From 3a18faf4ad62c46906a5b26decbb6d43ae240ea8 Mon Sep 17 00:00:00 2001 From: fhorse Date: Sat, 27 Feb 2016 23:58:21 +0100 Subject: [PATCH] (OpenGL) Supporto shaders Retroarch Riscritto da zero l'engine OpenGL per supportare pienamente shader multi-pass e il formato meta-shader utilizzato da Retroarch. --- src/Makefile.am | 1 + src/core/Makefile.am | 1 + src/core/conf.h | 2 +- src/core/gfx.h | 79 +- src/core/gfx_functions_inline.h | 36 +- src/core/input.c | 4 +- src/core/matrix.c | 72 + src/core/matrix.h | 53 + src/gui/Makefile.am | 2 + src/gui/cgp.cpp | 95 ++ src/{video/sdl/openGL/cube3d.h => gui/cgp.h} | 21 +- src/gui/designer/application.qrc | 6 + src/gui/designer/application.ui | 516 ++++-- src/gui/designer/icons/cpu_filter.png | Bin 0 -> 565 bytes .../hunterk/borders/1080p/border-1080p.png | Bin 0 -> 2633 bytes .../designer/shaders/lut/hunterk/hqx/hq2x.png | Bin 0 -> 2793 bytes .../designer/shaders/lut/hunterk/hqx/hq3x.png | Bin 0 -> 4665 bytes .../designer/shaders/lut/hunterk/hqx/hq4x.png | Bin 0 -> 11913 bytes src/gui/dlgInput.cpp | 9 - src/gui/mainWindow.cpp | 415 +++-- src/gui/mainWindow.hpp | 1 - src/gui/qt.cpp | 33 +- src/gui/qt.h | 5 + src/gui/screenWidget.cpp | 11 - src/gui/settings.h | 229 ++- src/gui/settingsObject.hpp | 2 +- src/video/Makefile.am | 9 +- src/video/sdl/gfx.c | 368 ++--- src/video/sdl/glew/glew.c | 6 +- src/video/sdl/glew/glxew.h | 2 +- src/video/sdl/openGL/cube3d.c | 222 --- src/video/sdl/openGL/no_effect.c | 94 -- src/video/sdl/openGL/no_effect.h | 29 - src/video/sdl/opengl.c | 1386 ++++++++++++----- src/video/sdl/opengl.h | 185 ++- src/video/sdl/shaders.c | 577 +++++++ src/video/sdl/shaders.h | 127 +- .../sdl/shaders/anti-aliasing/advanced-aa.h | 295 ++++ src/video/sdl/shaders/anti-aliasing/fx-aa.h | 222 +++ .../shaders/anti-aliasing/fxaa-edge-detect.h | 182 +++ src/video/sdl/shaders/blend.h | 23 + src/video/sdl/shaders/color.h | 32 - src/video/sdl/shaders/crt.h | 360 ----- src/video/sdl/shaders/crt/4xbr-hybrid-crt.h | 834 ++++++++++ src/video/sdl/shaders/crt/crt-caligari.h | 241 +++ src/video/sdl/shaders/crt/crt-cgwg-fast.h | 326 ++++ .../crt/crt-easymode-halation/blur_horiz.h | 123 ++ .../crt/crt-easymode-halation/blur_vert.h | 123 ++ .../crt-easymode-halation.h | 521 +++++++ .../crt/crt-easymode-halation/linearize.h | 92 ++ .../crt/crt-easymode-halation/threshold.h | 118 ++ src/video/sdl/shaders/crt/crt-easymode.h | 321 ++++ src/video/sdl/shaders/crt/crt-geom.h | 883 +++++++++++ src/video/sdl/shaders/crt/crt-hyllian.h | 305 ++++ src/video/sdl/shaders/crt/crt-lottes.h | 616 ++++++++ src/video/sdl/shaders/crt/crt-reverse-aa.h | 319 ++++ ...irst-pass-linearize-crt-gamma-bob-fields.h | 214 +++ ...rt-royale-scanlines-vertical-interlacing.h | 564 +++++++ src/video/sdl/shaders/crt/dotmask.h | 134 ++ src/video/sdl/shaders/crt/glow/blur_horiz.h | 123 ++ src/video/sdl/shaders/crt/glow/blur_vert.h | 123 ++ src/video/sdl/shaders/crt/glow/gauss_horiz.h | 158 ++ src/video/sdl/shaders/crt/glow/gauss_vert.h | 193 +++ src/video/sdl/shaders/crt/glow/linearize.h | 110 ++ src/video/sdl/shaders/crt/glow/resolve.h | 138 ++ src/video/sdl/shaders/crt/glow/threshold.h | 110 ++ src/video/sdl/shaders/crt/gtu-v050/pass1.h | 82 + src/video/sdl/shaders/crt/gtu-v050/pass2.h | 178 +++ src/video/sdl/shaders/crt/gtu-v050/pass3.h | 232 +++ src/video/sdl/shaders/crt/tvout-tweaks.h | 320 ++++ src/video/sdl/shaders/dbl.h | 141 -- src/video/sdl/shaders/eagle/super-eagle.h | 430 +++++ .../hunterk/handheld/lcd_cgwg/lcd-grid.h | 421 +++++ src/video/sdl/shaders/hunterk/hqx/hq3x.h | 199 +++ src/video/sdl/shaders/hunterk/hqx/pass1.h | 381 +++++ .../shaders/hunterk/hqx/resources/hq3x.png | Bin 0 -> 4665 bytes .../sdl/shaders/hunterk/misc/color-mangler.h | 167 ++ .../shaders/hunterk/misc/image-adjustment.h | 212 +++ .../shaders/hunterk/motionblur/braid-rewind.h | 162 ++ .../hunterk/motionblur/motionblur-simple.h | 211 +++ .../shaders/hunterk/resources/bigblur-1080p.h | 145 ++ .../shaders/hunterk/resources/bigblur-horiz.h | 203 +++ .../shaders/hunterk/resources/bigblur-vert.h | 203 +++ .../hunterk/resources/color-grid-1080p.h | 178 +++ .../shaders/hunterk/resources/mudlord-1080p.h | 175 +++ .../resources/shiny-iterations-1080p.h | 419 +++++ .../shaders/hunterk/resources/snow-1080p.h | 223 +++ .../shaders/hunterk/resources/voronoi-1080p.h | 254 +++ .../shaders/hunterk/resources/water-1080p.h | 210 +++ src/video/sdl/shaders/interpolation.h | 39 - src/video/sdl/shaders/misc/image-adjustment.h | 149 ++ src/video/sdl/shaders/motionblur/feedback.h | 138 ++ src/video/sdl/shaders/mudlord/emboss.h | 139 ++ src/video/sdl/shaders/mudlord/mud-mudlord.h | 128 ++ src/video/sdl/shaders/mudlord/noise-mudlord.h | 129 ++ src/video/sdl/shaders/mudlord/oldtv.h | 172 ++ src/video/sdl/shaders/no_filter.h | 154 +- .../ntsc/ntsc-pass1-composite-2phase.h | 145 ++ .../ntsc/ntsc-pass1-composite-3phase.h | 145 ++ .../shaders/ntsc/ntsc-pass1-svideo-3phase.h | 145 ++ .../sdl/shaders/ntsc/ntsc-pass2-2phase.h | 309 ++++ .../shaders/ntsc/ntsc-pass2-3phase-linear.h | 271 ++++ .../sdl/shaders/ntsc/ntsc-pass2-3phase.h | 261 ++++ src/video/sdl/shaders/phosphor.h | 96 -- src/video/sdl/shaders/scanline.h | 54 - src/video/sdl/shaders/waterpaint/water.h | 190 +++ .../sdl/shaders/windowed/jinc2-sharper.h | 451 ++++++ src/video/sdl/shaders/xbr/legacy/2xbr-v3.8c.h | 493 ++++++ src/video/sdl/shdcode.h | 169 ++ 109 files changed, 19139 insertions(+), 2185 deletions(-) create mode 100644 src/core/matrix.c create mode 100644 src/core/matrix.h create mode 100644 src/gui/cgp.cpp rename src/{video/sdl/openGL/cube3d.h => gui/cgp.h} (77%) create mode 100644 src/gui/designer/icons/cpu_filter.png create mode 100644 src/gui/designer/shaders/lut/hunterk/borders/1080p/border-1080p.png create mode 100644 src/gui/designer/shaders/lut/hunterk/hqx/hq2x.png create mode 100644 src/gui/designer/shaders/lut/hunterk/hqx/hq3x.png create mode 100644 src/gui/designer/shaders/lut/hunterk/hqx/hq4x.png delete mode 100644 src/video/sdl/openGL/cube3d.c delete mode 100644 src/video/sdl/openGL/no_effect.c delete mode 100644 src/video/sdl/openGL/no_effect.h create mode 100644 src/video/sdl/shaders.c create mode 100644 src/video/sdl/shaders/anti-aliasing/advanced-aa.h create mode 100644 src/video/sdl/shaders/anti-aliasing/fx-aa.h create mode 100644 src/video/sdl/shaders/anti-aliasing/fxaa-edge-detect.h create mode 100644 src/video/sdl/shaders/blend.h delete mode 100644 src/video/sdl/shaders/color.h delete mode 100644 src/video/sdl/shaders/crt.h create mode 100644 src/video/sdl/shaders/crt/4xbr-hybrid-crt.h create mode 100644 src/video/sdl/shaders/crt/crt-caligari.h create mode 100644 src/video/sdl/shaders/crt/crt-cgwg-fast.h create mode 100644 src/video/sdl/shaders/crt/crt-easymode-halation/blur_horiz.h create mode 100644 src/video/sdl/shaders/crt/crt-easymode-halation/blur_vert.h create mode 100644 src/video/sdl/shaders/crt/crt-easymode-halation/crt-easymode-halation.h create mode 100644 src/video/sdl/shaders/crt/crt-easymode-halation/linearize.h create mode 100644 src/video/sdl/shaders/crt/crt-easymode-halation/threshold.h create mode 100644 src/video/sdl/shaders/crt/crt-easymode.h create mode 100644 src/video/sdl/shaders/crt/crt-geom.h create mode 100644 src/video/sdl/shaders/crt/crt-hyllian.h create mode 100644 src/video/sdl/shaders/crt/crt-lottes.h create mode 100644 src/video/sdl/shaders/crt/crt-reverse-aa.h create mode 100644 src/video/sdl/shaders/crt/crt-royale/crt-royale-first-pass-linearize-crt-gamma-bob-fields.h create mode 100644 src/video/sdl/shaders/crt/crt-royale/crt-royale-scanlines-vertical-interlacing.h create mode 100644 src/video/sdl/shaders/crt/dotmask.h create mode 100644 src/video/sdl/shaders/crt/glow/blur_horiz.h create mode 100644 src/video/sdl/shaders/crt/glow/blur_vert.h create mode 100644 src/video/sdl/shaders/crt/glow/gauss_horiz.h create mode 100644 src/video/sdl/shaders/crt/glow/gauss_vert.h create mode 100644 src/video/sdl/shaders/crt/glow/linearize.h create mode 100644 src/video/sdl/shaders/crt/glow/resolve.h create mode 100644 src/video/sdl/shaders/crt/glow/threshold.h create mode 100644 src/video/sdl/shaders/crt/gtu-v050/pass1.h create mode 100644 src/video/sdl/shaders/crt/gtu-v050/pass2.h create mode 100644 src/video/sdl/shaders/crt/gtu-v050/pass3.h create mode 100644 src/video/sdl/shaders/crt/tvout-tweaks.h delete mode 100644 src/video/sdl/shaders/dbl.h create mode 100644 src/video/sdl/shaders/eagle/super-eagle.h create mode 100644 src/video/sdl/shaders/hunterk/handheld/lcd_cgwg/lcd-grid.h create mode 100644 src/video/sdl/shaders/hunterk/hqx/hq3x.h create mode 100644 src/video/sdl/shaders/hunterk/hqx/pass1.h create mode 100644 src/video/sdl/shaders/hunterk/hqx/resources/hq3x.png create mode 100644 src/video/sdl/shaders/hunterk/misc/color-mangler.h create mode 100644 src/video/sdl/shaders/hunterk/misc/image-adjustment.h create mode 100644 src/video/sdl/shaders/hunterk/motionblur/braid-rewind.h create mode 100644 src/video/sdl/shaders/hunterk/motionblur/motionblur-simple.h create mode 100644 src/video/sdl/shaders/hunterk/resources/bigblur-1080p.h create mode 100644 src/video/sdl/shaders/hunterk/resources/bigblur-horiz.h create mode 100644 src/video/sdl/shaders/hunterk/resources/bigblur-vert.h create mode 100644 src/video/sdl/shaders/hunterk/resources/color-grid-1080p.h create mode 100644 src/video/sdl/shaders/hunterk/resources/mudlord-1080p.h create mode 100644 src/video/sdl/shaders/hunterk/resources/shiny-iterations-1080p.h create mode 100644 src/video/sdl/shaders/hunterk/resources/snow-1080p.h create mode 100644 src/video/sdl/shaders/hunterk/resources/voronoi-1080p.h create mode 100644 src/video/sdl/shaders/hunterk/resources/water-1080p.h delete mode 100644 src/video/sdl/shaders/interpolation.h create mode 100644 src/video/sdl/shaders/misc/image-adjustment.h create mode 100644 src/video/sdl/shaders/motionblur/feedback.h create mode 100644 src/video/sdl/shaders/mudlord/emboss.h create mode 100644 src/video/sdl/shaders/mudlord/mud-mudlord.h create mode 100644 src/video/sdl/shaders/mudlord/noise-mudlord.h create mode 100644 src/video/sdl/shaders/mudlord/oldtv.h create mode 100644 src/video/sdl/shaders/ntsc/ntsc-pass1-composite-2phase.h create mode 100644 src/video/sdl/shaders/ntsc/ntsc-pass1-composite-3phase.h create mode 100644 src/video/sdl/shaders/ntsc/ntsc-pass1-svideo-3phase.h create mode 100644 src/video/sdl/shaders/ntsc/ntsc-pass2-2phase.h create mode 100644 src/video/sdl/shaders/ntsc/ntsc-pass2-3phase-linear.h create mode 100644 src/video/sdl/shaders/ntsc/ntsc-pass2-3phase.h delete mode 100644 src/video/sdl/shaders/phosphor.h delete mode 100644 src/video/sdl/shaders/scanline.h create mode 100644 src/video/sdl/shaders/waterpaint/water.h create mode 100644 src/video/sdl/shaders/windowed/jinc2-sharper.h create mode 100644 src/video/sdl/shaders/xbr/legacy/2xbr-v3.8c.h create mode 100644 src/video/sdl/shdcode.h diff --git a/src/Makefile.am b/src/Makefile.am index 7e07063de..588ba330b 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -15,6 +15,7 @@ bin_PROGRAMS = punes punes_SOURCES = \ core/main.c \ + core/matrix.c \ gui/application.cpp \ core/palette.c \ $(ico_stuff) diff --git a/src/core/Makefile.am b/src/core/Makefile.am index 7b42d3b42..937a0aff8 100644 --- a/src/core/Makefile.am +++ b/src/core/Makefile.am @@ -38,6 +38,7 @@ libcore_a_SOURCES = \ main.h \ mappers.c \ mappers.h \ + matrix.h \ mem_map.h \ miniz.h \ overscan.c \ diff --git a/src/core/conf.h b/src/core/conf.h index 0dd6d7e06..4800fa0be 100644 --- a/src/core/conf.h +++ b/src/core/conf.h @@ -39,7 +39,7 @@ typedef struct { BYTE render; BYTE scale; BYTE fullscreen; - BYTE filter; + DBWORD filter; BYTE ntsc_format; BYTE palette; BYTE disable_swap_emphasis_pal; diff --git a/src/core/gfx.h b/src/core/gfx.h index 1e1f12bc0..3823018bc 100644 --- a/src/core/gfx.h +++ b/src/core/gfx.h @@ -46,18 +46,67 @@ enum filters_type { HQ3X, HQ4X, NTSC_FILTER, - /* shaders */ - PHOSPHOR, - SCANLINE, - DBL, - CRT_CURVE, - CRT_NO_CURVE, - PHOSPHOR2, - DARK_ROOM, - /* shaders end */ XBRZ2X, XBRZ3X, - XBRZ4X + XBRZ4X, + FUTURE_USE0, + FUTURE_USE1, + FUTURE_USE2, + FUTURE_USE3, + FUTURE_USE4, + FUTURE_USE5, + FUTURE_USE6, + FUTURE_USE7, + FUTURE_USE8, + FUTURE_USE9, + FUTURE_USE10, + FUTURE_USE11, + FUTURE_USE12, + FUTURE_USE13, + FUTURE_USE14, + /* shaders */ + FLTSHDSTART, + sh_anti_aliasing_advanced_aa = FLTSHDSTART, + sh_anti_aliasing_fx_aa, + sh_anti_aliasing_fxaa_edge_detect, + sh_cgp_tvout_tvout_ntsc_2phase_composite, + sh_cgp_tvout_tvout_ntsc_256px_svideo, + sh_cgp_2xbr_crt_hyllian, + sh_cgp_2xbr_jinc2_sharper_hybrid, + sh_crt_gtuv50, + sh_crt_4xbr_hybrid_crt, + sh_crt_crt_caligari, + sh_crt_crt_cgwg_fast, + sh_crt_crt_easymode, + sh_crt_crt_easymode_halation, + sh_crt_crt_geom, + sh_crt_crtglow_gauss, + sh_crt_crtglow_gauss_ntsc_3phase, + sh_crt_crt_hyllian, + sh_crt_crt_lottes, + sh_crt_crt_reverse_aa, + sh_crt_dotmask, + sh_eagle_super_eagle, + sh_hunterk_borders_1080p_bigblur, + sh_hunterk_borders_1080p_color_grid, + sh_hunterk_borders_1080p_mudlord, + sh_hunterk_borders_1080p_shiny_iterations, + sh_hunterk_borders_1080p_snow, + sh_hunterk_borders_1080p_voronoi, + sh_hunterk_borders_1080p_water, + sh_hunterk_handheld_nds, + sh_hunterk_hqx_hq3x, + sh_hunterk_motionblur_motionblur_simple, + sh_motionblur_feedback, + sh_mudlord_emboss, + sh_mudlord_mud_mudlord, + sh_mudlord_noise_mudlord, + sh_mudlord_oldtv, + sh_waterpaint_water, + + sh_test, + FLTSHDSTOP = sh_waterpaint_water + /* shaders end */ }; enum overcan_type { OSCAN_OFF, OSCAN_ON, OSCAN_DEFAULT, OSCAN_DEFAULT_OFF, OSCAN_DEFAULT_ON }; enum gfx_info_type { CURRENT, NO_OVERSCAN, MONITOR, VIDEO_MODE }; @@ -72,7 +121,7 @@ enum no_change { NO_CHANGE = 255 }; #if defined (SDL) #include -enum render_type { RENDER_SOFTWARE, RENDER_OPENGL, RENDER_GLSL }; +enum render_type { RENDER_SOFTWARE, RENDER_GLSL }; #if defined (__WIN32__) enum sdl_win_event_type { SDLWIN_NONE, @@ -86,7 +135,7 @@ enum sdl_win_event_type { SDLWIN_VSYNC }; -EXTERNC struct { +EXTERNC struct _sdlwe { int event; int arg; } sdlwe; @@ -102,7 +151,7 @@ EXTERNC int (*flip)(SDL_Surface *surface); #elif defined (D3D9) enum render_type { RENDER_SOFTWARE, RENDER_HLSL }; -typedef struct { +typedef struct _texcoords { float l, r; float t, b; } _texcoords; @@ -136,8 +185,8 @@ EXTERNC struct _gfx { EXTERNC BYTE gfx_init(void); EXTERNC void gfx_set_render(BYTE render); -EXTERNC void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE force_scale, - BYTE force_palette); +EXTERNC void gfx_set_screen(BYTE scale, DBWORD filter, BYTE fullscreen, BYTE palette, + BYTE force_scale, BYTE force_palette); EXTERNC void gfx_draw_screen(BYTE forced); EXTERNC void gfx_quit(void); diff --git a/src/core/gfx_functions_inline.h b/src/core/gfx_functions_inline.h index 93b2a7619..92c6bb991 100644 --- a/src/core/gfx_functions_inline.h +++ b/src/core/gfx_functions_inline.h @@ -40,7 +40,6 @@ static void INLINE gfx_VSYNC(void); static void INLINE gfx_SWITCH_RENDERING(void) { #if defined (SDL) sdl_wid(); - opengl_effect_change(opengl.rotation); gfx_reset_video(); #endif gfx_set_screen(NO_CHANGE, NO_CHANGE, NO_CHANGE, NO_CHANGE, TRUE, FALSE); @@ -68,27 +67,6 @@ static void INLINE gfx_FILTER(int filter) { case NO_FILTER: gfx_set_screen(NO_CHANGE, NO_FILTER, NO_CHANGE, NO_CHANGE, FALSE, FALSE); break; - case PHOSPHOR: - gfx_set_screen(NO_CHANGE, PHOSPHOR, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; - case PHOSPHOR2: - gfx_set_screen(NO_CHANGE, PHOSPHOR2, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; - case SCANLINE: - gfx_set_screen(NO_CHANGE, SCANLINE, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; - case DBL: - gfx_set_screen(NO_CHANGE, DBL, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; - case DARK_ROOM: - gfx_set_screen(NO_CHANGE, DARK_ROOM, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; - case CRT_CURVE: - gfx_set_screen(NO_CHANGE, CRT_CURVE, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; - case CRT_NO_CURVE: - gfx_set_screen(NO_CHANGE, CRT_NO_CURVE, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - break; case SCALE2X: gfx_set_screen(X2, SCALE2X, NO_CHANGE, NO_CHANGE, FALSE, FALSE); break; @@ -107,6 +85,12 @@ static void INLINE gfx_FILTER(int filter) { case HQ4X: gfx_set_screen(X4, HQ4X, NO_CHANGE, NO_CHANGE, FALSE, FALSE); break; + case NTSC_FILTER: + gfx_set_screen(NO_CHANGE, NTSC_FILTER, NO_CHANGE, NO_CHANGE, FALSE, FALSE); + if (cfg->filter == NTSC_FILTER) { + ntsc_set(cfg->ntsc_format, 0, 0, (BYTE *) palette_RGB, 0); + } + break; case XBRZ2X: gfx_set_screen(X2, XBRZ2X, NO_CHANGE, NO_CHANGE, FALSE, FALSE); break; @@ -116,11 +100,9 @@ static void INLINE gfx_FILTER(int filter) { case XBRZ4X: gfx_set_screen(X4, XBRZ4X, NO_CHANGE, NO_CHANGE, FALSE, FALSE); break; - case NTSC_FILTER: - gfx_set_screen(NO_CHANGE, NTSC_FILTER, NO_CHANGE, NO_CHANGE, FALSE, FALSE); - if (cfg->filter == NTSC_FILTER) { - ntsc_set(cfg->ntsc_format, 0, 0, (BYTE *) palette_RGB, 0); - } + default: + // shaders + gfx_set_screen(NO_CHANGE, filter, NO_CHANGE, NO_CHANGE, FALSE, FALSE); break; } } diff --git a/src/core/input.c b/src/core/input.c index c42969ea6..a182d4fa1 100644 --- a/src/core/input.c +++ b/src/core/input.c @@ -379,8 +379,8 @@ BYTE input_rd_reg_zapper(BYTE openbus, WORD **screen_index, BYTE nport) { if (!mouse.right) { #if defined (SDL) if (gfx.opengl) { - int l = (int) opengl.quadcoords.l; - int b = (int) opengl.quadcoords.b; + int l = (int) opengl.vp->x; + int b = (int) opengl.vp->y; gx -= l; gy -= b; diff --git a/src/core/matrix.c b/src/core/matrix.c new file mode 100644 index 000000000..e78a7f56a --- /dev/null +++ b/src/core/matrix.c @@ -0,0 +1,72 @@ +/* Copyright (C) 2010-2015 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this file (matrix.c). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +/* + * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "matrix.h" + +// Sets mat to an identity matrix +void matrix_4x4_identity(_math_matrix_4x4 *mat) { + int i; + + memset(mat, 0, sizeof(*mat)); + + for (i = 0; i < 4; i++) { + MAT_ELEM_4X4(*mat, i, i) = 1.0f; + } +} +// Creates an orthographic projection matrix. +void matrix_4x4_ortho(_math_matrix_4x4 *mat, float left, float right, float bottom, float top, + float znear, float zfar) { + float tx, ty, tz; + + matrix_4x4_identity(mat); + + tx = -(right + left) / (right - left); + ty = -(top + bottom) / (top - bottom); + tz = -(zfar + znear) / (zfar - znear); + + MAT_ELEM_4X4(*mat, 0, 0) = 2.0f / (right - left); + MAT_ELEM_4X4(*mat, 1, 1) = 2.0f / (top - bottom); + MAT_ELEM_4X4(*mat, 2, 2) = -2.0f / (zfar - znear); + MAT_ELEM_4X4(*mat, 0, 3) = tx; + MAT_ELEM_4X4(*mat, 1, 3) = ty; + MAT_ELEM_4X4(*mat, 2, 3) = tz; +} + + diff --git a/src/core/matrix.h b/src/core/matrix.h new file mode 100644 index 000000000..0fc702c37 --- /dev/null +++ b/src/core/matrix.h @@ -0,0 +1,53 @@ +/* Copyright (C) 2010-2015 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this file (matrix.c). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +/* + * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef MATRIX_H_ +#define MATRIX_H_ + +#define MAT_ELEM_4X4(mat, r, c) ((mat).data[4 * (c) + (r)]) + +typedef struct { + float data[16]; +} _math_matrix_4x4; + +void matrix_4x4_identity(_math_matrix_4x4 *mat); +void matrix_4x4_ortho(_math_matrix_4x4 *mat, float left, float right, float bottom, float top, + float znear, float zfar); + +#endif /* MATRIX_H_ */ diff --git a/src/gui/Makefile.am b/src/gui/Makefile.am index d8ff9beda..a0ceb4ac6 100644 --- a/src/gui/Makefile.am +++ b/src/gui/Makefile.am @@ -36,6 +36,8 @@ BUILT_SOURCES += \ noinst_LIBRARIES = libgui.a libgui_a_SOURCES = \ application.hh \ + cgp.cpp \ + cgp.h \ cheatObject.cpp \ cheatObject.hpp \ dlgApuChannels.cpp \ diff --git a/src/gui/cgp.cpp b/src/gui/cgp.cpp new file mode 100644 index 000000000..d323f1c4c --- /dev/null +++ b/src/gui/cgp.cpp @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include "cgp.h" +#include "shaders.h" +#include "opengl.h" + +void cgp_pragma_param(const char *code) { + QTextStream stream(code); + QString line; + _param_shd param; + + + do { + line = stream.readLine(); + + memset (¶m, 0x00, sizeof(_param_shd)); + + if (line.startsWith("#pragma parameter")) { + QRegExp rx("\\d*\\.\\d+"); + int i, count = 0, pos = 0; + bool finded; + + // sscanf non e' locale indipendente percio' lo utilizzo solo per + // ricavare nome e descrizione del parametro. + count = sscanf(line.toUtf8().constData(), "#pragma parameter %63s \"%63[^\"]\" ", + param.name, param.desc); + + if (count < 2) { + continue; + } + + while ((pos = rx.indexIn(line, pos)) != -1) { + switch (count++) { + case 2: + param.initial = rx.cap(0).toFloat(); + break; + case 3: + param.min = rx.cap(0).toFloat(); + break; + case 4: + param.max = rx.cap(0).toFloat(); + break; + case 5: + param.step = rx.cap(0).toFloat(); + break; + } + pos += rx.matchedLength(); + } + + if (count < 5) { + continue; + } + + param.value = param.initial; + + finded = false; + + for (i = 0; i < shader_effect.params; i++) { + _param_shd *ctrl = &shader_effect.param[i]; + + if (::strncmp(param.name, ctrl->name, sizeof(param.name)) == 0) { + finded = true; + break; + } + } + + if (finded == false) { + if (shader_effect.params < MAX_PARAM) { + ::memcpy(&shader_effect.param[shader_effect.params], ¶m, + sizeof(_param_shd)); + shader_effect.params++; + } + } + } + } while (!line.isNull()); +} diff --git a/src/video/sdl/openGL/cube3d.h b/src/gui/cgp.h similarity index 77% rename from src/video/sdl/openGL/cube3d.h rename to src/gui/cgp.h index b15c04702..ebb3b4710 100644 --- a/src/video/sdl/openGL/cube3d.h +++ b/src/gui/cgp.h @@ -16,14 +16,19 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#ifndef CUBE3D_H_ -#define CUBE3D_H_ +#ifndef CGP_H_ +#define CGP_H_ -#include "opengl.h" +#include "common.h" -void opengl_init_cube3d(void); -void opengl_set_cube3d(SDL_Surface *src); -void opengl_unset_cube3d(void); -void opengl_draw_scene_cube3d(SDL_Surface *surface); +#if defined (__cplusplus) +#define EXTERNC extern "C" +#else +#define EXTERNC +#endif -#endif /* CUBE3D_H_ */ +EXTERNC void cgp_pragma_param(const char *code); + +#undef EXTERNC + +#endif /* CGP_H_ */ diff --git a/src/gui/designer/application.qrc b/src/gui/designer/application.qrc index d06e7bd73..60156fc3d 100644 --- a/src/gui/designer/application.qrc +++ b/src/gui/designer/application.qrc @@ -1,5 +1,7 @@ + shaders/lut/hunterk/hqx/hq3x.png + icons/cpu_filter.png icons/buffer_size.png icons/fast_forward.png icons/application.png @@ -53,6 +55,10 @@ icons/recent_roms.png icons/open.png + + shaders/lut/hunterk/borders/1080p/border-1080p.png + shaders/lut/hunterk/hqx/hq3x.png + pics/Nes_controller.png pics/btn_donate_SM.gif diff --git a/src/gui/designer/application.ui b/src/gui/designer/application.ui index b17ce654d..876e9be1d 100644 --- a/src/gui/designer/application.ui +++ b/src/gui/designer/application.ui @@ -132,7 +132,6 @@ - @@ -237,13 +236,13 @@ - + - Fi&lter + Software Fi&lters - :/icon/icons/filter.png:/icon/icons/filter.png + :/icon/icons/cpu_filter.png:/icon/icons/cpu_filter.png @@ -258,13 +257,136 @@ - - - - - - - + + + + S&haders + + + + :/icon/icons/effect.png:/icon/icons/effect.png + + + + crt + + + + + + + + + + + + + + + + + + mudlord + + + + + + + + + cgp + + + + tvout + + + + + + + + + + + waterpaint + + + + + + eagle + + + + + + anti-aliasing + + + + + + + hunterk + + + + hqx + + + + + + borders + + + + 1080p + + + + + + + + + + + + + + motionblur + + + + + + handheld + + + + + + + + + + + motionblur + + + + + + + + + + + + @@ -285,16 +407,6 @@ - - - &Effect - - - - :/icon/icons/effect.png:/icon/icons/effect.png - - - @@ -302,9 +414,9 @@ - + + - @@ -698,20 +810,6 @@ false - - - true - - - false - - - Rend2 - - - false - - true @@ -1057,62 +1155,6 @@ &No Filter - - - true - - - &Phosphor - - - - - true - - - &Phosphor2 - - - - - true - - - S&canline - - - - - true - - - &DBL - - - - - true - - - Dark R&oom - - - - - true - - - &CRT With Curve - - - - - true - - - &CRT Without Curve - - true @@ -1275,14 +1317,6 @@ &Load from file - - - true - - - &Cube - - true @@ -1963,6 +1997,286 @@ &Pause + + + CRT + + + + + true + + + gtu-v050 + + + + + true + + + 4xbr-hybrid-crt + + + + + true + + + crt-geom + + + + + true + + + crt-hyllian + + + + + true + + + emboss + + + + + true + + + noise-mudlord + + + + + true + + + oldtv + + + + + true + + + 2xbr-crt-hyllian + + + + + true + + + 2xbr-jinc2-sharper-hybrid + + + + + true + + + water + + + + + true + + + super-eagle + + + + + true + + + advanced-aa + + + + + true + + + mud-mudlord + + + + + true + + + fxaa-edge-detect + + + + + true + + + tvout-ntsc-2phase-composite + + + + + true + + + crt-caligari + + + + + true + + + crt-cgwg-fast + + + + + true + + + test + + + + + true + + + crt-easymode + + + + + true + + + crt-easymode-halation + + + + + true + + + crtglow-gauss + + + + + true + + + crtglow-gauss-ntsc-3phase + + + + + true + + + crt-lottes + + + + + true + + + crt-reverse-aa + + + + + true + + + dotmask + + + + + true + + + hq3x + + + + + mudlord + + + + + bigblur + + + + + color-grid + + + + + shiny-iterations + + + + + snow + + + + + voronoi + + + + + water + + + + + true + + + motionblur-simple + + + + + true + + + tvout+ntsc-256px-svideo + + + + + true + + + nds + + + + + true + + + feedback + + diff --git a/src/gui/designer/icons/cpu_filter.png b/src/gui/designer/icons/cpu_filter.png new file mode 100644 index 0000000000000000000000000000000000000000..3b728cbc6038b9d2adc23287599bfffcf90fff20 GIT binary patch literal 565 zcmV-50?Pe~P)nC0#^b8Qvw1_0s%e&05Sj_9UUHB9wTBSCub)tY%DD; zEiQvDFmNz2hA}cOCNeTIGKVrVh%-1iI600vJUl!+kvu(;Jw84@KR-V}KtMy7LqtSG zM43cJMn*?RM@XGWN}ozhp-fIrPESuyQKnH+Pe)UzQ&(44SFBfAu31~KTU@bRU0q#Z zwP0akVPv^vXuW7|!)}P8R*KFh301|XkPE!DmnZ3Thz`?@9#KyDGR}-z0mL0@D8eY6u_3b?>Kv%u;Ufp6j|E-;kFXAiLN-My9H&=IF6oWPzMD zsSh<#6t!V}V&#CmzPNQJ321&-r{W{puupdbaOZsntU3Zw#1oHDIr z_40mfG1DSI4QP7PkJ9vj0!ru3_^Wd+0rB#$IR3l@Vg?3oVGw3ym^DWND7L`U#WAGf*4vAWoCh3u4jh;@ zr(Rn>Njm<}+$M)-in)30AM~3a^Yj^8oO@s~V2s~2A3k&)EMz+_DU)6>XOuA-2%{-s yG#8BKg3(+snhQpA0WEUD_Bw;z5`&?!!Ty}>FN4O9v!1{P9D}E;pUXO@geCy^>><1W literal 0 HcmV?d00001 diff --git a/src/gui/designer/shaders/lut/hunterk/hqx/hq2x.png b/src/gui/designer/shaders/lut/hunterk/hqx/hq2x.png new file mode 100644 index 0000000000000000000000000000000000000000..a49c0f484acac6dd1e1a7bcf5b82f27b19655645 GIT binary patch literal 2793 zcmZve3p7;QAIJAGGVaKXZb@l0N)Lr}i95)Q{Od|8dPqVem5Riuq)c-TD)iEWEG|*% zdL?do+@zUtNsp;?E9FsUjFG%&WZsW+XS)A?YyH={>#TkDS$plZ*KdEnzwc+AjDU?k zrZ`I+0Kn9D?dr_{K)O%hWo)E-OTx-ny2&WQ&u2A2^-s~GlB>FvAL7;q9|pi=x_&?) zFMpP95qrdU!y0Ul(To|+^DLzKfdJqVd{?j9n%FfO)_vucJN`wM+hW%`l^V@_)!HgO z60EW|nfkc$tlx$$Lpf1U!hEigox>j7S^#cr^-5-~zin0DT=b`KL4x%@Hf4#>Xutn& zL)(v=mG7ty>a|$e<7B?pT04aw6v)I=ljU>yu&p9`3UhN)0djLQ)0`C<&@MKA&3kVhn(An6s6Db= zU6n20VOi4*%~+m~V?%4rq=~jJ*G{C#XP=bhh%+n;t)nz^7EURu`;TNN>@ZsOI&G4+ z56!a7%7eg?liuRM!K!SHbGkpEJ?w-{nXkf7zronjyN}y28uQnNw};11|9I*U>W}PJ znizJz>I+u?q{?ZPK%bgRK5V_fW z3Urb5XUlz`%?Z>TtJLCr3!f@15P!h7j<~1M*56|Trx9%bs#A9v=rILUU7KpJ8FZDu zl!w@rp76qC9hm3UbIAAEcsyeWs(zPzO}ub+0_^pnz&^Vyva0Vm{Zk}*0(qYreX!bL z1+Ps0NpW07z_tglV9q+8i)B^qNiaPT$Airy;fl7oxT6YMs*-|@A2pB%jBsn_dV9As zRq-BciWl83ZQC1KcK};syRIw$+Ntsriav2jBb|{F6ZD1qIn~*t)@ym0+19D!v`2nk z=JsK47i9!^$4a}OD6frr&uH4 zRAdpxexgE@UH-s<*7b1C>&j4uQHm?B-RkCi9*^A(k7)x{GL+1!8%@LcOHB9{h-1RC z%@@#L`LU{YR1yiawlSUwSED!Ynp_zcYhX6-(1V9B)>=^gqlRw|J|Zw|nOl}UlvH$@ zv&)7meVd&{Plm^bVUHTk)fG=4H2b>-R!))xFn(?0VKG-xAPSpl-e5(6&i9(!@?aNh ze7ftCDkh(+6r^TorN`;1c)lf(Gdw~fdc}bz$Pg919(o!b?vs< z%2^NQYj7KO_53ALZzQ(-s1@q3PL)CI%l?n4A*jzN?4tRhlw(lYN=DpNIxWyBjSb$K zjHF|X^%EbsD)=5Ncz&W(Ob6YH`3g(5!H45ft3D8g=YJuCOP-|0Z2z;E#F(+ z>A;!LkhqY2pAQ9T{t6{p)(&ZX1vO-3ZjY7r2$8du0tUc*5@*7_@m|5<;-&BoBF9Nv zM+UhkX4iY}e5nYio@@}DFI6bM#K=dJ;tkkSH!i5P;M9K( z6VobTepNGVH=N85`AWL+FBP|9lLi=odX)C9;t`X$b_NK_#H2HTov5AWGV=NS76lj@ z7yrJ60xI*G#PvdqE$yYw8O#K<{$wWgTIRe7D8CV}K2MOB3>b#ydAG8_haL+))oz63 z1`+OrXDrBf*OtgRVh2uLK5~4wikqVKbA##yxbEL` za3rYD1G~J18bL!UK4Z4ucLe7&x7XJsIjvfi(QPZEal2(xI?k}WSs-%Rv_GZAq%r^4 zYvg!Xd0hQlXu@#NeLJS}Hn^6mzAW#P$Rup5F0HSn@MG`dU(2^CGskGClRBQcSiS4c z$qJsY(*Hg0QQ$A*j(Rt|I==Ox-b}u!8<>5kd8lAy@M5_*;-0Z}M9}Z{iCf0^#0sS3 zl|kFk(fV|n=?J$u)la9 zDpS^9E5H7^>>AaM@#NuEdggfH9p=X;yH*~A*^DqI!&W=sIq$jHi3}Yp0@i#44wRArfFFr!#jQuxGwolV5` z7RQ(F=Xkuro(HWbMIS~8)E3eZd{E^#)aR$1^@UnT)eMXD*&b|Z(6qf{Z;Hc{s&l`X zeT$^A3j04mHrim#6kr(;^RnmP~ged%X9)_kZtm|Mz+R&wcK5p0oXazvrCq^ZkB5%Q;Ep{f@HI zYSLn2VzPUkhzG>PRw0*S=@?1mIDWh=135|hIXe=?;FXP8U2p>#S$*E=&>v!AG72mE zDzQ8F)+2*bp?h5&q<%;$Dw<)`B(6hZV%WyL#N8g3duDz5zUFGJaXCwmhMW2x7(}je zb8#TYfKP7RHPn>dljwQ1n`-U11?OiGzvhOv_st~P3~h^FQ?vcBNN11Dw_-QPui2?4 zjjup0Gpu?i;FS%_+pW}Ks}kVWTXoZ4UY$U z@H*Q7>6&waZJKZbzGmw%OBH^=!)L=2{CPh~0x`tvSl7T%+EAy_PaEQiwrTUvLQ%=N z6BC{EUorS9!Q{{3sUVpj8t0{IIuxv{^lJDY7V>y`Md4us53*gktllnO>scnc<|FKz zZ7m0A4U49JnQ$Zu6(q>>0A2o z{JR6_2hEj}9^%{UqSq!13}3*prkmJe2ZX%UN2DH|qC$L9pqREWB7vOWzdBh+;*?hDJ@vX%2)7$G z_t;w&F`ajr+f`d|t3#?MNusNG%CDI2>bfrx8{!3BOZ2f`cBKIQ1a#c0Ee*c>!yy2zVmPlJ8*3)J3wXNxy9#239YRKFV7g96c-Y%kU7kgoLbD^4-EU$zfySAd&J*)>OIxA!g8rc%n=7fVB`VzX?a z9|~52QlI-dBep==5PPA@c8?pWlQS0*Z~o?p(DZeY>iRFjer(k8hVQb4xiw3t^MA09 zE*uZv9%6t^%x?2fw90q5Z3}P5eJmwa3{n*E4M1|@@n#oMR+#e={x|eG*aIYkMM624 zH4RV9+`sx;P*@ZG<&T8?NzYW%qgqiZY+h~WgvbtSywCKRiRb#5BEg7HvcZO7_m zCH^6SOQ*x4eHTq|6t3W~#QBKgTvW9XP)+$6Ni z%R1w%?sMM8?N4Dfuyv!`}dUTmmvNxSSjv4D%PyPZ&*S|jAG*&|&u zaPjPsr(eR(;p|M?r_1V3@8^~G-xcD8?|;RtpZSwp%KqqbLI|slL5tNXjP0zW#Nq5% z_O`>1l^LU)b8l;!f)|%~r7WOsXEtz2Y5j2^%`n7ES(+uvVMUA$4rj@X;8lT5`5!Od zy`6Gcyu5BaY$Vm7msAlWP?>iWuywGevUT_13)%CW7Em=iKEr>*3|}Pd!oJW*7{B4a zo<86VkBiwc&Rqnz)eP)~zS(EGqYaAuUwUElEn-{-3oK$};c979)&rnO*~1sqEE*~v zrMO_7*ptc~6rA@bdC^)$9Ik=8XCaRpeWz%_)RlL*iDe0UCFAokrJ2AUn@+|?ydsr} z>A=B`!wER~M1t}9XV-08u_kHV#ls1S1m~%e$MFp7wasuik$HVN0Y|QfCsYXN*p;;^ zNF{y-X`!eXVz@{Os}~4LW2rm5ui(=08bx_dpY5@Q`8c+b0qPnz2ZM%(Xap1B#w7m1 z1mhvbLmk+b$i`bh+~RTgrvC4iTa(lAc{gS79;9>L-5DYLqYW9A>?y?(iWa0(6FW#+IyN6P>30!XZ?h4;nM4i zm8iFPY|9iI2dx7%n~vYHdTE@kD6As2#Q;^IAEIIq=y3hCZ%dTNU)8`mm6tCG^OTMq z80r$WzGw0MJMWWW=W)CQrQCds4v?|_+iULqyCkT%qu;grE?KF$jKgV;aY6bhpP&9E zl?JFx_tN)E_?M|=qbw=-IgM~w6r6+cxQmg%$*&1JUf1qhA-*$ce8As$gKT_mZHtic z3}fcwf6C!l*;U5-d+#zLbZsVp1W?lr{p6g)JnJ_!O%R8NU$NI~_X|&%q z4<{hm{H}4yCu8J4sN&fOb_?J|D&jV|MBTUoyN#wLHW6UwrecwElV+W+`n1<=^#+y- zWuwTv306pg2LJRO)v9PanIkopJpiw{>JxV>y5In^D&B6cbs+}SdzzrlBn zyJwa~s&8udU7$<0YU46@s%^`{NH{Q?RZaxu)XOe%7n$@@@dNm*X-qOCxv{w-6BWSY9vRTQMh2`Sj}r)bgx;8*xS7>*;*zAZC3Mr79U0np!A4>e03S*_nwdH~(?j+Kie>p_U9 z_B#I2>4mn6M<{C_O|Pf_gn+IqD9}T7HfqWY&C^ry;Pf*7r1aMhEx6Cd%lPkP+Y0^5 zjxB?cN{)#;p1Qy7;pYer@N@XygA5Hk7f?W0h>WmLuFN$uI=0qV#Y~=hMGjOSMj|I_ z>7jzw|BoV0thY-fgrZ@R0V?3yokO?tQ*oaxpbHMnGN{}GEl?}2hYIQ$_kn`9Izv`( zzVE~8Ng%3#+oFfc^gxHWj~IG+YR*G4_XO#`j#&CWna3 zpG?Nm{;(-U?*3(p7rLeQx1V}n_OEb`7D^koM9lL(AE%vaGXvt>U`^Su1+Oa)X#_{b zi{69%Zdknr);*k@zQe{d&oH5D5C~){x-A+^bu_Xf;Xygr94>IFeRJs0i5GurtHcx@ zRd##x>0x6PO^0~9Q{Ok}KcUV})8w;~5F{f-XoObCaOJ&!!3SQ0)jNV@It@R!;ybif rCjR>7s=tQDeX5nxLcY0%V5uPSH=vYzggf$+M{KXde&Ta`-`IZxzg{uP literal 0 HcmV?d00001 diff --git a/src/gui/designer/shaders/lut/hunterk/hqx/hq4x.png b/src/gui/designer/shaders/lut/hunterk/hqx/hq4x.png new file mode 100644 index 0000000000000000000000000000000000000000..18abeb31023c5cddb9a17aae23fe60d39b87b2c3 GIT binary patch literal 11913 zcma)?2~-o=w)ZPWi31oMkU>mTT2WC@QPIYvP*GG=9J&QX4TuVg3WAD4NKkA>Au1x` z6p&WzR*Z^(2qYkri~&(bA&@W%frKHckV@4%(6{fs-}l~q>n)c_R;ubyIcJ~${_X#+ z@V$HNbfy|jg&;_0$9CKO5JUhU3D9IM@OH%K#VPQnb==<07Q)B=CFCT>fN!RFZ$IP< zLDOc9{U<;V9vOfyNf&qQ-b!lGnmv1sp?BIlZ3vnV?XcbS%aumy(YD%`OSB&aN!5b> zmZ=TYpoLGbyPOjg`6`%YX|9tKXWxzYn6z+0bpoNn2%2*;#qdGmipfy*7Po!T((uRU zj!^ChNdYN&_u>?55om!+Y%6i%9$B8fdIj^i`&?Q0ymd+0nx(8IFE^u`i1*yVi=9+7 zDEP`>hdHVkMz|6B08x6drwdM@8R>BAGlf62bkeO!PQ>{x`%c*q=4;)DmN3$*jOMQm z+Q4j?;14Y@H~a88MVbeBK>G~o*Py8*1Q)IK=Wz=E<(Y6Hv=cS8DU_NzlJXn$)8Inh zTT`3gu>Jc~FEq|rTw`4kz6`gQux~oV1g7Ab3d>>dTD(y%TFr9H{(5Y|$8F*soU~X8 z_wfZ0xe>XEyH?(FSsq3>?xeNqy^q!|U&Hf*6I%N=K`t7R4>LWYK4cIQn@;`}fo3v) z?iCbw8L)@z2{@IxXan;VkA`OA8|kx-%-sV4YZMT=viyi{{?%f$K%8!Dv+BF6~A ztc4DI%onNo{_N(8LQe5_J)}=7UA|?8IJ|LBJEBm>)eZjukqkI*>C^=vdK zuh38FEYrKGgM~H}7(Ed4f|m0q#d{0fQD4nmS#pDUrUUtf$}wW;t_=qo?&Reruxog_ z>US@FChIviawewlGO*c-;BASJO--4$wo%*jp~N?u{-LGxh`trQJy!NJ^52DA|82y+ z{s6*1a@_0CmfP1(K9HB_L|J0ow_Z`~NIXaEwX(Z}zYuGZn*JkZ0ExhUI zvTM)R?pPx1{pr|5^zD(HUz*4e=GsCsZh%)Ew)H%i<)M6=Qz4FPoI7eIJrvjRMUjm7 zs`uR>2jSODnU3^cc21xt+Jp|w!cDi?CyTjWcv9Zj!meYvXMbfmZM&U3yDwuA*%bjJZr?ZJW^4zKu!4a@!^|W#VdtYU%qnfRY&txuqqR4$s=`2Dlp9Th8`RTnL z{#wHg$9>7vtLTCPlc=&Ioz3cXXP4PrxhA{WnV`Sq>}^Q5$U|%M^?B z^I|qE&VgZK{fFg;TC#Y^;eZaocAQyEZysFx!~3_HYN_InW<^xFi}r(+Mj7nIE48Fr za}zu=R0i=G&fB#+TAI%{2F@^S=mQXT%_Okb| z^`;w|F3$%!SC?7i(Q@gjoB+QrN`zdjxSPhc(rg-~$T-EYWAQ$mW-~c(WLO$iW+y*T z(=NFu!JnQpn%YN&j_ot1x@12UbjXGHv#vag+-g0=DRt<~8w#4qEUkWZI2W~tyy7SWLgy&_w-+k1j zQxfLD-!m%Y89Q>!G5Ni7QM4D{qIJdW=pN6&^d+f9_D=%-4Au*(Ra-`^(r*fm?Oo!R zyV*7K^y>M}#|1-#R6n&|+CXCbmP2}@%GI`KcwXfgrGHYuR~Uh&t^~C(zAa3JL+)tx+?K}o6uP&9%|O?9dfW= z)5zNVYK7{z3%r}J9+$Pp9bTk(A51guYdel!k<2QsWrvcS4)ATCNJpyY$jF7TVv7hNT#jlFx*S=2kEWRwHc|rAzqE5bQ z8LMthh1R}6yK@^O@M=j^HAJf5CgoP~eacgPIL zp5>a-XzJkBcVA5@z7)EyQ?^U8<*sbnBXeGAnY7RHQGhI8BdH53D&p=a%f=>kp)JnPjXS`7_+B41g`I!jJ+HHch2JKyNKE3WvJP^-J0kVG)%&NW~L5R^_w zmnx$j2i^;`*q@qm9n=;IxX51mP%S#=lCK2H#_!NcZ92&8%~ejfZ%9$w)1U_` z1cGgBr|}1~721p!#dGC^*6?1L??~v7(yvvJiko1x-xhUFD}Re~Z&3S{pBzLZU1IhK zBK(H`)R*os4B3(srt!N8H(o?iY#h~F=z?y7aU;(mk;$dx2FmqmLBYO{2HJwXsIjwY zK_==I?CHXnJ5cZoS3*xox279Z6JMML*Q`-+!HXCS!m&u`CX@^3ptCHhiQUK9xm{oo zQ5ErnCH9o`ril$Ur#>Bt&gmw!4)hYf>#?hex-_Vo=%EVgCcIKwKPBl}M1i}~VSu@8 zjidw(2=>#{C$s)9ul@DOC1} zr&TP^M;0N?tT(pgpe^RvFEk#!O2aN8;Zx@)sXd~Yo_UEFqE){Y?UGi;TtcVhi4n9-drVt)?3?=OoCalF)V9H2% z-=7@s%jkM0?a_$fGMW_pWSaqOuRa0)i9X71HwpgrzN~p-mrs(Z**tex9@TZ?M*oh9 z0rYoMm8+;bmgQv(VN*6D)8AIlxu8$QF34t5-8CGUY4$R7c$bVo&!r2pipiusUW0<4 zu_#O#4qMjK*1Q~{7VtH`=!%=PG0b4J)fJ04+>>bNF;&|E{)P8FZ`wpT#*UZC^^u&M z-vpNg`t(zoD^lyH@~7a<7=T2ciYy>IXe`17k55A9l>#Sn!djSlhVhV^W5+^LRo@;{ zg0^}HPU>_xT;)~{P@YVgT`xofAILpb=nTwIU5jKOA~Q@Y_(`9qYPdl$>#;)MgJ#?m z8F-z-2`UuL~xAplvD+7zldZ@ZnYD07flYQK&-_u zGyUpQlFU*r{ISb?%&Sa>9&tQSJY8U>y&J<{U8o11H==RlE?#3)CUz>UkS=M^CRUiE9H2gYl zB@gwJ-yRn`M!ST)5X#}c zo6nPrY*H6u4={W&dIuqU9}feomo*q;^3K|g?Zp~Nqd?14!zl=XN5-<6EEH5v3xA+b z^O5nT8~ZR%2BtSvqfxbi8_tk`!}ai&;f$etB3PobF`-L>!1Dg=0;K1;2CQd28@z;p z^8_2gy61w`KkER7Y;7FM7=ik40?q4Fh}tHqzWr;&@jteL3Kn^UWj73opWW^zyl;!7 z_t$xOEp zOGc(zuHrZ2hnaqYNsPSuR`#EyT-UTac^UI(^($|(U$cp59BOQSFzGukBa7>v@G( zW{-Yv%ZH(?j7Y^cagq=ViiYaX5ZFdIImt`#R^U9uT7XmdKWu}-sr6?op2 z{lAkb7ql=^Qm*)Mq<*dlsq)sgZ-fhU++ z{CmC~MUX^++9rLnd=PwW{)-nIw^{1W{Qgq@>wb|Q5|BBH-=v2>T@)Y#{WkY=u8W8_e%&%3vFr$})+> zfTK8p%9WlcQ-|^@upR5(H{yFxeA7@VeBjl z3qIKFV7Msq{io6EqOFh4OE9snNe`XY9=!s??`bDw#kQ1b;*)qU#iloc=rLPzsJ`slb<*U)iUVOU8+ z+E~35^b9TN`r6!pVQAe@s{Wwd?y@`Q*8;nNJ6yglaEXv-{*bejGn6{eLuhYg1Pi`l zLG0g2y0VW-!7Q3vis33Me3wY28l5`v=8Mza0l+X6!@ds}n?SxGuJrWiylq%IG?eT! zdn`*xzu1ct-!4%WiE4JW!@J&d@tpgUjgtmh=Gs&Z~5E0rr|=V}jkrLqTf4gi~em zA>;#Du%F!e0>6+z@_vi|<_~p0CwYf(z^c`WdA%TV5*~AKjX$&s1KWBs>biA(i7D4T zafsQe?i1u_j$0@Wsr@=k9YoeFXV!?9m!Li}uoi1r3TH~VHRZ)5gs||iEcU`7*6>WG z^4Q4F=n+jDs+orj^xFyu=zOH z+6+UwG-sJZHVCyyO@*p0IeHE)h#QTc1R3T1KZfAy;%4A0Qlt#c)3h4107`dy)8i*{?8 z#TkL?!e6=x+2tQK*S^Hn5GN~E9XrE`(ZGe&f<;Uw@tsz|;rybGPJ~-vs2o zt^*Mlr$|991<+vr@3N~Now>pcbL;A*OpjCf_r-v6T;i7ubHBVPw;cr%R;Re6s#dp$ z!dwRJ9K39($s~rsFJhSq)JFj`3clfVd2$Iq4L9afDn}XCn6o5<#uA%`6zpZ~IW~AZ zZ`m&7{B_^V>X_K*R4!8FyLxkR=qaJy!8X2M#8i2Tg&DMQ3ftDX;3yL*&a-De8i7A? zWq-7ur6p|*K73m$Sbj;KC5P(bw`O00?5>NbdP;nTeGiVG2wGNu{?qNA8=0thsh+z|>}ZUXEg3J2OW4xi6K)nZGYuMdi@B~S7|NOp{Zvd-)A z7@mX<=6f+g)UkfT4qd+mhM=uxlMYFMk6kI`CzEb@vURY7Y9e-95 zC?o7&g(W1o~5AdNO0iho+<2r zD4-#f+-5mE7p^9*Hv+^NMA4Y~L&=^1EANdjU+Y6tkS1=SGQgX1!2l>&(!uvEP)5uW zvkMpbLn#4&l^XZPN^!7O&T5c0rH0X0V7|V1?&A9sMFz?S6FPtGjoaay)hQSF2G6&$5Re+CXUd)`<}Tj6fWEZ#qdt5oHs2h;=dHE#YmL^KTNUF!(bwE`jkDq1;CMj>D^H)(?^ut4 zRg_8Db-yKIg7pVHBe((LtYBElEq34B2d_pZX&f|Shcn?0KSbF^$0Y8G zq;qnMJTAA)Nhvwng2yApm{1XkND^?>8kRXWf^>~QUr^cEFqCCm7;p#S@2{EBeOlNU zNj`d=%E>g7Z8!kWZt`p6^)g0z)(ZS*?EKwI#AVXcdVDs+b#YOKnh`nBpV4Y&Fc)=D zDe?qL6_*FMdZl@FPB`+2N>AfejF-|4=#P6N!w;W@xgOf0I?$3llojeeVUptB+S!IT z(0*Ul5s*Ff2k67T>23SbD^ll3?kG2(bY)bzbwjW~RT@ynUioBp zY(s`CN#KrC3%L!Cw~&!YA1y&69*o4b&XT_;T^{*q;76}S80j{3jlQpZpb<*uzi zb4VL@iOK8|Wuc-!+0Nu#p%#Z)3d{i!cKXq6!<(CCZIdX36N?hkOnqMvS3j;fFTx6~ zJA<31u%}~3DAB`{S7R2^9>C1x2abwRIce!GJBrJp6{SF&b`4oD-=A3@4aXcvnoM4= zSMg)^J98> zj%qi6xEH>%$-0{vw7>w#>WGn_zWbnz_q(@T(-3pbA|%9{j>8!nF_i$|Z_k4@glV|u z0Kkgwm!!P`X+H?>$Lu-Dp+2X<)8CJTFm^z@|M4i;8j1zlpIu*Mxdp>sIRgI6l?yK(U z3S+F&Dq6xrw=GaQ>KCwuEacfZG2dYrC`&pi^?G2|%U8wRrw{au>&(Ex!3sV)N z9@CIekZmMRWE-7{%GG&+>sG|^e))uiOQT1iuemFEvdJ^5$RSsM6D*Q%TJ|HQ%4X=6SN zJx(W+JT^nGkNHDAgFk0|uN-jk$|EZ|43h_2LAAylu?$*)szgn)OTH|{W;*t{zwd$) z9sUg=SQJ`(Bd%OvSWR7(pUIX zntwkR_8@P5dwi)WVni zAt@6bs3V5S$BejEve~Dlbe{y_lQgeFueW|6$zI&FzPQ+{fP97ammlpi#@==({EDy^ z^oJ)6`em@kSx!7gMg1}ueei$e@Ro57zee&VVb*F`EIQzHoS$o~#&>{P#{yM3eY%YD zD0t>5xAzqksUEjgjspM2CG(RWEohIzuPYQ}PX=eqgP|6n5>;FCyTc#@t_5|U_iT_G zo%-{p{uTRRp`TB+9fRrbHh^?|<+Er(oJum_>Y0Fn>ZOAGrTs65@0e9|QkkqZKMda&2?}wR+;r#2jLK+gDDR)9&18xDX{zA$ z!jM7V!8;u7gRYLT-4yelx#3e449esg!AfCV7c9$ow9KzA2*+U{-gP< zto2hd=Hc6Lbph9~?}>HoDEYVu+knj}dNStu@?^b|fnwomYzq&So$<7vO*v5M;{=G@ zi+(v`%z4J{u?Ie}Gw?Jy?uq3ONuavz80o6-W(ZEf=c#6%MJ?H-$ zp}&@FQIlqs;AE8|dlFS&!m*NUkxdfJ#65>0|MpN}257Xf7GWF4u$mb@?jN`>4ts-x zh#cVj&F1DH(jFD))1dF+AUpy0F`kTJIY2uwga`p4h;Bzy$2{s>AsBPr*qDp4%%8`j z5}f#uxCGP~V@_j&aHQ8C(y^|0{->uLIOZvrIO67LP@FgpM2|wyIfF}2hrbX#Kzqp< zS&J1bDl`M@HoRJMw!E0!ky{)ZVrcjZV0V`M==o+hI(^O1XYG`?OX_6u7)7clzJdAW z4NW#;JrqL}#WQGP3Ab~snYITRI4`JYzY9b^{|gc!+w*g-LMOspbNiQD&6*Uz`%n-udFs?T+ERx2u+Zr%YoV|GEoIx> zfa%;s*Z5@9QEi=Dz&!pqhuT_#8?&Nttp|GYx?w>pBMkHz+Q%AeqKAyY6jIPmdY~CA zw>KE?S43)x8^_6fGU$YjZ}!O;SU$P$@uF7|}p| zj3)s>xF>}Eo7nKLP5|eC23Y-NaM9sD;9Ip;B0y!%--R})JG69#4%Zv&ARBcLG^$WXO=~Pez z-!8FWxCtJM0<$!ZqufY57KYq4;F+Fuj_}}&ro9v!^alIxz6ffL-{5}-@I%qkHle0V z97>^s+r(iF}-r}j6h1mLTHa&_P$);gf zX+dk?jdK^~g4W*oVubHgcF0x~e4g1o6TMP?^qMe!H1R(nOs&l10{#QE7aSGM_9O`E6}Tm0`2 z?40~T72V*zgh%jF%*x*N?QLX!WIEiHG!G@K(+fH#D-J7wxSvF z?kBRE@{5@=O)v$#ny5wLIP7t(LBEKdg>9wT|Lpf!(f580 zPP*{Dr?I!H@_QEPcWQ)SQv9zG-pz>4nVj>{f42(HJ;~`zeRes&A|Uslj<1OFcMlus za0kL&)irvF7Ig9Ir33=wR;CD+%8}6Lu-M#A;FzrR2usiY9 z+12?2^^9=FaX}~^tx%>9^a$$l-D8hAK>JvOYyV%5c2)Qg6WM|ur3Gz6O>puEg#5tZ zR!Nuq0+scQlDiL=*pOR~#PZ7P`7*M*Ea_G5~TH5FHnK*v#-N76;|BfRf8 z(1n}3ROQNszbu+m1#m>7Klk6%G^@V-ZQHshqwUe`J(g5zD=Ew)&#~yFs@h)G98fp* z00W7V`#+krU2apF{xWG9^1XNdoeejGZ2Av2gu-za=;3+)p{WLTh#-;V?S~4BK*EgH z0%`QS|G3M#=2sxKprNPr6y)7VVB0b;vXCBo(AkCO;bmiXY!=9>R>Kf|0pyXV=$=dvshgJ6RauIUE39EQDC)e?(b zi#phs(7Bp{S?p790{WeL;jln;7vgLX(1@4H1)q2v0TnJo$T@@gFH=_RxUy?Q*}jv? zpd3~G(sB3I8OxdW_Y(#Kd%O+QQcS;>@V+zDLFzf~J&5iw0>5FUs6vGf>M5L6&EUa? zbyy0f3=`xfn5t_r;@e5pr*X4lwkNu-SeP}KpR@}02mKjO)Cl-us3N`k-wbIApt|>8 z|G<|UaJ0spq48^mII={JETdmkQH+^k(=b0VxlW#_2@Y?^Lzw|B*Ex~$;)n7D$aO|I z4qV*vo)s|U0NojH0u6lD5*Ur2vUwQ7_MpC(#_8c=CJ3CLfZ(+50i_iP6m)Pbt;2Vz zEXi2A*+ed!c>|o{H<<7K5DW#LE&Rtr2H;=?0mO0o6fpAW5y5Lx)tlfPy)lLuYx`8& zDKbm^yOMdWHJnpXqDGeaSAcJVQhp{rPxv@CBua%O8Y4*6N|WGN(B`+|m!$-h15=$6 ze{^G#j}8?cD=O}i`A+2Aq3UFxwbXb=P)<55=M~t^{n2;>0xGs@&~OQI z2JH2(+HV}kppx;j4_E&mwsugewG;TQGjR6A7wXG7*dMy!p>b%();+ebH@jT_FW><# ASO5S3 literal 0 HcmV?d00001 diff --git a/src/gui/dlgInput.cpp b/src/gui/dlgInput.cpp index 5570448ea..6c068c018 100644 --- a/src/gui/dlgInput.cpp +++ b/src/gui/dlgInput.cpp @@ -216,9 +216,6 @@ void dlgInput::update_dialog() { update_text_shortcut(parentMain->ui->action_2x, SET_INP_SC_SCALE_2X); update_text_shortcut(parentMain->ui->action_3x, SET_INP_SC_SCALE_3X); update_text_shortcut(parentMain->ui->action_4x, SET_INP_SC_SCALE_4X); -#if defined (SDL) - update_text_shortcut(parentMain->ui->action_Cube, SET_INP_SC_EFFECT_CUBE); -#endif update_text_shortcut(parentMain->ui->action_Interpolation, SET_INP_SC_INTERPOLATION); update_text_shortcut(parentMain->ui->action_Fullscreen, SET_INP_SC_FULLSCREEN); update_text_shortcut(parentMain->ui->action_Stretch_in_fullscreen, SET_INP_SC_STRETCH_FULLSCREEN); @@ -712,12 +709,6 @@ void dlgInput::s_default_clicked(bool checked) { update_dialog(); } void dlgInput::s_apply_clicked(bool checked) { -#if defined (SDL) - if (opengl.rotation && (input_zapper_is_connected((_port *) &data.port) == TRUE)) { - mainWindow::s_set_effect(); - } -#endif - memcpy(&cfg->input, &data.settings, sizeof(_config_input)); for (int i = PORT1; i < PORT_MAX; i++) { diff --git a/src/gui/mainWindow.cpp b/src/gui/mainWindow.cpp index 6f9f084ec..42f2fb854 100644 --- a/src/gui/mainWindow.cpp +++ b/src/gui/mainWindow.cpp @@ -143,7 +143,6 @@ void mainWindow::setup() { grp->setExclusive(true); grp->addAction(ui->action_Rend0); grp->addAction(ui->action_Rend1); - grp->addAction(ui->action_Rend2); // Settings/Video/FPS grp = new QActionGroup(this); grp->setExclusive(true); @@ -202,17 +201,10 @@ void mainWindow::setup() { grp->setExclusive(true); grp->addAction(ui->action_Oscan_Def_On); grp->addAction(ui->action_Oscan_Def_Off); - // Settings/Video/Filter + // Settings/Video/Software Filters grp = new QActionGroup(this); grp->setExclusive(true); grp->addAction(ui->action_No_Filter); - grp->addAction(ui->action_Phosphor); - grp->addAction(ui->action_Phosphor2); - grp->addAction(ui->action_Scanline); - grp->addAction(ui->action_DBL); - grp->addAction(ui->action_Dark_Room); - grp->addAction(ui->action_CRT_With_Curve); - grp->addAction(ui->action_CRT_Without_Curve); grp->addAction(ui->action_Scale2X); grp->addAction(ui->action_Scale3X); grp->addAction(ui->action_Scale4X); @@ -225,7 +217,46 @@ void mainWindow::setup() { grp->addAction(ui->action_NTSC_Composite); grp->addAction(ui->action_NTSC_SVideo); grp->addAction(ui->action_NTSC_RGB); - // Settings/Video/Filter + // Settings/Video/Shaders + grp->addAction(ui->action_shader_test); + + grp->addAction(ui->action_anti_aliasing_advanced_aa); + grp->addAction(ui->action_anti_aliasing_fxaa_edge_detect); + grp->addAction(ui->action_cgp_tvout_tvout_ntsc_2phase_composite); + grp->addAction(ui->action_cgp_tvout_tvout_ntsc_256px_svideo); + grp->addAction(ui->action_cgp_2xbr_crt_hyllian); + grp->addAction(ui->action_cgp_2xbr_jinc2_sharper_hybrid); + grp->addAction(ui->action_crt_gtu_v050); + grp->addAction(ui->action_crt_4xbr_hybrid_crt); + grp->addAction(ui->action_crt_crt_caligari); + grp->addAction(ui->action_crt_crt_cgwg_fast); + grp->addAction(ui->action_crt_crt_easymode); + grp->addAction(ui->action_crt_crt_easymode_halation); + grp->addAction(ui->action_crt_crt_geom); + grp->addAction(ui->action_crt_crtglow_gauss); + grp->addAction(ui->action_crt_crtglow_gauss_ntsc_3phase); + grp->addAction(ui->action_crt_crt_hyllian); + grp->addAction(ui->action_crt_crt_lottes); + grp->addAction(ui->action_crt_crt_reverse_aa); + grp->addAction(ui->action_crt_dotmask); + grp->addAction(ui->action_eagle_super_eagle); + grp->addAction(ui->action_hunterk_borders_1080p_bigblur); + grp->addAction(ui->action_hunterk_borders_1080p_color_grid); + grp->addAction(ui->action_hunterk_borders_1080p_mudlord); + grp->addAction(ui->action_hunterk_borders_1080p_shiny_iterations); + grp->addAction(ui->action_hunterk_borders_1080p_snow); + grp->addAction(ui->action_hunterk_borders_1080p_voronoi); + grp->addAction(ui->action_hunterk_borders_1080p_water); + grp->addAction(ui->action_hunterk_handheld_nds); + grp->addAction(ui->action_hunterk_hqx_hq3x); + grp->addAction(ui->action_hunterk_motionblur_motionblur_simple); + grp->addAction(ui->action_motionblur_feedback); + grp->addAction(ui->action_mudlord_emboss); + grp->addAction(ui->action_mudlord_mud_mudlord); + grp->addAction(ui->action_mudlord_noise_mudlord); + grp->addAction(ui->action_mudlord_oldtv); + grp->addAction(ui->action_waterpaint_water); + // Settings/Video/Palette grp = new QActionGroup(this); grp->setExclusive(true); grp->addAction(ui->action_Palette_PAL); @@ -381,13 +412,8 @@ bool mainWindow::eventFilter(QObject *obj, QEvent *event) { update_window(); ui->action_Rend0->setText(tr("&Software")); #if defined (SDL) - ui->action_Rend1->setText(tr("&OpenGL")); - ui->action_Rend2->setText(tr("OpenGL &GLSL")); - + ui->action_Rend1->setText(tr("OpenGL &GLSL")); ui->action_PAR_Soft_Stretch->setText(tr("GLSL &soft stretch")); - - ui->action_Cube->setText(tr("&Cube")); - ui->menu_Effect->setTitle(tr("&Effect")); #elif defined (D3D9) ui->action_Rend1->setText(tr("&HLSL")); ui->action_PAR_Soft_Stretch->setText(tr("HLSL &soft stretch")); @@ -448,12 +474,9 @@ void mainWindow::setup_video_rendering() { ui->action_Rend0->setEnabled(true); ui->action_Rend0->setVisible(true); #if defined (SDL) - ui->action_Rend1->setText(tr("&OpenGL")); + ui->action_Rend1->setText(tr("OpenGL &GLSL")); ui->action_Rend1->setEnabled(true); ui->action_Rend1->setVisible(true); - ui->action_Rend2->setText(tr("OpenGL &GLSL")); - ui->action_Rend2->setEnabled(true); - ui->action_Rend2->setVisible(true); ui->action_PAR_Soft_Stretch->setText(tr("GLSL &soft stretch")); #elif defined (D3D9) @@ -516,7 +539,7 @@ void mainWindow::update_recent_roms() { break; } - sprintf(description, "%s", basename(recent_roms_list.item[i])); + ::sprintf(description, "%s", basename(recent_roms_list.item[i])); action->setText(description); ext = strrchr(description, '.'); @@ -555,27 +578,10 @@ void mainWindow::update_menu_settings() { ui->action_Rend1->setEnabled(false); } - if (opengl.glsl.compliant) { - ui->action_Rend2->setEnabled(true); + if (opengl.supported && gfx.opengl) { + ui->action_Rend1->setChecked(true); } else { - ui->action_Rend2->setEnabled(false); - } - - { - QAction *tmp; - - if (!gfx.opengl) { - tmp = ui->action_Rend0; - } else { - if (!opengl.glsl.compliant) { - tmp = ui->action_Rend1; - } else if (!opengl.glsl.enabled) { - tmp = ui->action_Rend1; - } else { - tmp = ui->action_Rend2; - } - } - tmp->setChecked(true); + ui->action_Rend0->setChecked(true); } #elif defined (D3D9) if (gfx.hlsl.compliant) { @@ -723,7 +729,7 @@ void mainWindow::update_menu_settings() { ui->menu_Pixel_Aspect_Ratio->setEnabled(false); } - if ((opengl.glsl.compliant == TRUE) && (opengl.glsl.enabled == TRUE) + if ((opengl.supported && gfx.opengl) #elif defined (D3D9) if ((gfx.hlsl.compliant == TRUE) && (gfx.hlsl.enabled == TRUE) #endif @@ -757,7 +763,7 @@ void mainWindow::update_menu_settings() { ui->action_Oscan_Def_Off->setChecked(true); break; } - // Settings/Video/Filter + // Settings/Video/Software Filters { bool state; @@ -773,57 +779,69 @@ void mainWindow::update_menu_settings() { ui->action_xBRZ_2X->setEnabled(state); ui->action_xBRZ_3X->setEnabled(state); ui->action_xBRZ_4X->setEnabled(state); - - if (opengl.glsl.compliant && opengl.glsl.enabled && (cfg->scale != X1)) { -#elif defined (D3D9) - if (gfx.hlsl.enabled && (cfg->scale != X1)) { -#endif + if (cfg->scale != X1) { state = true; } else { state = false; } - ui->action_Phosphor->setEnabled(state); - ui->action_Phosphor2->setEnabled(state); - ui->action_Scanline->setEnabled(state); - ui->action_DBL->setEnabled(state); - ui->action_Dark_Room->setEnabled(state); - ui->action_CRT_With_Curve->setEnabled(state); - ui->action_CRT_Without_Curve->setEnabled(state); + ui->action_NTSC_Composite->setEnabled(state); + ui->action_NTSC_SVideo->setEnabled(state); + ui->action_NTSC_RGB->setEnabled(state); - if (cfg->scale != X1) { + // Settings/Video/Shaders + if (gfx.opengl && (cfg->scale != X1)) { +#elif defined (D3D9) + if (gfx.hlsl.enabled && (cfg->scale != X1)) { +#endif state = true; } else { state = false; } - ui->action_NTSC_Composite->setEnabled(state); - ui->action_NTSC_SVideo->setEnabled(state); - ui->action_NTSC_RGB->setEnabled(state); + ui->menu_Shaders->setEnabled(state); + + ui->action_shader_test->setEnabled(state); + + ui->action_anti_aliasing_advanced_aa->setEnabled(state); + ui->action_anti_aliasing_fxaa_edge_detect->setEnabled(state); + ui->action_cgp_tvout_tvout_ntsc_2phase_composite->setEnabled(state); + ui->action_cgp_tvout_tvout_ntsc_256px_svideo->setEnabled(state); + ui->action_cgp_2xbr_crt_hyllian->setEnabled(state); + ui->action_cgp_2xbr_jinc2_sharper_hybrid->setEnabled(state); + ui->action_crt_gtu_v050->setEnabled(state); + ui->action_crt_4xbr_hybrid_crt->setEnabled(state); + ui->action_crt_crt_caligari->setEnabled(state); + ui->action_crt_crt_cgwg_fast->setEnabled(state); + ui->action_crt_crt_easymode->setEnabled(state); + ui->action_crt_crt_easymode_halation->setEnabled(state); + ui->action_crt_crt_geom->setEnabled(state); + ui->action_crt_crtglow_gauss->setEnabled(state); + ui->action_crt_crtglow_gauss_ntsc_3phase->setEnabled(state); + ui->action_crt_crt_hyllian->setEnabled(state); + ui->action_crt_crt_lottes->setEnabled(state); + ui->action_crt_crt_reverse_aa->setEnabled(state); + ui->action_crt_dotmask->setEnabled(state); + ui->action_eagle_super_eagle->setEnabled(state); + ui->action_hunterk_borders_1080p_bigblur->setEnabled(state); + ui->action_hunterk_borders_1080p_color_grid->setEnabled(state); + ui->action_hunterk_borders_1080p_mudlord->setEnabled(state); + ui->action_hunterk_borders_1080p_shiny_iterations->setEnabled(state); + ui->action_hunterk_borders_1080p_snow->setEnabled(state); + ui->action_hunterk_borders_1080p_voronoi->setEnabled(state); + ui->action_hunterk_borders_1080p_water->setEnabled(state); + ui->action_hunterk_handheld_nds->setEnabled(state); + ui->action_hunterk_hqx_hq3x->setEnabled(state); + ui->action_hunterk_motionblur_motionblur_simple->setEnabled(state); + ui->action_motionblur_feedback->setEnabled(state); + ui->action_mudlord_emboss->setEnabled(state); + ui->action_mudlord_mud_mudlord->setEnabled(state); + ui->action_mudlord_noise_mudlord->setEnabled(state); + ui->action_mudlord_oldtv->setEnabled(state); + ui->action_waterpaint_water->setEnabled(state); } switch (cfg->filter) { case NO_FILTER: ui->action_No_Filter->setChecked(true); break; - case PHOSPHOR: - ui->action_Phosphor->setChecked(true); - break; - case PHOSPHOR2: - ui->action_Phosphor2->setChecked(true); - break; - case SCANLINE: - ui->action_Scanline->setChecked(true); - break; - case DBL: - ui->action_DBL->setChecked(true); - break; - case DARK_ROOM: - ui->action_Dark_Room->setChecked(true); - break; - case CRT_CURVE: - ui->action_CRT_With_Curve->setChecked(true); - break; - case CRT_NO_CURVE: - ui->action_CRT_Without_Curve->setChecked(true); - break; case SCALE2X: ui->action_Scale2X->setChecked(true); break; @@ -864,6 +882,119 @@ void mainWindow::update_menu_settings() { break; } break; + + case sh_test: + ui->action_shader_test->setChecked(true); + break; + + case sh_anti_aliasing_advanced_aa: + ui->action_anti_aliasing_advanced_aa->setChecked(true); + break; + case sh_anti_aliasing_fxaa_edge_detect: + ui->action_anti_aliasing_fxaa_edge_detect->setChecked(true); + break; + case sh_cgp_tvout_tvout_ntsc_2phase_composite: + ui->action_cgp_tvout_tvout_ntsc_2phase_composite->setChecked(true); + break; + case sh_cgp_tvout_tvout_ntsc_256px_svideo: + ui->action_cgp_tvout_tvout_ntsc_256px_svideo->setChecked(true); + break; + case sh_cgp_2xbr_crt_hyllian: + ui->action_cgp_2xbr_crt_hyllian->setChecked(true); + break; + case sh_cgp_2xbr_jinc2_sharper_hybrid: + ui->action_cgp_2xbr_jinc2_sharper_hybrid->setChecked(true); + break; + case sh_crt_gtuv50: + ui->action_crt_gtu_v050->setChecked(true); + break; + case sh_crt_4xbr_hybrid_crt: + ui->action_crt_4xbr_hybrid_crt->setChecked(true); + break; + case sh_crt_crt_caligari: + ui->action_crt_crt_caligari->setChecked(true); + break; + case sh_crt_crt_cgwg_fast: + ui->action_crt_crt_cgwg_fast->setChecked(true); + break; + case sh_crt_crt_easymode: + ui->action_crt_crt_easymode->setChecked(true); + break; + case sh_crt_crt_easymode_halation: + ui->action_crt_crt_easymode_halation->setChecked(true); + break; + case sh_crt_crt_geom: + ui->action_crt_crt_geom->setChecked(true); + break; + case sh_crt_crtglow_gauss: + ui->action_crt_crtglow_gauss->setChecked(true); + break; + case sh_crt_crtglow_gauss_ntsc_3phase: + ui->action_crt_crtglow_gauss_ntsc_3phase->setChecked(true); + break; + case sh_crt_crt_hyllian: + ui->action_crt_crt_hyllian->setChecked(true); + break; + case sh_crt_crt_lottes: + ui->action_crt_crt_lottes->setChecked(true); + break; + case sh_crt_crt_reverse_aa: + ui->action_crt_crt_reverse_aa->setChecked(true); + break; + case sh_crt_dotmask: + ui->action_crt_dotmask->setChecked(true); + break; + case sh_eagle_super_eagle: + ui->action_eagle_super_eagle->setChecked(true); + break; + case sh_hunterk_borders_1080p_bigblur: + ui->action_hunterk_borders_1080p_bigblur->setChecked(true); + break; + case sh_hunterk_borders_1080p_color_grid: + ui->action_hunterk_borders_1080p_color_grid->setChecked(true); + break; + case sh_hunterk_borders_1080p_mudlord: + ui->action_hunterk_borders_1080p_mudlord->setChecked(true); + break; + case sh_hunterk_borders_1080p_shiny_iterations: + ui->action_hunterk_borders_1080p_shiny_iterations->setChecked(true); + break; + case sh_hunterk_borders_1080p_snow: + ui->action_hunterk_borders_1080p_snow->setChecked(true); + break; + case sh_hunterk_borders_1080p_voronoi: + ui->action_hunterk_borders_1080p_voronoi->setChecked(true); + break; + case sh_hunterk_borders_1080p_water: + ui->action_hunterk_borders_1080p_water->setChecked(true); + break; + case sh_hunterk_handheld_nds: + ui->action_hunterk_handheld_nds->setChecked(true); + break; + case sh_hunterk_hqx_hq3x: + ui->action_hunterk_hqx_hq3x->setChecked(true); + break; + case sh_hunterk_motionblur_motionblur_simple: + ui->action_hunterk_motionblur_motionblur_simple->setChecked(true); + break; + case sh_motionblur_feedback: + ui->action_motionblur_feedback->setChecked(true); + break; + case sh_mudlord_emboss: + ui->action_mudlord_emboss->setChecked(true); + break; + case sh_mudlord_mud_mudlord: + ui->action_mudlord_mud_mudlord->setChecked(true); + break; + case sh_mudlord_noise_mudlord: + ui->action_mudlord_noise_mudlord->setChecked(true); + break; + case sh_mudlord_oldtv: + ui->action_mudlord_oldtv->setChecked(true); + break; + case sh_waterpaint_water: + ui->action_waterpaint_water->setChecked(true); + break; } } // Settings/Video/Palette @@ -895,15 +1026,6 @@ void mainWindow::update_menu_settings() { ui->action_Palette_File->setChecked(true); break; } - // Settings/Video/Effect -#if defined (SDL) - if (gfx.opengl && (input_zapper_is_connected((_port *) &port) == FALSE)) { - ui->menu_Effect->setEnabled(true); - } else { - ui->menu_Effect->setEnabled(false); - } - ui->action_Cube->setChecked(opengl.rotation); -#endif // Settings/Video/[VSync, Interpolation, Text on screen] #if defined (SDL) if (gfx.opengl) { @@ -1196,10 +1318,6 @@ void mainWindow::shortcuts() { connect_shortcut(ui->action_2x, SET_INP_SC_SCALE_2X); connect_shortcut(ui->action_3x, SET_INP_SC_SCALE_3X); connect_shortcut(ui->action_4x, SET_INP_SC_SCALE_4X); -#if defined (SDL) - // Settings/Video/Effect - connect_shortcut(ui->action_Cube, SET_INP_SC_EFFECT_CUBE, SLOT(s_set_effect())); -#endif // Settings/Video/[Interpolation, Fullscreen, Stretch in fullscreen] connect_shortcut(ui->action_Interpolation, SET_INP_SC_INTERPOLATION, SLOT(s_set_interpolation())); @@ -1263,11 +1381,6 @@ void mainWindow::shcjoy_stop() { } void mainWindow::control_visible_cursor() { if ((mouse.hidden == FALSE) && (input_zapper_is_connected((_port *) &port) == FALSE)) { -#if defined (SDL) - if (opengl.rotation == TRUE) { - return; - } -#endif if (cfg->fullscreen == FULLSCR) { gui_cursor_hide(TRUE); } else if ((gui_get_ms() - mouse.timer) >= 2000) { @@ -1358,8 +1471,7 @@ void mainWindow::connect_menu_signals() { // Settings/Video/Rendering connect_action(ui->action_Rend0, RENDER_SOFTWARE, SLOT(s_set_rendering())); #if defined (SDL) - connect_action(ui->action_Rend1, RENDER_OPENGL, SLOT(s_set_rendering())); - connect_action(ui->action_Rend2, RENDER_GLSL, SLOT(s_set_rendering())); + connect_action(ui->action_Rend1, RENDER_GLSL, SLOT(s_set_rendering())); #elif defined (D3D9) connect_action(ui->action_Rend1, RENDER_HLSL, SLOT(s_set_rendering())); #endif @@ -1411,15 +1523,8 @@ void mainWindow::connect_menu_signals() { connect_action(ui->action_Oscan_Def_On, OSCAN_DEFAULT_ON, SLOT(s_set_overscan())); connect_action(ui->action_Oscan_Def_Off, OSCAN_DEFAULT_OFF, SLOT(s_set_overscan())); connect_action(ui->action_Oscan_Set_Borders, SLOT(s_set_overscan_borders())); - // Settings/Video/Filter + // Settings/Video/Software Filters connect_action(ui->action_No_Filter, NO_FILTER, SLOT(s_set_other_filter())); - connect_action(ui->action_Phosphor, PHOSPHOR, SLOT(s_set_other_filter())); - connect_action(ui->action_Phosphor2, PHOSPHOR2, SLOT(s_set_other_filter())); - connect_action(ui->action_Scanline, SCANLINE, SLOT(s_set_other_filter())); - connect_action(ui->action_DBL, DBL, SLOT(s_set_other_filter())); - connect_action(ui->action_Dark_Room, DARK_ROOM, SLOT(s_set_other_filter())); - connect_action(ui->action_CRT_With_Curve, CRT_CURVE, SLOT(s_set_other_filter())); - connect_action(ui->action_CRT_Without_Curve, CRT_NO_CURVE, SLOT(s_set_other_filter())); connect_action(ui->action_Scale2X, SCALE2X, SLOT(s_set_other_filter())); connect_action(ui->action_Scale3X, SCALE3X, SLOT(s_set_other_filter())); connect_action(ui->action_Scale4X, SCALE4X, SLOT(s_set_other_filter())); @@ -1432,6 +1537,82 @@ void mainWindow::connect_menu_signals() { connect_action(ui->action_NTSC_Composite, COMPOSITE, SLOT(s_set_ntsc_filter())); connect_action(ui->action_NTSC_SVideo, SVIDEO, SLOT(s_set_ntsc_filter())); connect_action(ui->action_NTSC_RGB, RGBMODE, SLOT(s_set_ntsc_filter())); + // Settings/Video/Shaders + connect_action(ui->action_shader_test, + sh_test, SLOT(s_set_other_filter())); + + connect_action(ui->action_anti_aliasing_advanced_aa, + sh_anti_aliasing_advanced_aa, SLOT(s_set_other_filter())); + connect_action(ui->action_anti_aliasing_fxaa_edge_detect, + sh_anti_aliasing_fxaa_edge_detect, SLOT(s_set_other_filter())); + connect_action(ui->action_cgp_tvout_tvout_ntsc_2phase_composite, + sh_cgp_tvout_tvout_ntsc_2phase_composite, SLOT(s_set_other_filter())); + connect_action(ui->action_cgp_tvout_tvout_ntsc_256px_svideo, + sh_cgp_tvout_tvout_ntsc_256px_svideo, SLOT(s_set_other_filter())); + connect_action(ui->action_cgp_2xbr_crt_hyllian, + sh_cgp_2xbr_crt_hyllian, SLOT(s_set_other_filter())); + connect_action(ui->action_cgp_2xbr_jinc2_sharper_hybrid, + sh_cgp_2xbr_jinc2_sharper_hybrid, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_gtu_v050, + sh_crt_gtuv50, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_4xbr_hybrid_crt, + sh_crt_4xbr_hybrid_crt, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_caligari, + sh_crt_crt_caligari, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_cgwg_fast, + sh_crt_crt_cgwg_fast, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_easymode, + sh_crt_crt_easymode, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_easymode_halation, + sh_crt_crt_easymode_halation, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_geom, + sh_crt_crt_geom, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crtglow_gauss, + sh_crt_crtglow_gauss, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crtglow_gauss_ntsc_3phase, + sh_crt_crtglow_gauss_ntsc_3phase, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_hyllian, + sh_crt_crt_hyllian, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_lottes, + sh_crt_crt_lottes, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_crt_reverse_aa, + sh_crt_crt_reverse_aa, SLOT(s_set_other_filter())); + connect_action(ui->action_crt_dotmask, + sh_crt_dotmask, SLOT(s_set_other_filter())); + connect_action(ui->action_eagle_super_eagle, + sh_eagle_super_eagle, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_bigblur, + sh_hunterk_borders_1080p_bigblur, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_color_grid, + sh_hunterk_borders_1080p_color_grid, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_mudlord, + sh_hunterk_borders_1080p_mudlord, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_shiny_iterations, + sh_hunterk_borders_1080p_shiny_iterations, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_snow, + sh_hunterk_borders_1080p_snow, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_voronoi, + sh_hunterk_borders_1080p_voronoi, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_borders_1080p_water, + sh_hunterk_borders_1080p_water, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_handheld_nds, + sh_hunterk_handheld_nds, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_hqx_hq3x, + sh_hunterk_hqx_hq3x, SLOT(s_set_other_filter())); + connect_action(ui->action_hunterk_motionblur_motionblur_simple, + sh_hunterk_motionblur_motionblur_simple, SLOT(s_set_other_filter())); + connect_action(ui->action_motionblur_feedback, + sh_motionblur_feedback, SLOT(s_set_other_filter())); + connect_action(ui->action_mudlord_emboss, + sh_mudlord_emboss, SLOT(s_set_other_filter())); + connect_action(ui->action_mudlord_mud_mudlord, + sh_mudlord_mud_mudlord, SLOT(s_set_other_filter())); + connect_action(ui->action_mudlord_noise_mudlord, + sh_mudlord_noise_mudlord, SLOT(s_set_other_filter())); + connect_action(ui->action_mudlord_oldtv, + sh_mudlord_oldtv, SLOT(s_set_other_filter())); + connect_action(ui->action_waterpaint_water, + sh_waterpaint_water, SLOT(s_set_other_filter())); // Settings/Video/Palette connect_action(ui->action_Palette_PAL, PALETTE_PAL, SLOT(s_set_palette())); connect_action(ui->action_Palette_NTSC, PALETTE_NTSC, SLOT(s_set_palette())); @@ -1441,14 +1622,6 @@ void mainWindow::connect_menu_signals() { connect_action(ui->action_Palette_File, PALETTE_FILE, SLOT(s_set_palette())); connect_action(ui->action_Palette_Save_File, SLOT(s_save_palette())); connect_action(ui->action_Palette_Load_File, SLOT(s_load_palette())); - // Settings/Video/Effect -#if defined (SDL) - connect_action(ui->action_Cube, SLOT(s_set_effect())); -#elif defined (D3D9) - ui->menu_Effect->removeAction(ui->action_Cube); - delete (ui->action_Cube); - delete (ui->menu_Effect); -#endif // Settings/Video/[VSync, Interpolation, Text on screen, Fullscreen, Stretch in fullscreen] connect_action(ui->action_Disable_emphasis_swap_PAL, SLOT(s_set_disable_emphasis_pal())); connect_action(ui->action_VSync, SLOT(s_set_vsync())); @@ -1561,11 +1734,6 @@ void mainWindow::set_filter(int filter) { gfx_FILTER(filter); #endif } -void mainWindow::s_set_effect() { -#if defined (SDL) - opengl_effect_change(!opengl.rotation); -#endif -} void mainWindow::s_set_fullscreen() { if (gui.in_update) { return; @@ -2352,11 +2520,6 @@ void mainWindow::s_shcjoy_read_timer() { case SET_INP_SC_SCALE_4X: ui->action_4x->trigger(); break; -#if defined (SDL) - case SET_INP_SC_EFFECT_CUBE: - ui->action_Cube->trigger(); - break; -#endif case SET_INP_SC_INTERPOLATION: ui->action_Interpolation->trigger(); break; diff --git a/src/gui/mainWindow.hpp b/src/gui/mainWindow.hpp index 322b877b1..cbbb45522 100644 --- a/src/gui/mainWindow.hpp +++ b/src/gui/mainWindow.hpp @@ -101,7 +101,6 @@ class mainWindow: public QMainWindow { void set_filter(int filter); public slots: - static void s_set_effect(); void s_set_fullscreen(); private slots: diff --git a/src/gui/qt.cpp b/src/gui/qt.cpp index a32ace046..142a8305a 100644 --- a/src/gui/qt.cpp +++ b/src/gui/qt.cpp @@ -43,6 +43,8 @@ #include "gui.h" #if defined (SDL) #include "opengl.h" +#include +#include #if defined (__WIN32__) #include "sdl_wid.h" #endif @@ -56,13 +58,8 @@ class appEventFilter: public QObject { bool eventFilter(QObject* object, QEvent* event) { if (event->type() == QEvent::MouseMove) { if (mouse.hidden == TRUE) { -#if defined (SDL) - if ((input_zapper_is_connected((_port *) &port) == TRUE) || - (cfg->fullscreen != FULLSCR) || (opengl.rotation == TRUE)) { -#else if ((input_zapper_is_connected((_port *) &port) == TRUE) || (cfg->fullscreen != FULLSCR)) { -#endif gui_cursor_hide(FALSE); } } @@ -78,6 +75,7 @@ static struct _qt { mainWindow *mwin; screenWidget *screen; cheatObject *chobj; + QImage qimage; } qt; void gui_quit(void) {} @@ -283,6 +281,31 @@ void gui_mainWindow_make_reset(BYTE type) { qt.mwin->make_reset(type); } +#if defined (SDL) +BYTE gui_load_lut(_lut *lut, const char *path) { + QImage tmp; + + if (path && (::strlen(path) > 0)) { + tmp = QImage(path); + } + + if (tmp.isNull()) { + lut->w = 0; + lut->h = 0; + lut->bits = NULL; + return (FALSE); + } + + qt.qimage = tmp.convertToFormat(QImage::Format_ARGB32); + + lut->w = qt.qimage.width(); + lut->h = qt.qimage.height(); + lut->bits = qt.qimage.bits(); + + return (TRUE); +} +#endif + #if defined (__WIN32__) #include "os_windows.h" #else diff --git a/src/gui/qt.h b/src/gui/qt.h index 3f43eaebb..339e626ce 100644 --- a/src/gui/qt.h +++ b/src/gui/qt.h @@ -27,6 +27,7 @@ #include "common.h" #include "emu.h" #include "jstick.h" +#include "opengl.h" #if defined (__cplusplus) #define EXTERNC extern "C" @@ -103,6 +104,10 @@ EXTERNC void gui_control_visible_cursor(void); EXTERNC void gui_mainWindow_make_reset(BYTE type); +#if defined (SDL) +EXTERNC BYTE gui_load_lut(_lut *lut, const char *path); +#endif + EXTERNC double (*gui_get_ms)(void); EXTERNC void gui_init(int *argc, char **argv); diff --git a/src/gui/screenWidget.cpp b/src/gui/screenWidget.cpp index 4911d3b70..82bd6e57d 100644 --- a/src/gui/screenWidget.cpp +++ b/src/gui/screenWidget.cpp @@ -171,10 +171,6 @@ bool screenWidget::eventFilter(QObject *obj, QEvent *event) { mouseEvent = ((QMouseEvent *)event); if (mouseEvent->button() == Qt::LeftButton) { -#if defined (SDL) - opengl.x_diff = mouseEvent->x() - (opengl.y_rotate * slow_factor); - opengl.y_diff = -mouseEvent->y() + (opengl.x_rotate * slow_factor); -#endif mouse.left = TRUE; } else if (mouseEvent->button() == Qt::RightButton) { mouse.right = TRUE; @@ -192,13 +188,6 @@ bool screenWidget::eventFilter(QObject *obj, QEvent *event) { mouse.x = mouseEvent->x(); mouse.y = mouseEvent->y(); - -#if defined (SDL) - if (mouse.left && opengl.rotation) { - opengl.x_rotate = (mouseEvent->y() + opengl.y_diff) / slow_factor; - opengl.y_rotate = (mouseEvent->x() - opengl.x_diff) / slow_factor; - } -#endif } return (QObject::eventFilter(obj, event)); diff --git a/src/gui/settings.h b/src/gui/settings.h index 8cfbb6eb5..415a18fd4 100644 --- a/src/gui/settings.h +++ b/src/gui/settings.h @@ -234,12 +234,12 @@ enum list_settings_element { LSET_INP }; -typedef struct { +typedef struct _opt { const char *lname; const char *sname; int value; } _opt; -typedef struct { +typedef struct _settings { const char *grp; const char *key; const char *def; @@ -247,12 +247,12 @@ typedef struct { const char *cmt; const char *hlp; - struct { + struct _opts { const int count; const _opt *opt; } opts; } _settings; -typedef struct { +typedef struct _list_settings { const _settings *cfg; const int count; } _list_settings; @@ -280,7 +280,6 @@ static const _opt opt_ff_velocity[] = { static const _opt opt_rend[] = { {"Software", "software", RENDER_SOFTWARE}, #if defined (SDL) - {"OpenGL" , "opengl" , RENDER_OPENGL}, {"GLSL" , "glsl" , RENDER_GLSL} #elif defined (D3D9) {"HLSL" , "hlsl" , RENDER_HLSL} @@ -343,16 +342,218 @@ static const _opt opt_filter[] = { {"Hq3X" , "hq3x" , HQ3X}, {"Hq4X" , "hq4x" , HQ4X}, {"NTSC" , "ntsc" , NTSC_FILTER}, - {"Phoshpor" , "phosphor" , PHOSPHOR}, - {"Scanline" , "scanline" , SCANLINE}, - {"DBL" , "dbl" , DBL}, - {"CRTCURVE" , "crtcurve" , CRT_CURVE}, - {"CRTNOCURVE", "crtnocurve", CRT_NO_CURVE}, - {"Phosphor2" , "phosphor2" , PHOSPHOR2}, - {"DarkRoom" , "darkroom" , DARK_ROOM}, {"xBRZ 2x" , "xbrz2x" , XBRZ2X}, {"xBRZ 3x" , "xbrz3x" , XBRZ3X}, {"xBRZ 4x" , "xbrz4x" , XBRZ4X}, + // per filtri CPU aggiuntivi futuri + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + {NULL , NULL , NO_FILTER}, + // shaders + { + "Anti-aliasing Advenced AA", + "anti_aliasing_advanced_aa", + sh_anti_aliasing_advanced_aa + }, + { + "Anti-aliasing FX AA", + "anti_aliasing_fx_aa", + sh_anti_aliasing_fx_aa + }, + { + "Anti-aliasing FXAA Edge Detect", + "anti_aliasing_fxaa_edge_detect", + sh_anti_aliasing_fxaa_edge_detect + }, + { + "Cgp TVout NTSC 2Phase Composite", + "cgp_tvout_tvout_ntsc_2phase_composite", + sh_cgp_tvout_tvout_ntsc_2phase_composite + }, + { + "Cgp TVout NTSC 256px Svideo", + "cgp_tvout_tvout_ntsc_256px_svideo", + sh_cgp_tvout_tvout_ntsc_256px_svideo + }, + { + "Cgp 2xbr CRT Hyllian", + "cgp_2xbr_crt_hyllian", + sh_cgp_2xbr_crt_hyllian + }, + { + "Cgp 2xbr Jinc2 Sharper Hybrid", + "cgp_2xbr_jinc2_sharper_hybrid", + sh_cgp_2xbr_jinc2_sharper_hybrid + }, + { + "CRT gtuv050", + "crt_gtuv50", + sh_crt_gtuv50 + }, + { + "CRT 4xbr Hybrid CRT", + "crt_4xbr_hybrid_crt", + sh_crt_4xbr_hybrid_crt + }, + { + "CRT Caligari", + "crtcrtcaligari", + sh_crt_crt_caligari + }, + { + "CRT CGWG Fast", + "crt_crt_cgwg_fast", + sh_crt_crt_cgwg_fast + }, + { + "CRT Easymode", + "crt_crt_easymode", + sh_crt_crt_easymode + }, + { + "CRT Easymode Halation", + "crt_crt_easymode_halation", + sh_crt_crt_easymode_halation + }, + { + "CRT Geom", + "crt_crt_geom", + sh_crt_crt_geom + }, + { + "CRTGLow Gauss", + "crt_crtglow_gauss", + sh_crt_crtglow_gauss + }, + { + "CRTGLow Gauss NTSC 3Phase", + "crt_crtglow_gauss_ntsc_3phase", + sh_crt_crtglow_gauss_ntsc_3phase + }, + { + "CRT Hyllian", + "crt_crt_hyllian", + sh_crt_crt_hyllian + }, + { + "CRT Lottes", + "crt_crt_lottes", + sh_crt_crt_lottes + }, + { + "CRT Reverse AA", + "crt_crt_reverse_aa", + sh_crt_crt_reverse_aa + }, + { + "Dotmask", + "crt_dotmask", + sh_crt_dotmask + }, + { + "Eagle Super Eagle", + "eagle_super_eagle", + sh_eagle_super_eagle + }, + { + "Hunterk Borders 1080p Bigblur", + "hunterk_borders_1080p_bigblur", + sh_hunterk_borders_1080p_bigblur + }, + { + "Hunterk Borders 1080p Color Grid", + "hunterk_borders_1080p_color_grid", + sh_hunterk_borders_1080p_color_grid + }, + { + "Hunterk Borders 1080p Mudlord", + "hunterk_borders_1080p_mudlord", + sh_hunterk_borders_1080p_mudlord + }, + { + "Hunterk Borders 1080p Shiny Iterations", + "hunterk_borders_1080p_shiny_iterations", + sh_hunterk_borders_1080p_shiny_iterations + }, + { + "Hunterk Borders 1080p Snow", + "hunterk_borders_1080p_snow", + sh_hunterk_borders_1080p_snow + }, + { + "Hunterk Borders 1080p Voronoi", + "hunterk_borders_1080p_voronoi", + sh_hunterk_borders_1080p_voronoi + }, + { + "Hunterk Borders 1080p Water", + "hunterk_borders_1080p_water", + sh_hunterk_borders_1080p_water + }, + { + "Hunterk Handheld NDS", + "hunterk_handheld_nds", + sh_hunterk_handheld_nds + }, + { + "Hunterk Hq3X", + "hunterk_hqx_hq3x", + sh_hunterk_hqx_hq3x + }, + { + "Hunterk Motionblur Simple", + "hunterk_motionblur_motionblur_simple", + sh_hunterk_motionblur_motionblur_simple + }, + { + "Motionblur Feedback", + "motionblur_feedback", + sh_motionblur_feedback + }, + { + "Mudlord Emboss", + "mudlord_emboss", + sh_mudlord_emboss + }, + { + "Mudlord Mud", + "mudlord_mud_mudlord", + sh_mudlord_mud_mudlord + }, + { + "Mudlord Noise", + "mudlord_noise_mudlord", + sh_mudlord_noise_mudlord + }, + { + "Mudlord Oldtv", + "mudlord_oldtv", + sh_mudlord_oldtv + }, + { + "Waterpaint Water", + "waterpaint_water", + sh_waterpaint_water + }, + + { + "Shader Test", + "shader_test", + sh_test + }, + }; static const _opt opt_ntsc[] = { {"Composite", "composite", COMPOSITE}, @@ -471,8 +672,8 @@ static const _settings main_cfg[] = { "video", "rendering", #if defined (SDL) "glsl", - "# possible values: software, opengl, glsl", - "-r, --rendering type of rendering : software, opengl, glsl", + "# possible values: software, glsl", + "-r, --rendering type of rendering : software, glsl", #elif defined (D3D9) "hlsl", "# possible values: software, hlsl", diff --git a/src/gui/settingsObject.hpp b/src/gui/settingsObject.hpp index 1118e520b..00e76b8c7 100644 --- a/src/gui/settingsObject.hpp +++ b/src/gui/settingsObject.hpp @@ -19,7 +19,7 @@ #ifndef SETTINGSOBJECT_HPP_ #define SETTINGSOBJECT_HPP_ -#include +#include "settings.h" #include #include #include diff --git a/src/video/Makefile.am b/src/video/Makefile.am index f2436eb00..38cc6a792 100644 --- a/src/video/Makefile.am +++ b/src/video/Makefile.am @@ -23,17 +23,14 @@ libvideo_a_SOURCES += \ sdl/opengl.c \ sdl/opengl.h \ sdl/sdl_wid.h \ - sdl/shaders.h + sdl/shaders.c \ + sdl/shaders.h \ + sdl/shdcode.h libvideo_a_SOURCES += \ sdl/glew/glew.c \ sdl/glew/glew.h \ sdl/glew/glxew.h \ sdl/glew/wglew.h -libvideo_a_SOURCES += \ - sdl/openGL/cube3d.c \ - sdl/openGL/cube3d.h \ - sdl/openGL/no_effect.c \ - sdl/openGL/no_effect.h libvideo_a_SOURCES += \ sdl/shaders/color.h \ sdl/shaders/crt.h \ diff --git a/src/video/sdl/gfx.c b/src/video/sdl/gfx.c index 5286f0890..d8dffe76a 100644 --- a/src/video/sdl/gfx.c +++ b/src/video/sdl/gfx.c @@ -90,7 +90,7 @@ static SDL_Cursor *init_system_cursor(char *xpm[]); BYTE gfx_init(void) { const SDL_VideoInfo *video_info; - /* casi particolari provenienti dal settings_file_parse() e cmd_line_parse() */ + // casi particolari provenienti dal settings_file_parse() e cmd_line_parse() if ((cfg->scale == X1) && (cfg->filter != NO_FILTER)) { cfg->scale = X2; } @@ -108,7 +108,7 @@ BYTE gfx_init(void) { sdl_wid(); - /* inizializzazione SDL */ + // inizializzazione video SDL if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "SDL initialization failed: %s\n", SDL_GetError()); return (EXIT_ERROR); @@ -118,35 +118,28 @@ BYTE gfx_init(void) { video_info = SDL_GetVideoInfo(); - /* - * modalita' video con profondita' di colore - * inferiori a 15 bits non sono supportate. - */ - if (video_info->vfmt->BitsPerPixel < 15) { - fprintf(stderr, "Sorry but video mode at 256 color are not supported\n"); + // modalita' video con profondita' di colore + // inferiori a 32 bits non sono supportate. + if (video_info->vfmt->BitsPerPixel < 32) { + fprintf(stderr, "Sorry but color depth less than 32 bits are not supported\n"); return (EXIT_ERROR); } - /* il filtro hqx supporta solo i 32 bit di profondita' di colore */ - if (((cfg->filter >= HQ2X) || (cfg->filter <= HQ4X)) && (video_info->vfmt->BitsPerPixel < 32)) { - cfg->filter = NO_FILTER; - } - - /* controllo se e' disponibile l'accelerazione hardware */ + // controllo se e' disponibile l'accelerazione hardware if (video_info->hw_available) { software_flags = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_ASYNCBLIT; } else { software_flags = SDL_SWSURFACE | SDL_ASYNCBLIT; } - /* per poter inizializzare il glew devo creare un contesto opengl prima */ + // per poter inizializzare il glew devo creare un contesto opengl prima if (!(surface_sdl = SDL_SetVideoMode(0, 0, 0, SDL_OPENGL))) { opengl.supported = FALSE; cfg->render = RENDER_SOFTWARE; gfx_set_render(cfg->render); - if ((cfg->filter >= PHOSPHOR) && (cfg->filter <= CRT_NO_CURVE)) { + if ((cfg->filter >= FLTSHDSTART) && (cfg->filter <= FLTSHDSTOP)) { cfg->filter = NO_FILTER; } @@ -155,7 +148,7 @@ BYTE gfx_init(void) { opengl.supported = TRUE; } - /* casi particolari provenienti dal settings_file_parse() e cmd_line_parse()*/ + // casi particolari provenienti dal settings_file_parse() e cmd_line_parse() if (cfg->fullscreen == FULLSCR) { if (!gfx.opengl) { cfg->fullscreen = NO_FULLSCR; @@ -165,19 +158,24 @@ BYTE gfx_init(void) { } sdl_init_gl(); - /* - * inizializzo l'ntsc che utilizzero' non solo - * come filtro ma anche nel gfx_set_screen() per - * generare la paletta dei colori. - */ + if (opengl.supported == FALSE) { + cfg->render = RENDER_SOFTWARE; + gfx_set_render(cfg->render); + + if ((cfg->filter >= FLTSHDSTART) && (cfg->filter <= FLTSHDSTOP)) { + cfg->filter = NO_FILTER; + } + } + + // inizializzo l'ntsc che utilizzero' non solo + // come filtro ma anche nel gfx_set_screen() per + // generare la paletta dei colori. if (ntsc_init(0, 0, 0, 0, 0) == EXIT_ERROR) { return (EXIT_ERROR); } - /* - * mi alloco una zona di memoria dove conservare la - * paletta nel formato di visualizzazione. - */ + // mi alloco una zona di memoria dove conservare la + // paletta nel formato di visualizzazione. if (!(palette_win = (uint32_t *) malloc(NUM_COLORS * sizeof(uint32_t)))) { fprintf(stderr, "Unable to allocate the palette\n"); return (EXIT_ERROR); @@ -190,13 +188,11 @@ BYTE gfx_init(void) { gui_fullscreen(); } else { gfx_set_screen(cfg->scale, cfg->filter, NO_FULLSCR, cfg->palette, FALSE, FALSE); - /* - * nella versione windows (non so in quella linux), sembra che - * il VSync (con alcune schede video) non venga settato correttamente - * al primo gfx_set_screen. E' necessario fare un gfx_reset_video - * e poi nuovamente un gfx_set_screen. Nella versione linux il gui_reset_video() - * non fa assolutamente nulla. - */ + // nella versione windows (non so in quella linux), sembra che + // il VSync (con alcune schede video) non venga settato correttamente + // al primo gfx_set_screen. E' necessario fare un gfx_reset_video + // e poi nuovamente un gfx_set_screen. Nella versione linux il gui_reset_video() + // non fa assolutamente nulla. gui_reset_video(); } @@ -211,20 +207,13 @@ void gfx_set_render(BYTE render) { switch (render) { case RENDER_SOFTWARE: gfx.opengl = FALSE; - opengl.rotation = FALSE; - opengl.glsl.enabled = FALSE; - break; - case RENDER_OPENGL: - gfx.opengl = TRUE; - opengl.glsl.enabled = FALSE; break; case RENDER_GLSL: gfx.opengl = TRUE; - opengl.glsl.enabled = TRUE; break; } } -void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE force_scale, +void gfx_set_screen(BYTE scale, DBWORD filter, BYTE fullscreen, BYTE palette, BYTE force_scale, BYTE force_palette) { BYTE set_mode; WORD width, height, w_for_pr, h_for_pr; @@ -234,16 +223,14 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE width = 0, height = 0; w_for_pr = 0, h_for_pr = 0; - /* - * l'ordine dei vari controlli non deve essere cambiato: - * 0) overscan - * 1) filtro - * 2) fullscreen - * 3) fattore di scala - * 4) tipo di paletta (IMPORTANTE: dopo il SDL_SetVideoMode) - */ + // l'ordine dei vari controlli non deve essere cambiato: + // 0) overscan + // 1) filtro + // 2) fullscreen + // 3) fattore di scala + // 4) tipo di paletta (IMPORTANTE: dopo il SDL_SetVideoMode) - /* overscan */ + // overscan { overscan.enabled = cfg->oscan; @@ -266,26 +253,18 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE } if ((filter != cfg->filter) || info.on_cfg || force_scale) { switch (filter) { - case PHOSPHOR: - case SCANLINE: case NO_FILTER: - case DBL: - case CRT_CURVE: - case CRT_NO_CURVE: - case PHOSPHOR2: - case DARK_ROOM: + default: gfx.filter = scale_surface; - /* - * se sto passando dal filtro ntsc ad un'altro, devo - * ricalcolare la larghezza del video mode quindi - * forzo il controllo del fattore di scala. - */ + // se sto passando dal filtro ntsc ad un'altro, devo + // ricalcolare la larghezza del video mode quindi + // forzo il controllo del fattore di scala. if (cfg->filter == NTSC_FILTER) { - /* devo reimpostare la larghezza del video mode */ + // devo reimpostare la larghezza del video mode scale = cfg->scale; - /* forzo il controllo del fattore di scale */ + // forzo il controllo del fattore di scale force_scale = TRUE; - /* indico che devo cambiare il video mode */ + // indico che devo cambiare il video mode set_mode = TRUE; } break; @@ -305,54 +284,46 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE } else if ((filter >= XBRZ2X) && (filter <= XBRZ4X)) { gfx.filter = xBRZ; } - /* - * se sto passando dal filtro ntsc ad un'altro, devo - * ricalcolare la larghezza del video mode quindi - * forzo il controllo del fattore di scala. - */ + // se sto passando dal filtro ntsc ad un'altro, devo + // ricalcolare la larghezza del video mode quindi + // forzo il controllo del fattore di scala. if (cfg->filter == NTSC_FILTER) { - /* forzo il controllo del fattore di scale */ + // forzo il controllo del fattore di scale force_scale = TRUE; - /* indico che devo cambiare il video mode */ + // indico che devo cambiare il video mode set_mode = TRUE; } break; case NTSC_FILTER: gfx.filter = ntsc_surface; - /* - * il fattore di scala deve essere gia' stato - * inizializzato almeno una volta. - */ + // il fattore di scala deve essere gia' stato inizializzato almeno una volta if (cfg->scale != NO_CHANGE) { - /* devo reimpostare la larghezza del video mode */ + // devo reimpostare la larghezza del video mode scale = cfg->scale; } else if (scale == NO_CHANGE) { - /* - * se scale e new_scale sono uguali a NO_CHANGE, - * imposto un default. - */ + // se scale e new_scale sono uguali a NO_CHANGE, imposto un default scale = X2; } - /* forzo il controllo del fattore di scale */ + // forzo il controllo del fattore di scale force_scale = TRUE; - /* indico che devo cambiare il video mode */ + // indico che devo cambiare il video mode set_mode = TRUE; break; } } - /* fullscreen */ + // fullscreen if (fullscreen == NO_CHANGE) { fullscreen = cfg->fullscreen; } if ((fullscreen != cfg->fullscreen) || info.on_cfg) { - /* forzo il controllo del fattore di scale */ + // forzo il controllo del fattore di scale force_scale = TRUE; - /* indico che devo cambiare il video mode */ + // indico che devo cambiare il video mode set_mode = TRUE; } - /* fattore di scala */ + // fattore di scala if (scale == NO_CHANGE) { scale = cfg->scale; } @@ -369,15 +340,10 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE switch (scale) { case X1: - /* - * il fattore di scala a 1 e' possibile - * solo senza filtro. - */ + // il fattore di scala a 1 e' possibile solo senza filtro if (filter != NO_FILTER) { - /* - * con un fattore di scala X1 effect deve essere - * sempre impostato su scale_surface. - */ + // con un fattore di scala X1 effect deve essere + // sempre impostato su scale_surface. gfx.filter = scale_surface; return; } @@ -409,17 +375,15 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE gfx.h[NO_OVERSCAN] = SCR_LINES * scale; } - /* - * cfg->scale e cfg->filter posso aggiornarli prima - * del set_mode, mentre cfg->fullscreen e cfg->palette - * devo farlo necessariamente dopo. - */ - /* salvo il nuovo fattore di scala */ + // cfg->scale e cfg->filter posso aggiornarli prima + // del set_mode, mentre cfg->fullscreen e cfg->palette + // devo farlo necessariamente dopo. + // salvo il nuovo fattore di scala cfg->scale = scale; - /* salvo ill nuovo filtro */ + // salvo ill nuovo filtro cfg->filter = filter; - /* devo eseguire un SDL_SetVideoMode? */ + // devo eseguire un SDL_SetVideoMode? if (set_mode) { uint32_t flags = software_flags; @@ -429,7 +393,7 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE gfx.pixel_aspect_ratio = 1.0f; if (gfx.opengl) { - flags = opengl.flags; + flags = opengl.sdl.flags; SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); @@ -441,9 +405,9 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE //SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); //SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32); - /* abilito il doublebuffering */ + // abilito il doublebuffering SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, TRUE); - /* abilito il vsync se e' necessario */ + // abilito il vsync se e' necessario SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, cfg->vsync); if (fullscreen) { @@ -451,7 +415,7 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE gfx.h[VIDEO_MODE] = gfx.h[MONITOR]; } - /* Pixel Aspect Ratio */ + // Pixel Aspect Ratio { if (cfg->filter == NTSC_FILTER) { gfx.pixel_aspect_ratio = 1.0f; @@ -484,21 +448,19 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE } } - /* faccio quello che serve prima del setvideo */ + // faccio quello che serve prima del setvideo gui_set_video_mode(); - /* - * nella versione a 32 bit (GTK) dopo un gfx_reset_video, - * se non lo faccio anche qui, crasha tutto. - */ + // nella versione a 32 bit (GTK) dopo un gfx_reset_video, + // se non lo faccio anche qui, crasha tutto. //sdl_wid(); - /* inizializzo la superfice video */ + // inizializzo la superfice video surface_sdl = SDL_SetVideoMode(gfx.w[VIDEO_MODE], gfx.h[VIDEO_MODE], 0, flags); gui_after_set_video_mode(); - /* in caso di errore */ + // in caso di errore if (!surface_sdl) { fprintf(stderr, "SDL_SetVideoMode failed : %s\n", SDL_GetError()); return; @@ -507,14 +469,14 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE gfx.bit_per_pixel = surface_sdl->format->BitsPerPixel; } - /* interpolation */ + // interpolation if (gfx.opengl && cfg->interpolation) { opengl.interpolation = TRUE; } else { opengl.interpolation = FALSE; } - /* paletta */ + // paletta if (palette == NO_CHANGE) { palette = cfg->palette; } @@ -556,13 +518,10 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE break; } - /* inizializzo in ogni caso la tabella YUV dell'hqx */ + // inizializzo in ogni caso la tabella YUV dell'hqx hqx_init(); - /* - * memorizzo i colori della paletta nel - * formato di visualizzazione. - */ + //memorizzo i colori della paletta nel formato di visualizzazione { WORD i; @@ -573,12 +532,12 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE } } - /* salvo il nuovo stato del fullscreen */ + // salvo il nuovo stato del fullscreen cfg->fullscreen = fullscreen; - /* salvo il nuovo tipo di paletta */ + // salvo il nuovo tipo di paletta cfg->palette = palette; - /* software rendering */ + // software rendering framebuffer = surface_sdl; flip = SDL_Flip; @@ -592,133 +551,54 @@ void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE h_for_pr = gfx.h[VIDEO_MODE]; if (gfx.opengl) { - opengl.scale_force = FALSE; + DBWORD f = NO_FILTER; opengl.scale = cfg->scale; - opengl.factor = X1; - opengl.PSS = FALSE; - opengl.glsl.shader_used = FALSE; - shader.id = SHADER_NONE; - opengl.glsl.param = 0; - - if ((opengl.glsl.compliant == TRUE) && (opengl.glsl.enabled == TRUE)) { - -#define PSS()\ - opengl.PSS = ((gfx.pixel_aspect_ratio != 1.0f) && (cfg->PAR_soft_stretch == TRUE)) ? TRUE : FALSE -#define glsl_up(e, s, p)\ - opengl.glsl.shader_used = TRUE;\ - shader.id = s;\ - opengl.scale_force = TRUE;\ - opengl.scale = X1;\ - opengl.factor = cfg->scale;\ - PSS();\ - opengl.glsl.param = p;\ - gfx.filter = e - - glsl_delete_shaders(&shader); - - switch (cfg->filter) { - case NO_FILTER: - glsl_up(scale_surface, SHADER_NO_FILTER, 0); - break; - case PHOSPHOR: - glsl_up(scale_surface, SHADER_PHOSPHOR, 0); - break; - case PHOSPHOR2: - glsl_up(scale_surface, SHADER_PHOSPHOR, 1); - break; - case SCANLINE: - glsl_up(scale_surface, SHADER_SCANLINE, 0); - break; - case DBL: - glsl_up(scale_surface, SHADER_DONTBLOOM, 0); - break; - case DARK_ROOM: - glsl_up(scale_surface, SHADER_DONTBLOOM, 1); - break; - case CRT_CURVE: - glsl_up(scale_surface, SHADER_CRT, 0); - /* niente interpolazione perche' gia fatta dallo shader stesso */ - opengl.interpolation = opengl.PSS = FALSE; - break; - case CRT_NO_CURVE: - glsl_up(scale_surface, SHADER_CRT, 1); - /* niente interpolazione perche' gia fatta dallo shader stesso */ - opengl.interpolation = opengl.PSS = FALSE; - break; - case SCALE2X: - case SCALE3X: - case SCALE4X: - case HQ2X: - case HQ3X: - case HQ4X: - case XBRZ2X: - case XBRZ3X: - case XBRZ4X: - case NTSC_FILTER: - PSS(); - break; - } + opengl.PSS = ((gfx.pixel_aspect_ratio != 1.0f) && cfg->PAR_soft_stretch) ? TRUE : FALSE; - /* - if (cfg->fullscreen) { - if ((cfg->filter >= SCALE2X) && (cfg->filter <= SCALE4X)) { - glsl_up(scaleNx, SHADER_NO_FILTER); - opengl.scale = X2; - opengl.factor = (float) cfg->scale / 2.0f; - } else if ((cfg->filter >= HQ2X) && (cfg->filter <= HQ4X)) { - glsl_up(hqNx, SHADER_NO_FILTER); - opengl.scale = X2; - opengl.factor = (float) cfg->scale / 2.0f; - } - } - */ + if ((filter == NO_FILTER) || (filter >= FLTSHDSTART)) { + opengl.scale = X1; + gfx.filter = scale_surface; + f = filter; } - /* creo la superficie che utilizzero' come texture */ - sdl_create_surface_gl(surface_sdl, gfx.w[CURRENT], gfx.h[CURRENT], cfg->fullscreen); - - /* opengl rendering */ - framebuffer = opengl.surface_gl; - flip = opengl_flip; - - text.surface = surface_sdl; - text_clear = opengl_text_clear; - text_blit = opengl_text_blit; - - text.w = gfx.w[CURRENT]; - text.h = gfx.h[CURRENT]; + shaders_set(f); - { - WORD r = (WORD) opengl.quadcoords.r; - WORD l = (WORD) opengl.quadcoords.l; - WORD t = (WORD) opengl.quadcoords.t; - WORD b = (WORD) opengl.quadcoords.b; - - w_for_pr = r - l; - h_for_pr = t - b; - } + // creo tutto il necessario per il rendering + if (sdl_setup_renderingl_gl(surface_sdl) == EXIT_ERROR) { + gfx.opengl = FALSE; + } else { + // opengl rendering + framebuffer = opengl.sdl.surface; + flip = opengl_flip; + + // gestione testo + text.surface = surface_sdl; + text_clear = opengl_text_clear; + text_blit = opengl_text_blit; + text.w = opengl.vp->w; + text.h = opengl.vp->h; + + w_for_pr = opengl.vp->w; + h_for_pr = opengl.vp->h; + } } - /* questo controllo devo farlo necessariamente dopo il glew_init() */ - if ((opengl.glsl.compliant == FALSE) || (opengl.glsl.enabled == FALSE)) { - if ((filter >= PHOSPHOR) && (filter <= CRT_NO_CURVE)) { - filter = NO_FILTER; - goto gfx_set_screen_start; - } + // questo controllo devo farlo necessariamente dopo il glew_init() + if (!gfx.opengl && (filter >= FLTSHDSTART)) { + filter = NO_FILTER; + goto gfx_set_screen_start; } gfx_text_reset(); - /* - * calcolo le proporzioni tra il disegnato a video (overscan e schermo - * con le dimensioni per il filtro NTSC compresi) e quello che dovrebbe - * essere (256 x 240). Mi serve per calcolarmi la posizione del puntatore - * dello zapper. - */ + // calcolo le proporzioni tra il disegnato a video (overscan e schermo + // con le dimensioni per il filtro NTSC compresi) e quello che dovrebbe + // essere (256 x 240). Mi serve per calcolarmi la posizione del puntatore + // dello zapper. gfx.w_pr = ((float) w_for_pr / gfx.w[CURRENT]) * ((float) gfx.w[NO_OVERSCAN] / SCR_ROWS); gfx.h_pr = ((float) h_for_pr / gfx.h[CURRENT]) * ((float) gfx.h[NO_OVERSCAN] / SCR_LINES); - /* setto il titolo della finestra */ + // setto il titolo della finestra gui_update(); if (info.on_cfg == TRUE) { @@ -737,9 +617,9 @@ void gfx_draw_screen(BYTE forced) { } } - /* se il frameskip me lo permette (o se forzato), disegno lo screen */ + // se il frameskip me lo permette (o se forzato), disegno lo screen if (forced || !ppu.skip_draw) { - /* applico l'effetto desiderato */ + // applico l'effetto desiderato if (gfx.opengl) { gfx.filter(screen.data, screen.line, @@ -772,7 +652,7 @@ void gfx_draw_screen(BYTE forced) { text_rendering(TRUE); } - /* disegno a video */ + // disegno a video flip(framebuffer); } } @@ -783,14 +663,6 @@ void gfx_reset_video(void) { surface_sdl = framebuffer = NULL; - if (opengl.surface_gl) { - SDL_FreeSurface(opengl.surface_gl); - } - if (opengl.screen.id) { - glDeleteTextures(1, &opengl.screen.id); - } - opengl.surface_gl = NULL; - //sdl_wid(); SDL_QuitSubSystem(SDL_INIT_VIDEO); SDL_InitSubSystem(SDL_INIT_VIDEO); diff --git a/src/video/sdl/glew/glew.c b/src/video/sdl/glew/glew.c index 0ed5520da..06d10da0d 100644 --- a/src/video/sdl/glew/glew.c +++ b/src/video/sdl/glew/glew.c @@ -30,12 +30,12 @@ ** THE POSSIBILITY OF SUCH DAMAGE. */ -#include +#include "glew/glew.h" #if defined(_WIN32) -# include +# include "glew/wglew.h" #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) -# include +# include "glew/glxew.h" #endif #include /* For size_t */ diff --git a/src/video/sdl/glew/glxew.h b/src/video/sdl/glew/glxew.h index d803d260b..876f61184 100644 --- a/src/video/sdl/glew/glxew.h +++ b/src/video/sdl/glew/glxew.h @@ -98,7 +98,7 @@ #include #include #include -#include +#include "glew/glew.h" #ifdef __cplusplus extern "C" { diff --git a/src/video/sdl/openGL/cube3d.c b/src/video/sdl/openGL/cube3d.c deleted file mode 100644 index 8d1accc5c..000000000 --- a/src/video/sdl/openGL/cube3d.c +++ /dev/null @@ -1,222 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#include "cube3d.h" - -INLINE void draw_primitive_cube3d(void); - -GLfloat x_vertex, y_vertex, z_vertex; -GLfloat distance; -GLfloat matrix_distance[60] = { - -2.000f, -2.020f, -2.040f, -2.060f, -2.080f, - -2.100f, -2.120f, -2.140f, -2.160f, -2.180f, - -2.200f, -2.220f, -2.240f, -2.260f, -2.280f, - -2.300f, -2.320f, -2.340f, -2.360f, -2.380f, - -2.400f, -2.420f, -2.440f, -2.460f, -2.480f, - -2.500f, -2.520f, -2.540f, -2.560f, -2.580f, - -2.600f, -2.620f, -2.640f, -2.660f, -2.680f, - -2.700f, -2.720f, -2.740f, -2.760f, -2.780f, - -2.800f, -2.820f, -2.840f, -2.860f, -2.880f, - -2.890f, -2.900f, -2.910f, -2.920f, -2.930f, - -2.940f, -2.950f, -2.965f, -2.970f, -2.975f, - -2.980f, -2.985f, -2.990f, -2.995f, -3.000f -}; -static _shader color; - -void opengl_init_cube3d(void) { - memset (&color, 0, sizeof(_shader)); -} -void opengl_set_cube3d(SDL_Surface *src) { - x_vertex = 1.0f - ((1.0f / ((GLfloat) src->w / 2.0f)) * opengl.quadcoords.l); - y_vertex = 1.0f - ((1.0f / ((GLfloat) src->h / 2.0f)) * opengl.quadcoords.b); - z_vertex = x_vertex; - - glClearColor(0.0f, 0.0f, 0.0f, 0.0f); - - glViewport(0, 0, (GLint) src->w, (GLint) src->h); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - glFrustum(-1, 1, -1, 1, 1.0f + (1.0f - z_vertex), 100.0f); - - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - glEnable(GL_CULL_FACE); - - glDepthMask(GL_TRUE); - glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - - glDisable(GL_TEXTURE_2D); - - if (opengl.glsl.shader_used) { - color.id = SHADER_COLOR; - glsl_shaders_init(&color); - } -} -void opengl_unset_cube3d(void) { - glsl_delete_shaders(&color); -} -void opengl_draw_scene_cube3d(SDL_Surface *surface) { - /* ripulisco la scena opengl */ - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); - - /* resetto la matrice corrente (modelview) */ - glLoadIdentity(); - - if (opengl.factor_distance < 60) { - distance = matrix_distance[opengl.factor_distance]; - opengl.factor_distance++; - } - glTranslatef(0.0f, 0.0f, distance); - - if (opengl.factor_distance > 30) { - glRotatef(opengl.x_rotate, 1.0f, 0.0f, 0.0f); - glRotatef(opengl.y_rotate, 0.0f, 1.0f, 0.0f); - } - - glEnable(GL_DEPTH_TEST); - - glEnable(GL_TEXTURE_2D); - - opengl_update_scr_texture(surface, TRUE); - - draw_primitive_cube3d(); - - if (opengl.glsl.shader_used) { - glUseProgram(0); - } - - if (opengl_update_txt_texture(FALSE) == EXIT_OK) { - glDisable(GL_DEPTH_TEST); - - /* disegno la texture del testo */ - draw_primitive_cube3d(); - - glDisable(GL_BLEND); - } - - glDisable(GL_TEXTURE_2D); - - if (opengl.glsl.shader_used) { - glUseProgram(color.prg); - } - - glEnable(GL_DEPTH_TEST); - - /* cubo interno */ - glBegin(GL_QUADS); - /* avanti */ - glColor3f(1.0f, 1.0f, 1.0f); - glVertex3f(+x_vertex, -y_vertex, +z_vertex); - glVertex3f(-x_vertex, -y_vertex, +z_vertex); - glVertex3f(-x_vertex, +y_vertex, +z_vertex); - glVertex3f(+x_vertex, +y_vertex, +z_vertex); - /* dietro */ - glColor3f(1.0f, 0.0f, 0.0f); - glVertex3f(-x_vertex, -y_vertex, -z_vertex); - glVertex3f(+x_vertex, -y_vertex, -z_vertex); - glVertex3f(+x_vertex, +y_vertex, -z_vertex); - glVertex3f(-x_vertex, +y_vertex, -z_vertex); - /* destra */ - glColor3f(0.0f, 1.0f, 0.0f); - glVertex3f(+x_vertex, -y_vertex, -z_vertex); - glVertex3f(+x_vertex, -y_vertex, +z_vertex); - glVertex3f(+x_vertex, +y_vertex, +z_vertex); - glVertex3f(+x_vertex, +y_vertex, -z_vertex); - /* sinistra */ - glColor3f(0.0f, 0.0f, 1.0f); - glVertex3f(-x_vertex, -y_vertex, +z_vertex); - glVertex3f(-x_vertex, -y_vertex, -z_vertex); - glVertex3f(-x_vertex, +y_vertex, -z_vertex); - glVertex3f(-x_vertex, +y_vertex, +z_vertex); - glEnd(); - - if (opengl.glsl.shader_used) { - glUseProgram(0); - } -} - -INLINE void draw_primitive_cube3d(void) { - /* cubo esterno */ - glBegin(GL_QUADS); - /* avanti */ - glColor3f(1.0f, 1.0f, 1.0f); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.t); - glVertex3f(-x_vertex, -y_vertex, +z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.t); - glVertex3f(+x_vertex, -y_vertex, +z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.b); - glVertex3f(+x_vertex, +y_vertex, +z_vertex); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.b); - glVertex3f(-x_vertex, +y_vertex, +z_vertex); - /* dietro */ - glColor3f(1.0f, 0.0f, 0.0f); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.t); - glVertex3f(+x_vertex, -y_vertex, -z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.t); - glVertex3f(-x_vertex, -y_vertex, -z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.b); - glVertex3f(-x_vertex, +y_vertex, -z_vertex); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.b); - glVertex3f(+x_vertex, +y_vertex, -z_vertex); - /* sopra */ - /* - glTexCoord2f(0.0f, opengl.texture.y); - glVertex3f(-x_vertex, +y_vertex, +z_vertex); - glTexCoord2f(opengl.texture.x, opengl.texture.y); - glVertex3f(+x_vertex, +y_vertex, +z_vertex); - glTexCoord2f(opengl.texture.x, 0.0f); - glVertex3f(+x_vertex, +y_vertex, -z_vertex); - glTexCoord2f(0.0f, 0.0f); - glVertex3f(-x_vertex, +y_vertex, -z_vertex); - */ - /* sotto */ - /* - glTexCoord2f(0.0f, opengl.texture.y); - glVertex3f(+x_vertex, -y_vertex, +z_vertex); - glTexCoord2f(opengl.texture.x, opengl.texture.y); - glVertex3f(-x_vertex, -y_vertex, +z_vertex); - glTexCoord2f(opengl.texture.x, 0.0f); - glVertex3f(-x_vertex, -y_vertex, -z_vertex); - glTexCoord2f(0.0f, 0.0f); - glVertex3f(+x_vertex, -y_vertex, -z_vertex); - */ - /* destra */ - glColor3f(0.0f, 1.0f, 0.0f); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.t); - glVertex3f(+x_vertex, -y_vertex, +z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.t); - glVertex3f(+x_vertex, -y_vertex, -z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.b); - glVertex3f(+x_vertex, +y_vertex, -z_vertex); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.b); - glVertex3f(+x_vertex, +y_vertex, +z_vertex); - /* sinistra */ - glColor3f(0.0f, 0.0f, 1.0f); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.t); - glVertex3f(-x_vertex, -y_vertex, -z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.t); - glVertex3f(-x_vertex, -y_vertex, +z_vertex); - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.b); - glVertex3f(-x_vertex, +y_vertex, +z_vertex); - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.b); - glVertex3f(-x_vertex, +y_vertex, -z_vertex); - glEnd(); -} diff --git a/src/video/sdl/openGL/no_effect.c b/src/video/sdl/openGL/no_effect.c deleted file mode 100644 index 10d268319..000000000 --- a/src/video/sdl/openGL/no_effect.c +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#include "no_effect.h" - -INLINE void draw_primitive_no_effect(void); - -void opengl_init_no_effect(void) { - return; -} -void opengl_set_no_effect(SDL_Surface *src) { - glClearColor(0.0f, 0.0f, 0.0f, 0.0f); - - glViewport(0, 0, (GLint) src->w, (GLint) src->h); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - glOrtho(0.0f, src->w, src->h, 0.0f, -1.0f, 1.0f); - - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - glDisable(GL_ALPHA_TEST); - glDisable(GL_BLEND); - glDisable(GL_DEPTH_TEST); - glDisable(GL_POLYGON_SMOOTH); - glDisable(GL_STENCIL_TEST); - - glEnable(GL_DITHER); - - glDepthMask(GL_FALSE); - - glDisable(GL_TEXTURE_2D); -} -void opengl_unset_no_effect(void) { - return; -} -void opengl_draw_scene_no_effect(SDL_Surface *surface) { - /* ripulisco la scena opengl */ - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); - - glEnable(GL_TEXTURE_2D); - - opengl_update_scr_texture(surface, FALSE); - - /* disegno la texture dello screen */ - draw_primitive_no_effect(); - - if (opengl.glsl.shader_used) { - glUseProgram(0); - } - - if (opengl_update_txt_texture(FALSE) == EXIT_OK) { - /* disegno la texture del testo */ - draw_primitive_no_effect(); - - glDisable(GL_BLEND); - } - - glDisable(GL_TEXTURE_2D); -} - -INLINE void draw_primitive_no_effect(void) { - glBegin(GL_QUADS); - /* Bottom Left Of The Texture */ - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.b); - glVertex2f(opengl.quadcoords.l, opengl.quadcoords.b); - /* Bottom Right Of The Texture */ - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.b); - glVertex2f(opengl.quadcoords.r, opengl.quadcoords.b); - /* Top Right Of The Texture */ - glTexCoord2f(opengl.texcoords.r, opengl.texcoords.t); - glVertex2f(opengl.quadcoords.r, opengl.quadcoords.t); - /* Top Left Of The Texture */ - glTexCoord2f(opengl.texcoords.l, opengl.texcoords.t); - glVertex2f(opengl.quadcoords.l, opengl.quadcoords.t); - glEnd(); -} diff --git a/src/video/sdl/openGL/no_effect.h b/src/video/sdl/openGL/no_effect.h deleted file mode 100644 index 22b06e8b6..000000000 --- a/src/video/sdl/openGL/no_effect.h +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#ifndef NO_EFFECT_H_ -#define NO_EFFECT_H_ - -#include "opengl.h" - -void opengl_init_no_effect(void); -void opengl_set_no_effect(SDL_Surface *src); -void opengl_unset_no_effect(void); -void opengl_draw_scene_no_effect(SDL_Surface *surface); - -#endif /* NO_EFFECT_H_ */ diff --git a/src/video/sdl/opengl.c b/src/video/sdl/opengl.c index 7cbf3c342..1c14d127b 100644 --- a/src/video/sdl/opengl.c +++ b/src/video/sdl/opengl.c @@ -16,381 +16,363 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +#include "common.h" #include "opengl.h" -#include "gfx.h" #include "ppu.h" #include "conf.h" -#include "openGL/no_effect.h" -#include "openGL/cube3d.h" -#define _SHADERS_CODE_ -#include "shaders.h" -#undef _SHADERS_CODE_ -void glsl_print_log(GLuint obj, BYTE ret); -char *glsl_file2string(const char *path); +#include "qt.h" +#include "cgp.h" + +#define FHOPENGLGEST + +#define BUFFER_OFFSET(i) ((char *)NULL + (i)) + +enum _texture_info { + TI_INTFRM = GL_RGBA8, + TI_FRM = GL_BGRA, + TI_TYPE = GL_UNSIGNED_BYTE, + TI_F_INTFRM = GL_RGBA32F, + TI_F_TYPE = GL_FLOAT, + TI_S_INTFRM = GL_SRGB8_ALPHA8, + TI_S_TYPE = GL_UNSIGNED_BYTE +}; + +static BYTE glew_init(void); + +static void shd_init(_shader *shd, const GLchar *code); +static void shd_delete(_shader *shd); +static void shd_print_log(GLuint obj, BYTE ret); +char *shd_file2string(const char *path); +static void shd_uni_texture(_shader_uniforms_tex *uni, GLint prg, GLchar *fmt, ...); +static GLint shd_get_uni(GLuint prog, const char *param); +static GLint shd_get_atr(GLuint prog, const char *param); +static void shd_set_vertex_buffer(_vertex_buffer *vb, _texture_rect *rect); +INLINE static void shd_set_params_text(_shader *shd); +INLINE static void shd_set_params(const _shader *shd, GLuint fcountmod, GLuint fcount); + +static BYTE tex_create(_texture *texture, GLuint index, GLuint clean); +static void tex_create_simple(_texture_simple *texture, GLuint w, GLuint h, BYTE fixed); +static void tex_create_lut(_lut *lut, GLuint index); +static void tex_delete_screen(void); +static void tex_delete_text(void); + +static GLint power_of_two(GLint base); +static const GLint get_integer(const GLenum penum); + +static const _vertex_buffer vb_upright[4] = { + { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, + { 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, + { 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, + { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, +}; +static const _vertex_buffer vb_flipped[4] = { + { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, + { 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, + { 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, + { 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, +}; +static const GLchar *uni_prefixes[] = { "", "ruby", }; void sdl_init_gl(void) { - opengl.rotation = 0; - opengl.surface_gl = NULL; - - opengl.flags = SDL_HWSURFACE | SDL_OPENGL; - opengl.factor_distance = 0; - opengl.x_rotate = 0; - opengl.y_rotate = 0; - opengl.x_diff = 0; - opengl.y_diff = 0; - - memset(&opengl.screen, 0, sizeof(_texture)); - memset(&shader, 0, sizeof(shader)); - - opengl_init_effect = opengl_init_no_effect; - opengl_set_effect = opengl_set_no_effect; - opengl_unset_effect = opengl_unset_no_effect; - opengl_draw_scene = opengl_draw_scene_no_effect; + opengl.sdl.surface = NULL; + opengl.sdl.flags = SDL_HWSURFACE | SDL_OPENGL; + opengl.vp = NULL; + + memset(&opengl.alias_define, 0x00, sizeof(opengl.alias_define)); + memset(&opengl.screen, 0x00, sizeof(opengl.screen)); + memset(&opengl.feedback, 0x00, sizeof(opengl.feedback)); + memset(&opengl.text, 0x00, sizeof(_texture_simple)); + memset(&opengl.texture, 0x00, LENGTH(opengl.texture) * sizeof(_texture)); + memset(&opengl.lut, 0x00, LENGTH(opengl.lut) * sizeof(_lut)); + + if (glew_init() == EXIT_ERROR) { + opengl.supported = FALSE; + return; + } - glew_init(); + // Calculate projection + matrix_4x4_ortho(&opengl.mvp, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f); } void sdl_quit_gl(void) { - if (opengl.surface_gl) { - SDL_FreeSurface(opengl.surface_gl); - } + tex_delete_screen(); + tex_delete_text(); +} +BYTE sdl_setup_renderingl_gl(SDL_Surface *src) { + GLuint i, w, h; - if (opengl.screen.id) { - glDeleteTextures(1, &opengl.screen.id); - } + glGetError(); - if (opengl.text.id) { - glDeleteTextures(1, &opengl.text.id); - } + glDisable(GL_DEPTH_TEST); + glDisable(GL_STENCIL_TEST); + glDisable(GL_CULL_FACE); + glDisable(GL_DITHER); + glDisable(GL_BLEND); - if (opengl_unset_effect) { - opengl_unset_effect(); - } + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - glsl_delete_shaders(&shader); -} -void sdl_create_surface_gl(SDL_Surface *src, WORD width, WORD height, BYTE flags) { - if (opengl.surface_gl) { - SDL_FreeSurface(opengl.surface_gl); - /* - * ripristino gli attributi opengl ai valori - * iniziali e li salvo nuovamente. - */ - glPopAttrib(); - } + glEnable(GL_TEXTURE_2D); - glPushAttrib(GL_ALL_ATTRIB_BITS); + tex_delete_screen(); - if (opengl.scale_force) { - opengl.surface_gl = gfx_create_RGB_surface(src, SCR_ROWS * opengl.scale, - SCR_LINES * opengl.scale); + if ((cfg->filter == NO_FILTER) || (cfg->filter >= FLTSHDSTART)) { + w = gfx.rows; + h = gfx.lines; } else { - opengl.surface_gl = gfx_create_RGB_surface(src, width, height); + w = gfx.w[CURRENT]; + h = gfx.h[CURRENT]; } - opengl_create_texture(&opengl.screen, opengl.surface_gl->w, opengl.surface_gl->h, POWER_OF_TWO); + opengl.sdl.surface = gfx_create_RGB_surface(src, w, h); - opengl.texcoords.l = 0.0f; - opengl.texcoords.r = (GLfloat) width / (opengl.screen.w * opengl.factor); - opengl.texcoords.b = 0.0f; - opengl.texcoords.t = (GLfloat) height / (opengl.screen.h * opengl.factor); + // screen + tex_create_simple(&opengl.screen.tex[0], w, h, TRUE); - { - /* aspect ratio */ - GLfloat w_quad = (GLfloat) src->w; - GLfloat h_quad = (GLfloat) src->h; - - opengl.quadcoords.l = 0.0f; - opengl.quadcoords.r = w_quad; - opengl.quadcoords.b = 0.0f; - opengl.quadcoords.t = h_quad; - - /* con flags intendo sia il fullscreen che il futuro resize */ - if (flags && !cfg->stretch) { - GLfloat ratio_surface = w_quad / h_quad; - GLfloat ratio_frame = (GLfloat) width / (GLfloat) height; - - /* - * se l'aspect ratio del frame e' maggiore di - * quello della superficie allora devo agire - * sull'altezza. - */ - if (ratio_frame > ratio_surface) { - GLfloat centering_factor = 0.0f; - - h_quad = trunc((w_quad / ratio_frame) / gfx.pixel_aspect_ratio); - centering_factor = trunc(((GLfloat) src->h - h_quad) / 2.0f); - - opengl.quadcoords.l = 0.0f; - opengl.quadcoords.r = w_quad; - opengl.quadcoords.b = centering_factor; - opengl.quadcoords.t = h_quad + centering_factor; - } else if (ratio_frame < ratio_surface) { - /* - * se l'aspect ratio del frame e' minore di - * quello della superficie allora devo agire - * sulla larghezza. - */ - GLfloat centering_factor = 0.0f; - - w_quad = trunc((h_quad * ratio_frame) * gfx.pixel_aspect_ratio); - centering_factor = trunc(((GLfloat) src->w - w_quad) / 2.0f); - - opengl.quadcoords.l = centering_factor; - opengl.quadcoords.r = w_quad + centering_factor; - opengl.quadcoords.b = 0.0f; - opengl.quadcoords.t = h_quad; - } + // creo le restanti texture/fbo + for (i = 0; i < shader_effect.pass; i++) { + if (tex_create(&opengl.texture[i], i, FALSE) == EXIT_ERROR) { + sdl_quit_gl(); + return (EXIT_ERROR); } } - opengl_create_texture(&opengl.text, opengl.screen.w * opengl.factor, - opengl.screen.h * opengl.factor, NO_POWER_OF_TWO); - - if (opengl.glsl.enabled && opengl.glsl.shader_used) { - glsl_shaders_init(&shader); + // non inizializzo le shader nel tex_create perche' opengl.alias_define + // viene costruita proprio durante il tex_create e a me serve completa quando + // inizializzo le shaders. + for (i = 0; i < shader_effect.pass; i++) { + shd_init(&opengl.texture[i].shader, shader_effect.sp[i].code); } - opengl_unset_effect(); - opengl_set_effect(src); - - glFinish(); -} + // PREV (calcolo il numero di screen da utilizzare) + // deve essere fatto dopo il shd_init(). + for (i = 0; i < shader_effect.pass; i++) { + GLuint a; -void opengl_create_texture(_texture *texture, uint32_t width, uint32_t height, uint8_t pow) { - GLfloat clr_color[4] = { 0, 0, 0, 0 }; - - switch (opengl.surface_gl->format->BitsPerPixel) { - case 16: - texture->format_internal = GL_RGB5; - if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { - texture->format = GL_BGR; - texture->type = GL_UNSIGNED_SHORT_5_6_5_REV; - } else { - texture->format = GL_RGB; - texture->type = GL_UNSIGNED_SHORT_5_6_5; - } - break; - case 24: - texture->format_internal = GL_RGB8; - if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { - texture->format = GL_BGR; - } else { - texture->format = GL_RGB; + for (a = 0; a < LENGTH(opengl.texture[i].shader.uni.prev); a++) { + if (opengl.texture[i].shader.uni.prev[a].texture >= 0) { + if (opengl.screen.in_use < (a + 1)) { + opengl.screen.in_use = (a + 1); + } } - texture->type = GL_UNSIGNED_BYTE; - break; - case 32: - default: - texture->format_internal = GL_RGBA8; - texture->format = GL_BGRA; - texture->type = GL_UNSIGNED_BYTE; - break; - } - - if (pow) { - texture->w = opengl_power_of_two(width); - texture->h = opengl_power_of_two(height); - } else { - texture->w = width; - texture->h = height; + } } - glEnable(GL_TEXTURE_2D); + opengl.screen.in_use++; - if (texture->id) { - glDeleteTextures(1, &texture->id); + // PREV + for (i = 1; i < opengl.screen.in_use; i++) { + tex_create_simple(&opengl.screen.tex[i], w, h, TRUE); } - glGenTextures(1, &texture->id); - glBindTexture(GL_TEXTURE_2D, texture->id); + // il vieport generale e' quello dell'ultimo pass + opengl.vp = &opengl.texture[shader_effect.last_pass].vp; - //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + // configuro l'aspect ratio del fullscreen + if (cfg->fullscreen && !cfg->stretch) { + GLfloat ratio_surface = ((GLfloat) gfx.rows / (GLfloat) gfx.lines) * gfx.pixel_aspect_ratio; + GLfloat ratio_frame = (GLfloat) src->w / (GLfloat) src->h; + GLfloat delta; - { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); - glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, clr_color); + if (ratio_frame > ratio_surface) { + delta = (ratio_surface / ratio_frame - 1.0f) / 2.0f + 0.5f; + opengl.vp->x = (int) roundf((GLfloat) src->w * (0.5f - delta)); + opengl.vp->w = (unsigned) roundf(2.0f * (GLfloat) src->w * delta); + } else { + delta = (ratio_frame / ratio_surface - 1.0f) / 2.0f + 0.5f; + opengl.vp->y = (int) roundf((GLfloat) src->h * (0.5f - delta)); + opengl.vp->h = (unsigned) roundf(2.0f * (GLfloat) src->h * delta); + } } - if (opengl.glew && !GLEW_VERSION_3_0) { - glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); + // FEEDBACK + if ((shader_effect.feedback_pass >= 0) && (shader_effect.feedback_pass < shader_effect.pass)) { + opengl.feedback.in_use = TRUE; + + if (tex_create(&opengl.feedback.tex, shader_effect.feedback_pass, TRUE) == EXIT_ERROR) { + sdl_quit_gl(); + return (EXIT_ERROR); + } } - // creo la texture nella GPU - glTexImage2D(GL_TEXTURE_2D, 0, texture->format_internal, texture->w, texture->h, 0, - texture->format, texture->type, NULL); + // testo + { + _shader *sh = &opengl.text.shader; - if (opengl.glew && GLEW_VERSION_3_0) { - glGenerateMipmap(GL_TEXTURE_2D); - } + tex_delete_text(); - // pulisco la texture - if (opengl.glew && GLEW_VERSION_3_0) { - GLuint fbo; + tex_create_simple(&opengl.text, opengl.vp->w, opengl.vp->h, FALSE); - glGenFramebuffers(1, &fbo); - glBindFramebuffer(GL_FRAMEBUFFER, fbo); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->id, 0); - glDrawBuffer(GL_COLOR_ATTACHMENT0); - glClearBufferfv(GL_COLOR, 0, clr_color); - glBindFramebuffer(GL_FRAMEBUFFER, 0); - glDeleteFramebuffers(1, &fbo); - } else { - int size = texture->w * texture->h * 4; - GLubyte emptyData[size]; + glGenBuffers(1, &sh->vbo); + memcpy(sh->vb, vb_flipped, sizeof(vb_flipped)); - memset (emptyData, 0x00, size); - glTexImage2D(GL_TEXTURE_2D, 0, texture->format_internal, texture->w, texture->h, 0, - texture->format, texture->type, &emptyData[0]); - } + glBindBuffer(GL_ARRAY_BUFFER, sh->vbo); + glBufferData(GL_ARRAY_BUFFER, sizeof(sh->vb), sh->vb, GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); - glDisable(GL_TEXTURE_2D); - glBindTexture(GL_TEXTURE_2D, 0); -} -void opengl_update_scr_texture(SDL_Surface *surface, uint8_t generate_mipmap) { - glBindTexture(GL_TEXTURE_2D, opengl.screen.id); + shd_init(sh, shader_code_blend()); + } - if (generate_mipmap && opengl.glew && !GLEW_VERSION_3_0) { - glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); + for (i = 0; i < shader_effect.luts; i++) { + tex_create_lut(&opengl.lut[i], i); } - glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->w); + // setto tutto quello che mi serve per il rendering + for (i = 0; i < shader_effect.pass; i++) { + _texture *tex = &opengl.texture[i]; + _shader *shd = &tex->shader; + _texture_rect *prev = NULL; + GLuint a, b; - glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, surface->w, surface->h, opengl.screen.format, - opengl.screen.type, surface->pixels); + if (i == 0) { + prev = &opengl.screen.tex[0].rect; + } else { + prev = &opengl.texture[i - 1].rect; + } - glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + shd->info.input_size[0] = (GLfloat) prev->base.w; + shd->info.input_size[1] = (GLfloat) prev->base.h; + shd->info.texture_size[0] = (GLfloat) prev->w, + shd->info.texture_size[1] = (GLfloat) prev->h; + shd->info.output_size[0] = (GLfloat) tex->vp.w; + shd->info.output_size[1] = (GLfloat) tex->vp.h; - if (generate_mipmap && opengl.glew && GLEW_VERSION_3_0) { - glGenerateMipmap(GL_TEXTURE_2D); - } + shd_set_vertex_buffer(&shd->vb[0], prev); - if ((opengl.interpolation == TRUE) || (opengl.PSS == TRUE)) { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - } else { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - } + for (a = 0; a < LENGTH(shd->vb); a++) { + // ORIG e PREV texture coord + shd->vb[a].origtx[0] = opengl.screen.tex[0].shader.vb[a].s0; + shd->vb[a].origtx[1] = opengl.screen.tex[0].shader.vb[a].t0; - if (opengl.glsl.shader_used) { - glUseProgram(shader.prg); + // FEEDBACK + if (opengl.feedback.in_use) { + shd->vb[a].feedtx[0] = opengl.texture[shader_effect.feedback_pass].shader.vb[a].s0; + shd->vb[a].feedtx[1] = opengl.texture[shader_effect.feedback_pass].shader.vb[a].t0; + } - if (shader.loc.frame_counter != -1) { - glUniform1f(shader.loc.frame_counter, (GLfloat) ppu.frames); + // LUT texture coord + shd->vb[a].luttx[0] = vb_upright[a].s0; + shd->vb[a].luttx[1] = vb_upright[a].t0; } - } -} -BYTE opengl_update_txt_texture(uint8_t generate_mipmap) { - if (!cfg->txt_on_screen || !text.on_screen) { - return (EXIT_ERROR); + // PASSPREV texture coord + for (a = 0; a < i; a++) { + for (b = 0; b < LENGTH(shd->vb); b++) { + shd->vb[b].pptx[(a * 2) + 0] = opengl.texture[a + 1].shader.vb[b].s0; + shd->vb[b].pptx[(a * 2) + 1] = opengl.texture[a + 1].shader.vb[b].t0; + } + } + + glBindBuffer(GL_ARRAY_BUFFER, shd->vbo); + glBufferData(GL_ARRAY_BUFFER, sizeof(shd->vb), shd->vb, GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); } - glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glFinish(); - glBindTexture(GL_TEXTURE_2D, opengl.text.id); + return (EXIT_OK); +} - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +void opengl_draw_scene(SDL_Surface *surface) { + GLuint i; - if (generate_mipmap && opengl.glew && !GLEW_VERSION_3_0) { - glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); - glGenerateMipmap(GL_TEXTURE_2D); - } + // screen + glBindTexture(GL_TEXTURE_2D, opengl.screen.tex[opengl.screen.index].id); + glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->w); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, surface->w, surface->h, TI_FRM, TI_TYPE, + surface->pixels); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - return (EXIT_OK); -} -void opengl_effect_change(BYTE mode) { - if (input_zapper_is_connected((_port *) &port) == TRUE) { - return; + if (opengl.supported_fbo.srgb) { + glEnable(GL_FRAMEBUFFER_SRGB); } - if (opengl_unset_effect) { - opengl_unset_effect(); + // fbo e pass + for (i = 0; i < shader_effect.pass; i++) { + const _texture *t = &opengl.texture[i]; + const _shader_pass *sp = &shader_effect.sp[i]; + GLuint id, fbo = t->fbo; + + shader_effect.running_pass = i; + + if (i == shader_effect.last_pass) { + fbo = 0; + if (opengl.supported_fbo.srgb) { + glDisable(GL_FRAMEBUFFER_SRGB); + } + } + + if (i == 0) { + id = opengl.screen.tex[opengl.screen.index].id; + } else { + id = opengl.texture[i - 1].id; + } + + glBindFramebuffer(GL_FRAMEBUFFER, fbo); + glClear(GL_COLOR_BUFFER_BIT); + glViewport(t->vp.x, t->vp.y, t->vp.w, t->vp.h); + glUseProgram(t->shader.prg); + shd_set_params(&t->shader, sp->frame_count_mod, ppu.frames); + glBindTexture(GL_TEXTURE_2D, id); + if (sp->mipmap_input) { + glGenerateMipmap(GL_TEXTURE_2D); + } + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } - opengl.rotation = mode; + opengl.screen.index = ((opengl.screen.index + 1) % opengl.screen.in_use); - if (opengl.rotation) { - opengl_init_effect = opengl_init_cube3d; - opengl_set_effect = opengl_set_cube3d; - opengl_unset_effect = opengl_unset_cube3d; - opengl_draw_scene = opengl_draw_scene_cube3d; + if (opengl.feedback.in_use) { + GLuint fbo = opengl.feedback.tex.fbo; + GLuint tex = opengl.feedback.tex.id; - opengl.factor_distance = opengl.x_rotate = opengl.y_rotate = 0; - } else { - opengl_init_effect = opengl_init_no_effect; - opengl_set_effect = opengl_set_no_effect; - opengl_unset_effect = opengl_unset_no_effect; - opengl_draw_scene = opengl_draw_scene_no_effect; + opengl.feedback.tex.fbo = opengl.texture[shader_effect.feedback_pass].fbo; + opengl.feedback.tex.id = opengl.texture[shader_effect.feedback_pass].id; + opengl.texture[shader_effect.feedback_pass].fbo = fbo; + opengl.texture[shader_effect.feedback_pass].id = tex; } - opengl_init_effect(); + // testo + if (!cfg->txt_on_screen || !text.on_screen) { + return; + } - gfx_set_screen(NO_CHANGE, NO_CHANGE, NO_CHANGE, NO_CHANGE, FALSE, FALSE); + glViewport(0, 0, opengl.text.rect.w, opengl.text.rect.h); + glUseProgram(opengl.text.shader.prg); + glBindTexture(GL_TEXTURE_2D, opengl.text.id); + shd_set_params_text(&opengl.text.shader); + glEnable(GL_BLEND); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + glDisable(GL_BLEND); } - void opengl_text_clear(_txt_element *ele) { if (!ele->blank) { return; } - glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, opengl.text.id); - glPixelStorei(GL_UNPACK_ROW_LENGTH, ele->w); - glTexSubImage2D(GL_TEXTURE_2D, 0, ele->x, ele->y, ele->w, ele->h, - opengl.text.format, opengl.text.type, ele->blank->pixels); - + TI_FRM, TI_TYPE, ele->blank->pixels); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - - glDisable(GL_TEXTURE_2D); } void opengl_text_blit(_txt_element *ele, _rect *rect) { if (!cfg->txt_on_screen) { return; } - glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, opengl.text.id); - glPixelStorei(GL_UNPACK_ROW_LENGTH, rect->w); - - glTexSubImage2D(GL_TEXTURE_2D, 0, rect->x, rect->y, rect->w, rect->h, opengl.text.format, - opengl.text.type, ele->surface->pixels); - + glTexSubImage2D(GL_TEXTURE_2D, 0, rect->x, rect->y, rect->w, rect->h, + TI_FRM, TI_TYPE, ele->surface->pixels); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - - glDisable(GL_TEXTURE_2D); } - int opengl_flip(SDL_Surface *surface) { SDL_GL_SwapBuffers(); return (0); } -int opengl_power_of_two(int base) { - int pot = 1; - - while (pot < base) { - pot <<= 1; - } - return (pot); -} - -void glew_init(void) { - opengl.glsl.compliant = FALSE; - /* opengl.glsl.enabled e' stato gia' settato dal file di configurazioen o - * dalla riga di comando. - * opengl.glsl.enabled = FALSE; - */ - opengl.glew = FALSE; +static BYTE glew_init(void) { if (opengl.supported){ GLenum err; @@ -398,145 +380,141 @@ void glew_init(void) { if ((err = glewInit()) != GLEW_OK) { fprintf(stderr, "INFO: %s\n", glewGetErrorString(err)); - opengl.glew = FALSE; } else { - opengl.glew = TRUE; - - if (GLEW_VERSION_2_0) { - fprintf(stderr, "INFO: OpenGL 2.0 supported. Glsl enabled.\n"); - opengl.glsl.compliant = TRUE; - } else { - fprintf(stderr, "INFO: OpenGL 2.0 not supported. Glsl disabled.\n"); - opengl.glsl.compliant = FALSE; - opengl.glsl.enabled = FALSE; + fprintf(stderr, "INFO: GPU %s (%s, %s)\n", glGetString(GL_RENDERER), + glGetString(GL_VENDOR), + glGetString(GL_VERSION)); + fprintf(stderr, "INFO: GL Version %d.%d %s\n", + get_integer(GL_MAJOR_VERSION), get_integer(GL_MINOR_VERSION), + get_integer(GL_CONTEXT_CORE_PROFILE_BIT) ? "Core" : "Compatibility"); + + if (!GLEW_VERSION_3_0) { + fprintf(stderr, "INFO: OpenGL 3.0 not supported. Disabled.\n"); + return (EXIT_ERROR); + } + + if (!GLEW_ARB_framebuffer_object) { + return (EXIT_ERROR); } - if (GLEW_VERSION_3_0) { - fprintf(stderr, "INFO: OpenGL 3.0 supported.\n"); - } else { - fprintf(stderr, "INFO: OpenGL 3.0 not supported.\n"); + if (!(glGenFramebuffers && glBindFramebuffer && glFramebufferTexture2D && + glCheckFramebufferStatus && glDeleteFramebuffers)) { + return (EXIT_ERROR); } + + opengl.supported_fbo.flt = GLEW_ARB_texture_float; + opengl.supported_fbo.srgb = (GLEW_EXT_texture_sRGB && GLEW_ARB_framebuffer_sRGB); + + return (EXIT_OK); } } + + return (EXIT_ERROR); } -void glsl_shaders_init(_shader *shd) { - shd->code = &shader_code[shd->id]; +static void shd_init(_shader *shd, const GLchar *code) { + const GLchar *src[3]; + GLuint i, vrt, frg; + + if (code == NULL) { + return; + } - /* program */ + // program shd->prg = glCreateProgram(); - /* vertex */ - if (shd->code->vertex != NULL) { - shd->vrt = glCreateShader(GL_VERTEX_SHADER); - glShaderSource(shd->vrt, 1, &shd->code->vertex, NULL); - glCompileShader(shd->vrt); + src[1] = opengl.alias_define; + src[2] = code; + + // vertex + src[0] = "#define VERTEX\n#define PARAMETER_UNIFORM\n"; + vrt = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vrt, 3, src, NULL); + glCompileShader(vrt); #if !defined (RELEASE) - glsl_print_log(shd->vrt, FALSE); + shd_print_log(vrt, FALSE); #endif - glAttachShader(shd->prg, shd->vrt); - } - - /* fragment */ - if (shd->code->fragment != NULL) { - shd->frg = glCreateShader(GL_FRAGMENT_SHADER); - glShaderSource(shd->frg, 1, &shd->code->fragment, NULL); - glCompileShader(shd->frg); + glAttachShader(shd->prg, vrt); + glDeleteShader(vrt); + + // fragment + src[0] = "#define FRAGMENT\n#define PARAMETER_UNIFORM\n"; + frg = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(frg, 3, src, NULL); + glCompileShader(frg); #if !defined (RELEASE) - glsl_print_log(shd->frg, FALSE); + shd_print_log(frg, FALSE); #endif - glAttachShader(shd->prg, shd->frg); - } + glAttachShader(shd->prg, frg); + glDeleteShader(frg); glLinkProgram(shd->prg); #if !defined (RELEASE) - glsl_print_log(shd->prg, TRUE); + shd_print_log(shd->prg, TRUE); #endif glUseProgram(shd->prg); + glUniform1i(shd_get_uni(shd->prg, "Texture"), 0); + + shd->uni.mvp = shd_get_uni(shd->prg, "MVPMatrix"); + shd->uni.tex_coord = shd_get_atr(shd->prg, "TexCoord"); + shd->uni.vertex_coord = shd_get_atr(shd->prg, "VertexCoord"); { - GLfloat sse[2], svm[2], st[2], fc, param, par, full_interpolation; + // alcuni driver fanno distinzione tra COLOR e Color + // se lascio solo Color con questi driver l'applicazione crasha + // mentre su altri driver se uso solo COLOR la shader non funziona + // quindi utilizzo entrambi. + shd->uni.COLOR = shd_get_atr(shd->prg, "COLOR"); + shd->uni.color = shd_get_atr(shd->prg, "Color"); + } - sse[0] = (GLfloat) SCR_ROWS; - sse[1] = (GLfloat) SCR_LINES; + shd->uni.input_size = shd_get_uni(shd->prg, "InputSize"); + shd->uni.output_size = shd_get_uni(shd->prg, "OutputSize"); + shd->uni.texture_size = shd_get_uni(shd->prg, "TextureSize"); - if (overscan.enabled) { - sse[0] -= (GLfloat) (overscan.borders->left + overscan.borders->right); - sse[1] -= (GLfloat) (overscan.borders->up + overscan.borders->down); - } + shd->uni.frame_count = shd_get_uni(shd->prg, "FrameCount"); + shd->uni.frame_direction = shd_get_uni(shd->prg, "FrameDirection"); - svm[0] = opengl.quadcoords.r - opengl.quadcoords.l; - svm[1] = opengl.quadcoords.t - opengl.quadcoords.b; - st[0] = opengl.screen.w; - st[1] = opengl.screen.h; + for (i = 0; i < shader_effect.params; i++) { + shd->uni.param[i] = shd_get_uni(shd->prg, shader_effect.param[i].name); + } - fc = (GLfloat) ppu.frames; - param = (GLfloat) opengl.glsl.param; - par = gfx.pixel_aspect_ratio; - full_interpolation = opengl.interpolation; + shd_uni_texture(&shd->uni.orig, shd->prg, "Orig"); + shd_uni_texture(&shd->uni.feedback, shd->prg, "Feedback"); - if ((shd->loc.size.screen_emu = glGetUniformLocation(shd->prg, "size_screen_emu")) >= 0) { - glUniform2f(shd->loc.size.screen_emu, sse[0], sse[1]); - } - if ((shd->loc.size.video_mode = glGetUniformLocation(shd->prg, "size_video_mode")) >= 0) { - glUniform2f(shd->loc.size.video_mode, svm[0], svm[1]); - } - if ((shd->loc.size.texture = glGetUniformLocation(shd->prg, "size_texture")) >= 0) { - glUniform2f(shd->loc.size.texture, st[0], st[1]); - } - if ((shd->loc.frame_counter = glGetUniformLocation(shd->prg, "frame_counter")) >= 0) { - glUniform1f(shd->loc.frame_counter, fc); - } - if ((shd->loc.param = glGetUniformLocation(shd->prg, "param")) >= 0) { - glUniform1f(shd->loc.param, param); - } - if ((shd->loc.pixel_aspect_ratio = glGetUniformLocation(shd->prg, "pixel_aspect_ratio")) - >= 0) { - glUniform1f(shd->loc.pixel_aspect_ratio, par); - } - if ((shd->loc.full_interpolation = glGetUniformLocation(shd->prg, "full_interpolation")) >= 0) { - glUniform1f(shd->loc.full_interpolation, full_interpolation); + for (i = 0; i < shader_effect.pass; i++) { + shd_uni_texture(&shd->uni.passprev[i], shd->prg, "Pass%u", i + 1); + shd_uni_texture(&shd->uni.passprev[i], shd->prg, "PassPrev%u", i + 1); + + if (shader_effect.sp[i].alias[0]) { + shd_uni_texture(&shd->uni.passprev[i], shd->prg, shader_effect.sp[i].alias); } } - glEnable(GL_TEXTURE_2D); + shd_uni_texture(&shd->uni.prev[0], shd->prg, "Prev"); - if ((shd->loc.texture.scr = glGetUniformLocation(shd->prg, "texture_scr")) >= 0) { - glActiveTexture(GL_TEXTURE0); - glBindTexture(GL_TEXTURE_2D, opengl.screen.id); - glUniform1i(shd->loc.texture.scr, 0); + for (i = 1; i < LENGTH(shd->uni.prev); i++) { + shd_uni_texture(&shd->uni.prev[i], shd->prg, "Prev%u", i); } - glDisable(GL_TEXTURE_2D); - - glUseProgram(0); -} -void glsl_delete_shaders(_shader *shd) { - /* routine */ - shd->id = SHADER_NONE; - shd->code = NULL; - - /* vertex */ - if (shd->vrt) { - glDeleteShader(shd->vrt); + for (i = 0; i < shader_effect.luts; i++) { + shd->uni.lut[i] = shd_get_uni(shd->prg, shader_effect.lp[i].name); } - shd->vrt = 0; - /* fragment */ - if (shd->frg) { - glDeleteShader(shd->frg); - } - shd->frg = 0; + shd->uni.lut_tex_coord = shd_get_atr(shd->prg, "LUTTexCoord"); - /* program */ + glUseProgram(0); +} +static void shd_delete(_shader *shd) { + // program if (shd->prg) { glDeleteProgram(shd->prg); + shd->prg = 0; } - shd->prg = 0; } -void glsl_print_log(GLuint obj, BYTE ret) { - int info_log_length = 0, max_length = 0; +static void shd_print_log(GLuint obj, BYTE ret) { + GLint info_log_length = 0, max_length = 0; if (glIsShader(obj)) { glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &max_length); @@ -567,7 +545,7 @@ void glsl_print_log(GLuint obj, BYTE ret) { } } } -char *glsl_file2string(const char *path) { +char *shd_file2string(const char *path) { FILE *fd; long len, r; char *str; @@ -597,7 +575,657 @@ char *glsl_file2string(const char *path) { return str; } +static void shd_uni_texture(_shader_uniforms_tex *sut, GLint prg, GLchar *fmt, ...) { + char type[50], buff[50]; + va_list ap; + + va_start(ap, fmt); + vsnprintf(type, sizeof(type), fmt, ap); + va_end(ap); + + snprintf(buff, sizeof(buff), "%s%s", type, "Texture"); + sut->texture = shd_get_uni(prg, buff); + snprintf(buff, sizeof(buff), "%s%s", type, "TextureSize"); + sut->texture_size = shd_get_uni(prg, buff); + snprintf(buff, sizeof(buff), "%s%s", type, "InputSize"); + sut->input_size = shd_get_uni(prg, buff); + snprintf(buff, sizeof(buff), "%s%s", type, "TexCoord"); + sut->tex_coord = shd_get_atr(prg, buff); +} +static GLint shd_get_uni(GLuint prog, const char *param) { + GLuint i; + GLint loc; + char buff[50]; + + for (i = 0; i < LENGTH(uni_prefixes); i++) { + snprintf(buff, sizeof(buff), "%s%s", uni_prefixes[i], param); + loc = glGetUniformLocation(prog, buff); + if (loc >= 0) { + return (loc); + } + } + + return (-1); +} +static GLint shd_get_atr(GLuint prog, const char *param) { + GLuint i; + GLint loc; + char buff[50]; + + for (i = 0; i < LENGTH(uni_prefixes); i++) { + snprintf(buff, sizeof(buff), "%s%s", uni_prefixes[i], param); + loc = glGetAttribLocation(prog, buff); + if (loc >= 0) { + return (loc); + } + } + + return (-1); +} +static void shd_set_vertex_buffer(_vertex_buffer *vb, _texture_rect *rect) { + GLfloat x = (GLfloat) rect->base.w / (GLfloat) rect->w; + GLfloat y = (GLfloat) rect->base.h / (GLfloat) rect->h; + + vb[1].s0 = x; vb[2].t0 = y; + vb[3].s0 = x; vb[3].t0 = y; + +} +INLINE static void shd_set_params_text(_shader *shd) { + GLuint buffer_index = 0; + + if (shd->uni.mvp >= 0) { + glUniformMatrix4fv(shd->uni.mvp, 1, GL_FALSE, opengl.mvp.data); + } + + glBindBuffer(GL_ARRAY_BUFFER, shd->vbo); + + if (shd->uni.tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.tex_coord); + glVertexAttribPointer(shd->uni.tex_coord, 2, GL_FLOAT, GL_FALSE, sizeof(_vertex_buffer), + BUFFER_OFFSET(buffer_index)); + } + buffer_index += 2; + + if (shd->uni.vertex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.vertex_coord); + glVertexAttribPointer(shd->uni.vertex_coord, 2, GL_FLOAT, GL_FALSE, sizeof(_vertex_buffer), + BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + + } + buffer_index += 2; + + { + if (shd->uni.COLOR >= 0) { + glEnableVertexAttribArray(shd->uni.COLOR); + glVertexAttribPointer(shd->uni.COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(_vertex_buffer), + BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + if (shd->uni.color >= 0) { + glEnableVertexAttribArray(shd->uni.color); + glVertexAttribPointer(shd->uni.color, 4, GL_FLOAT, GL_FALSE, sizeof(_vertex_buffer), + BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + } + buffer_index += 4; + + glBindBuffer(GL_ARRAY_BUFFER, 0); +} +INLINE static void shd_set_params(const _shader *shd, GLuint fcountmod, GLuint fcount) { + GLuint i, buffer_index = 0, texture_index = 1; + + if (shd->uni.mvp >= 0) { + glUniformMatrix4fv(shd->uni.mvp, 1, GL_FALSE, opengl.mvp.data); + } + if (shd->uni.input_size >= 0) { + glUniform2fv(shd->uni.input_size, 1, shd->info.input_size); + } + if (shd->uni.output_size >= 0) { + glUniform2fv(shd->uni.output_size, 1, shd->info.output_size); + } + if (shd->uni.texture_size >= 0) { + glUniform2fv(shd->uni.texture_size, 1, shd->info.texture_size); + } + if (shd->uni.frame_count >= 0) { + if (fcountmod) { + fcount %= fcountmod; + } + glUniform1i(shd->uni.frame_count, fcount); + } + if (shd->uni.frame_direction >= 0) { + //glUniform1i(shd->uni.frame_direction, state_manager_frame_is_reversed() ? -1 : 1); + glUniform1i(shd->uni.frame_direction, 1); + } + + // lut + for (i = 0; i < shader_effect.luts; i++) { + if (shd->uni.lut[i] >= 0) { + glActiveTexture(GL_TEXTURE0 + texture_index); + glBindTexture(GL_TEXTURE_2D, opengl.lut[i].id); + glUniform1i(shd->uni.lut[i], texture_index); + texture_index++; + } + } + + glBindBuffer(GL_ARRAY_BUFFER, shd->vbo); + + if (shd->uni.tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.tex_coord); + glVertexAttribPointer(shd->uni.tex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(buffer_index)); + } + buffer_index += 2; + + if (shd->uni.vertex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.vertex_coord); + glVertexAttribPointer(shd->uni.vertex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + buffer_index += 2; + + { + if (shd->uni.COLOR >= 0) { + glEnableVertexAttribArray(shd->uni.COLOR); + glVertexAttribPointer(shd->uni.COLOR, 4, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + if (shd->uni.color >= 0) { + glEnableVertexAttribArray(shd->uni.color); + glVertexAttribPointer(shd->uni.color, 4, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + } + buffer_index += 4; + + // ORIG + if (shd->uni.orig.texture >= 0) { + glActiveTexture(GL_TEXTURE0 + texture_index); + glBindTexture(GL_TEXTURE_2D, opengl.screen.tex[opengl.screen.index].id); + glUniform1i(shd->uni.orig.texture, texture_index); + texture_index++; + } + if (shd->uni.orig.input_size >= 0) { + glUniform2fv(shd->uni.orig.input_size, 1, + opengl.screen.tex[opengl.screen.index].shader.info.input_size); + } + if (shd->uni.orig.texture_size >= 0) { + glUniform2fv(shd->uni.orig.texture_size, 1, + opengl.screen.tex[opengl.screen.index].shader.info.texture_size); + } + if (shd->uni.orig.tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.orig.tex_coord); + glVertexAttribPointer(shd->uni.orig.tex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + // PREV (uso le stesse tex_coord di ORIG) + { + GLint circle_index = opengl.screen.index - 1; + + for (i = 0; i < (opengl.screen.in_use - 1); i++) { + if (circle_index < 0) { + circle_index = opengl.screen.in_use - 1; + } + + if (shd->uni.prev[i].texture >= 0) { + glActiveTexture(GL_TEXTURE0 + texture_index); + glBindTexture(GL_TEXTURE_2D, opengl.screen.tex[circle_index].id); + glUniform1i(shd->uni.prev[i].texture, texture_index); + texture_index++; + } + + if (shd->uni.prev[i].tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.prev[i].tex_coord); + glVertexAttribPointer(shd->uni.prev[i].tex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + + circle_index--; + } + } + buffer_index += 2; + + // FEEDBACK + if (opengl.feedback.in_use) { + if (shd->uni.feedback.texture >= 0) { + glActiveTexture(GL_TEXTURE0 + texture_index); + glBindTexture(GL_TEXTURE_2D, opengl.feedback.tex.id); + glUniform1i(shd->uni.feedback.texture, texture_index); + texture_index++; + } + if (shd->uni.feedback.input_size >= 0) { + glUniform2fv(shd->uni.feedback.input_size, 1, + opengl.texture[shader_effect.feedback_pass].shader.info.input_size); + } + if (shd->uni.feedback.texture_size >= 0) { + glUniform2fv(shd->uni.feedback.texture_size, 1, + opengl.texture[shader_effect.feedback_pass].shader.info.texture_size); + } + if (shd->uni.feedback.tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.feedback.tex_coord); + glVertexAttribPointer(shd->uni.feedback.tex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + } + buffer_index += 2; + + // PASSPREV + for (i = 0; i < shader_effect.running_pass; i++) { + GLuint index = (shader_effect.running_pass - 1) - i; + + if (shd->uni.passprev[i].texture >= 0) { + glActiveTexture(GL_TEXTURE0 + texture_index); + glBindTexture(GL_TEXTURE_2D, opengl.texture[index].id); + glUniform1i(shd->uni.passprev[i].texture, texture_index); + texture_index++; + } + if (shd->uni.passprev[i].input_size >= 0) { + glUniform2fv(shd->uni.passprev[i].input_size, 1, + opengl.texture[i].shader.info.input_size); + } + if (shd->uni.passprev[i].texture_size >= 0) { + glUniform2fv(shd->uni.passprev[i].texture_size, 1, + opengl.texture[i].shader.info.texture_size); + } + if (shd->uni.passprev[i].tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.passprev[i].tex_coord); + glVertexAttribPointer(shd->uni.passprev[i].tex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), + BUFFER_OFFSET(sizeof(GLfloat) * (buffer_index + (index * 2)))); + } + } + buffer_index += (MAX_PASS * 2); + + // LUT + if (shd->uni.lut_tex_coord >= 0) { + glEnableVertexAttribArray(shd->uni.lut_tex_coord); + glVertexAttribPointer(shd->uni.lut_tex_coord, 2, GL_FLOAT, GL_FALSE, + sizeof(_vertex_buffer), BUFFER_OFFSET(sizeof(GLfloat) * buffer_index)); + } + buffer_index += 2; + + glBindBuffer(GL_ARRAY_BUFFER, 0); + + glActiveTexture(GL_TEXTURE0); + + // params + for (i = 0; i < shader_effect.params; i++) { + if (shd->uni.param[i] >= 0) { + glUniform1fv(shd->uni.param[i], 1, &shader_effect.param[i].value); + } + } +} +static BYTE tex_create(_texture *texture, GLuint index, GLuint clean) { + _shader_pass *sp = &shader_effect.sp[index]; + _shader_scale *sc = &sp->sc; + const _shader_pass *next = &shader_effect.sp[index + 1]; + const _vertex_buffer *vb = vb_upright; + const _texture_rect *prev; + const GLuint flt = (opengl.interpolation || opengl.PSS) ? GL_LINEAR : GL_NEAREST; + const GLuint flt_mip =(opengl.interpolation || opengl.PSS) ? + GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST; + _texture_rect *rect = &texture->rect; + _texture_viewport *vp = &texture->vp; + GLuint min_flt, mag_flt, wrap; + + if (index == 0) { + prev = &opengl.screen.tex[0].rect; + } else { + prev = &opengl.texture[index - 1].rect; + } + if (index == shader_effect.last_pass) { + vb = vb_flipped; + sc->scale.x = 1.0f; + sc->scale.y = 1.0f; + sc->type.x = SHADER_SCALE_VIEWPORT; + sc->type.y = SHADER_SCALE_VIEWPORT; + } +#if defined FHOPENGLGEST + switch (sc->type.x) { + case SHADER_SCALE_DEFAULT: + case SHADER_SCALE_INPUT: + rect->base.w = (GLfloat) prev->base.w * sc->scale.x; + rect->max.w = (GLfloat) prev->max.w * sc->scale.x; + break; + case SHADER_SCALE_ABSOLUTE: + rect->base.w = rect->max.w = sc->abs.x; + break; + case SHADER_SCALE_VIEWPORT: + rect->base.w = rect->max.w = (GLfloat) surface_sdl->w * sc->scale.x; + break; + } + switch (sc->type.y) { + case SHADER_SCALE_DEFAULT: + case SHADER_SCALE_INPUT: + rect->base.h = (GLfloat) prev->base.h * sc->scale.y; + rect->max.h = (GLfloat) prev->max.h * sc->scale.y; + break; + case SHADER_SCALE_ABSOLUTE: + rect->base.h = rect->max.h = sc->abs.y; + break; + case SHADER_SCALE_VIEWPORT: + rect->base.h = rect->max.h = (GLfloat) surface_sdl->h * sc->scale.y; + break; + } + + rect->w = power_of_two(rect->base.w); + rect->h = power_of_two(rect->base.h); +#else + switch (sc->type.x) { + case SHADER_SCALE_DEFAULT: + case SHADER_SCALE_INPUT: + rect->w = (GLfloat) prev->w * sc->scale.x; + rect->base.w = (GLfloat) prev->base.w * sc->scale.x; + rect->max.w = (GLfloat) prev->max.w * sc->scale.x; + break; + case SHADER_SCALE_ABSOLUTE: + rect->w = rect->base.w = rect->max.w = sc->abs.x; + break; + case SHADER_SCALE_VIEWPORT: + rect->w = rect->base.w = rect->max.w = (GLfloat) surface_sdl->w * sc->scale.x; + break; + } + switch (sc->type.y) { + case SHADER_SCALE_DEFAULT: + case SHADER_SCALE_INPUT: + rect->h = (GLfloat) prev->h * sc->scale.y; + rect->base.h = (GLfloat) prev->base.h * sc->scale.y; + rect->max.h = (GLfloat) prev->max.h * sc->scale.y; + break; + case SHADER_SCALE_ABSOLUTE: + rect->h = rect->base.h = rect->max.h = sc->abs.y; + break; + case SHADER_SCALE_VIEWPORT: + rect->h = rect->base.h = rect->max.h = (GLfloat) surface_sdl->h * sc->scale.y; + break; + } + + rect->w = power_of_two(rect->w); + rect->h = power_of_two(rect->h); +#endif + + vp->x = 0; + vp->y = 0; + vp->w = rect->base.w; + vp->h = rect->base.h; + + glGenTextures(1, &texture->id); + glBindTexture(GL_TEXTURE_2D, texture->id); + + min_flt = next->mipmap_input ? flt_mip : flt; + + if (next->linear) { + min_flt = next->mipmap_input ? + (next->linear ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) : + (next->linear ? GL_LINEAR : GL_NEAREST); + } + + switch (min_flt) { + case GL_LINEAR_MIPMAP_LINEAR: + mag_flt = GL_LINEAR; + break; + case GL_NEAREST_MIPMAP_NEAREST: + mag_flt = GL_NEAREST; + break; + default: + mag_flt = min_flt; + break; + } + switch (next->wrap) { + case TEXTURE_WRAP_BORDER: + default: + wrap = GL_CLAMP_TO_BORDER; + break; + case TEXTURE_WRAP_EDGE: + wrap = GL_CLAMP_TO_EDGE; + break; + case TEXTURE_WRAP_REPEAT: + wrap = GL_REPEAT; + break; + case TEXTURE_WRAP_MIRRORED_REPEAT: + wrap = GL_MIRRORED_REPEAT; + break; + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_flt); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_flt); + + // creo la texture nella GPU + if (sp->fbo_flt && opengl.supported_fbo.flt) { + glTexImage2D(GL_TEXTURE_2D, 0, TI_F_INTFRM, rect->w, rect->h, 0, TI_FRM, TI_F_TYPE, NULL); + } else if (sp->fbo_srgb && opengl.supported_fbo.srgb) { + glTexImage2D(GL_TEXTURE_2D, 0, TI_S_INTFRM, rect->w, rect->h, 0, TI_FRM, TI_S_TYPE, NULL); + } else { + glTexImage2D(GL_TEXTURE_2D, 0, TI_INTFRM, rect->w, rect->h, 0, TI_FRM, TI_TYPE, NULL); + } + + // gestione fbo + glGenFramebuffers(1, &texture->fbo); + glBindFramebuffer(GL_FRAMEBUFFER, texture->fbo); + + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->id, 0); + + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { + fprintf(stderr, "INFO: Error on create FBO.\n"); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glBindTexture(GL_TEXTURE_2D, 0); + return (EXIT_ERROR); + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glBindTexture(GL_TEXTURE_2D, 0); + + glGenBuffers(1, &texture->shader.vbo); + memcpy(texture->shader.vb, vb, sizeof(vb_flipped)); + + if (sp->alias[0]) { + char define[128]; + + snprintf(define, sizeof(define), "#define %s_ALIAS\n", sp->alias); + strncpy(opengl.alias_define, define, sizeof(opengl.alias_define)); + } + + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); + glClear(GL_COLOR_BUFFER_BIT); + + return (EXIT_OK); +} +static void tex_create_simple(_texture_simple *texture, GLuint w, GLuint h, BYTE fixed) { + _texture_rect *rect = &texture->rect; + _shader *shd = &texture->shader; + + glGenTextures(1, &texture->id); + glBindTexture(GL_TEXTURE_2D, texture->id); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + + rect->base.w = w; + rect->base.h = h; + + if (fixed) { +#if defined FHOPENGLGEST + rect->w = power_of_two(rect->base.w); + rect->h = power_of_two(rect->base.h); +#else + // rect->w = 1024 e rect->h = 1024 sono + // le dimensioni che imposta retroarch + // ma su alcune shader l'effetto e' piu' + // sgranato ("mudlord/emboss.h" e + // "antialiasing/fx-aa.h" sono un esempio) + rect->w = 1024; + rect->h = 1024; +#endif + } else { + rect->w = rect->base.w; + rect->h = rect->base.h; + } + + shd->info.input_size[0] = (GLfloat) rect->base.w; + shd->info.input_size[1] = (GLfloat) rect->base.h; + shd->info.texture_size[0] = (GLfloat) rect->w; + shd->info.texture_size[1] = (GLfloat) rect->h; + + shd_set_vertex_buffer(&shd->vb[0], rect); + + // pulisco la texture + { + GLuint size = rect->w * rect->h * 4; + GLubyte *empty = malloc(size); + + memset(empty, 0x00, size); + glTexImage2D(GL_TEXTURE_2D, 0, TI_INTFRM, rect->w, rect->h, 0, TI_FRM, TI_TYPE, empty); + free(empty); + } + + glBindTexture(GL_TEXTURE_2D, 0); +} +static void tex_create_lut(_lut *lut, GLuint index) { + _lut_pass *lp = &shader_effect.lp[index]; + GLuint min_flt, mag_flt, wrap; + + glGenTextures(1, &lut->id); + glBindTexture(GL_TEXTURE_2D, lut->id); + + min_flt = lp->mipmap ? + (lp->linear ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) : + (lp->linear ? GL_LINEAR : GL_NEAREST); + + switch (min_flt) { + case GL_LINEAR_MIPMAP_LINEAR: + mag_flt = GL_LINEAR; + break; + case GL_NEAREST_MIPMAP_NEAREST: + mag_flt = GL_NEAREST; + break; + default: + mag_flt = min_flt; + break; + } + + switch (lp->wrap) { + case TEXTURE_WRAP_BORDER: + default: + wrap = GL_CLAMP_TO_BORDER; + break; + case TEXTURE_WRAP_EDGE: + wrap = GL_CLAMP_TO_EDGE; + break; + case TEXTURE_WRAP_REPEAT: + wrap = GL_REPEAT; + break; + case TEXTURE_WRAP_MIRRORED_REPEAT: + wrap = GL_MIRRORED_REPEAT; + break; + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_flt); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_flt); + + gui_load_lut(lut, lp->path); + + glTexImage2D(GL_TEXTURE_2D, 0, TI_INTFRM, lut->w, lut->h, 0, TI_FRM, TI_TYPE, lut->bits); + + if (lp->mipmap) { + glGenerateMipmap(GL_TEXTURE_2D); + } + + glBindTexture(GL_TEXTURE_2D, 0); +} +static void tex_delete_screen(void) { + GLint i; + + if (opengl.sdl.surface) { + SDL_FreeSurface(opengl.sdl.surface); + opengl.sdl.surface = NULL; + } + + memset(&opengl.alias_define, 0x00, sizeof(opengl.alias_define)); + + opengl.screen.in_use = 0; + opengl.screen.index = 0; + + for (i = 0; i < LENGTH(opengl.screen.tex); i++) { + if (opengl.screen.tex[i].id) { + glDeleteTextures(1, &opengl.screen.tex[i].id); + opengl.screen.tex[i].id = 0; + } + } + + { + opengl.feedback.in_use = FALSE; + + if (opengl.feedback.tex.id) { + glDeleteTextures(1, &opengl.feedback.tex.id); + opengl.feedback.tex.id = 0; + } + if (opengl.feedback.tex.fbo) { + glDeleteFramebuffers(1, &opengl.feedback.tex.fbo); + opengl.feedback.tex.fbo = 0; + } + if (opengl.feedback.tex.shader.vbo) { + glDeleteBuffers(1, &opengl.feedback.tex.shader.vbo); + opengl.feedback.tex.shader.vbo = 0; + } + } + + for (i = 0; i < LENGTH(opengl.texture); i++) { + if (opengl.texture[i].id) { + glDeleteTextures(1, &opengl.texture[i].id); + opengl.texture[i].id = 0; + } + if (opengl.texture[i].fbo) { + glDeleteFramebuffers(1, &opengl.texture[i].fbo); + opengl.texture[i].fbo = 0; + } + if (opengl.texture[i].shader.vbo) { + glDeleteBuffers(1, &opengl.texture[i].shader.vbo); + opengl.texture[i].shader.vbo = 0; + } + shd_delete(&opengl.texture[i].shader); + } + + for (i = 0; i < LENGTH(opengl.lut); i++) { + if (opengl.lut[i].id) { + glDeleteTextures(1, &opengl.lut[i].id); + opengl.lut[i].id = 0; + } + } +} +static void tex_delete_text(void) { + if (opengl.text.id) { + glDeleteTextures(1, &opengl.text.id); + opengl.text.id = 0; + } + + if (opengl.text.shader.vbo) { + glDeleteBuffers(1, &opengl.text.shader.vbo); + opengl.text.shader.vbo = 0; + } + + shd_delete(&opengl.text.shader); +} + +static GLint power_of_two(GLint base) { + GLint pot = 1; + + while (pot < base) { + pot <<= 1; + } + return (pot); +} +const GLint get_integer(const GLenum penum) { + GLint result; + + glGetIntegerv(penum, &result); + + return (result); +} diff --git a/src/video/sdl/opengl.h b/src/video/sdl/opengl.h index ce73d3aeb..c0c304bfa 100644 --- a/src/video/sdl/opengl.h +++ b/src/video/sdl/opengl.h @@ -23,85 +23,154 @@ #include #include "common.h" #include "gfx.h" +#include "matrix.h" #include "shaders.h" -#define slow_factor 3 - -enum power_of_two_switch { NO_POWER_OF_TWO, POWER_OF_TWO }; - -typedef struct { - GLfloat l, r; - GLfloat t, b; -} _texcoords; - -#if defined (__cplusplus) -#define EXTERNC extern "C" -#else -#define EXTERNC -#endif - -EXTERNC struct _opengl { - BYTE rotation; - +typedef struct _vertex_buffer { + // tex coords + GLfloat s0, t0; + // vertexes + GLfloat x, y; + // white_color + GLfloat c0, c1, c2, c3; + // orig tex coords + GLfloat origtx[2]; + // feedback tex coords + GLfloat feedtx[2]; + // passprev tex coords + GLfloat pptx[MAX_PASS * 2]; + // lut tex coords + GLfloat luttx[2]; +} _vertex_buffer; +typedef struct _lut { + GLuint id; + int w, h; + const unsigned char *bits; +} _lut; +typedef struct _shader_uniforms_tex { + int texture; + int input_size; + int texture_size; + int tex_coord; +} _shader_uniforms_tex; +typedef struct _shader_uniforms { + int mvp; + int tex_coord; + int vertex_coord; + int COLOR; + int color; + + int input_size; + int output_size; + int texture_size; + + int frame_count; + unsigned frame_count_mod; + int frame_direction; + + int lut[MAX_PASS]; + int lut_tex_coord; + + int param[MAX_PARAM]; + + _shader_uniforms_tex orig; + _shader_uniforms_tex passprev[MAX_PASS]; + _shader_uniforms_tex prev[MAX_PREV]; + _shader_uniforms_tex feedback; +} _shader_uniforms; +typedef struct _shader_info { + GLfloat input_size[2]; + GLfloat output_size[2]; + GLfloat texture_size[2]; +} _shader_info; +typedef struct _shader { + GLuint prg; + GLuint vbo; + + _vertex_buffer vb[4]; + _shader_uniforms uni; + _shader_info info; +} _shader; +typedef struct _texture_rect { + GLint w; + GLint h; + _wh_uint base; + _wh_uint max; +} _texture_rect; +typedef struct _texture_viewport { + GLint x, y; + GLint w, h; +} _texture_viewport; +typedef struct _texture { + GLuint id; + GLuint fbo; + _texture_rect rect; + _texture_viewport vp; + _shader shader; +} _texture; +typedef struct _texture_simple { + GLuint id; + _texture_rect rect; + _shader shader; +} _texture_simple; +typedef struct _opengl { BYTE supported; - BYTE glew; - struct { - BYTE compliant; - BYTE enabled; - BYTE shader_used; - BYTE param; - } glsl; + struct _opengl_supported_fbo { + BYTE flt; + BYTE srgb; + } supported_fbo; + + struct _opengl_sdl { + SDL_Surface *surface; + Uint32 flags; + } sdl; - GLint scale_force; GLfloat scale; - GLfloat factor; BYTE interpolation; BYTE PSS; - SDL_Surface *surface_gl; + _math_matrix_4x4 mvp; - _texture screen; - _texture text; + char alias_define[1024]; - _texcoords texcoords; - _texcoords quadcoords; + struct _screen { + GLint in_use; + GLuint index; + _texture_simple tex[MAX_PREV + 1]; + } screen; - Uint32 flags; - BYTE factor_distance; + struct _feedback { + GLint in_use; + _texture tex; + } feedback; - float x_rotate; - float y_rotate; - float x_diff; - float y_diff; -} opengl; + _texture_simple text; + _texture texture[MAX_PASS + 1]; + _lut lut[MAX_PASS]; + _texture_viewport *vp; +} _opengl; -EXTERNC void sdl_init_gl(void); -EXTERNC void sdl_quit_gl(void); -EXTERNC void sdl_create_surface_gl(SDL_Surface *src, WORD width, WORD height, BYTE flags); +#if defined (__cplusplus) +#define EXTERNC extern "C" +#else +#define EXTERNC +#endif -EXTERNC void opengl_create_texture(_texture *texture, uint32_t width, uint32_t height, uint8_t pow); -EXTERNC void opengl_update_scr_texture(SDL_Surface *surface, uint8_t generate_mipmap); -EXTERNC BYTE opengl_update_txt_texture(uint8_t generate_mipmap); +EXTERNC _opengl opengl; -EXTERNC void opengl_effect_change(BYTE mode); +EXTERNC void sdl_init_gl(void); +EXTERNC void sdl_quit_gl(void); +EXTERNC BYTE sdl_setup_renderingl_gl(SDL_Surface *src); +EXTERNC void opengl_set_shader(GLuint shader); +EXTERNC void opengl_draw_scene(SDL_Surface *surface); EXTERNC void opengl_text_clear(_txt_element *ele); EXTERNC void opengl_text_blit(_txt_element *ele, _rect *rect); - EXTERNC int opengl_flip(SDL_Surface *surface); -EXTERNC int opengl_power_of_two(int base); - -EXTERNC void glew_init(void); - -EXTERNC void glsl_shaders_init(_shader *shd); -EXTERNC void glsl_delete_shaders(_shader *shd); -/* funzioni virtuali */ -EXTERNC void (*opengl_init_effect)(void); -EXTERNC void (*opengl_set_effect)(SDL_Surface *src); -EXTERNC void (*opengl_unset_effect)(void); -EXTERNC void (*opengl_draw_scene)(SDL_Surface *surface); +EXTERNC void shaders_set(int shader); +EXTERNC const char *shader_code_blend(void); #undef EXTERNC diff --git a/src/video/sdl/shaders.c b/src/video/sdl/shaders.c new file mode 100644 index 000000000..0935d3e05 --- /dev/null +++ b/src/video/sdl/shaders.c @@ -0,0 +1,577 @@ +/* + * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "opengl.h" +#include "shdcode.h" +#include "conf.h" +#include "cgp.h" + +#define SPALIAS(a) strncpy(sp->alias, a, sizeof(sp->alias)) +#define LPPATH(a) strncpy(lp->path, LUTCODE(a), sizeof(lp->path)) +#define LPNAME(a) strncpy(lp->name, a, sizeof(lp->name)) +#define PRMNAME(a) strncpy(prm->name, a, sizeof(prm->name)) + +#define _shdpass(a) sp = &se->sp[a]; type = &sp->sc.type; scale = &sp->sc.scale; abs = &sp->sc.abs +#define shdpass() _shdpass(se->pass++) +#define lutpass() lp = &se->lp[se->luts++] +#define prmshd(a, b) prm = &se->param[se->params++]; PRMNAME(a); prm->value = b + + +static void sp_set_default(_shader_pass *sp); +static void lp_set_default(_lut_pass *lp); +static void se_set_default(void); +static void se_soft_stretch(void); + +void shaders_set(int shader) { + _shader_effect *se = &shader_effect; + _shader_pass *sp = NULL; + _xy_uint *type = NULL; + _xy_float *scale = NULL; + _xy_uint *abs = NULL; + _lut_pass *lp = NULL; + _param_shd *prm = NULL; + int i; + + se_set_default(); + + //cgp_parse(); + + switch (shader) { + case NO_FILTER: + shdpass(); + sp->code = SHDCODE(shc_no_filter); + se_soft_stretch(); + break; + case sh_anti_aliasing_advanced_aa: + shdpass(); + sp->code = SHDCODE(shc_anti_aliasing_advanced_aa); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 2.0f; + scale->y = 2.0f; + shdpass(); + sp->code = SHDCODE(shc_no_filter); + sp->linear = TRUE; + break; + case sh_anti_aliasing_fx_aa: + shdpass(); + sp->code = SHDCODE(shc_anti_aliasing_fx_aa); + break; + case sh_anti_aliasing_fxaa_edge_detect: + shdpass(); + sp->code = SHDCODE(shc_anti_aliasing_fxaa_edge_detect); + break; + case sh_cgp_tvout_tvout_ntsc_2phase_composite: + shdpass(); + sp->code = SHDCODE(shc_ntsc_ntsc_pass1_composite_2phase); + sp->frame_count_mod = 2; + sp->fbo_flt = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 4.0f; + shdpass(); + sp->code = SHDCODE(shc_ntsc_ntsc_pass2_2phase); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 0.5f; + shdpass(); + sp->code = SHDCODE(shc_crt_tvout_tweaks); + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_misc_image_adjustment); + sp->linear = TRUE; + break; + case sh_cgp_tvout_tvout_ntsc_256px_svideo: + shdpass(); + sp->code = SHDCODE(shc_ntsc_ntsc_pass1_svideo_3phase); + sp->frame_count_mod = 2; + sp->fbo_flt = TRUE; + type->x = SHADER_SCALE_ABSOLUTE; + type->y = SHADER_SCALE_INPUT; + abs->x = 1024.0f; + shdpass(); + sp->code = SHDCODE(shc_ntsc_ntsc_pass2_3phase); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 0.5f; + shdpass(); + sp->code = SHDCODE(shc_crt_tvout_tweaks); + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_misc_image_adjustment); + break; + case sh_cgp_2xbr_crt_hyllian: + shdpass(); + sp->code = SHDCODE(shc_xbr_legacy_2xbr_v38c); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 2.0f; + shdpass(); + sp->code = SHDCODE(shc_crt_crt_hyllian); + break; + case sh_cgp_2xbr_jinc2_sharper_hybrid: + shdpass(); + sp->code = SHDCODE(shc_xbr_legacy_2xbr_v38c); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 2.0f; + shdpass(); + sp->code = SHDCODE(shc_windowed_jinc2_sharper); + break; + case sh_crt_gtuv50: + shdpass(); + sp->code = SHDCODE(shc_crt_gtu_v050_pass1); + sp->fbo_flt = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_gtu_v050_pass2); + sp->fbo_flt = TRUE; + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_gtu_v050_pass3); + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_VIEWPORT; + break; + case sh_crt_4xbr_hybrid_crt: + shdpass(); + sp->code = SHDCODE(shc_crt_4xbr_hybrid_crt); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 4.0f; + scale->y = 4.0f; + shdpass(); + sp->code = SHDCODE(shc_no_filter); + sp->linear = TRUE; + break; + case sh_crt_crt_caligari: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_caligari); + break; + case sh_crt_crt_cgwg_fast: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_cgwg_fast); + break; + case sh_crt_crt_easymode: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_easymode); + break; + case sh_crt_crt_easymode_halation: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_easymode_halation_linearize); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_crt_easymode_halation_blur_horiz); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_crt_easymode_halation_blur_vert); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_crt_easymode_halation_threshold); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_crt_easymode_halation_crt_easymode_halation); + sp->linear = TRUE; + break; + case sh_crt_crt_geom: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_geom); + break; + case sh_crt_crtglow_gauss: + shdpass(); + sp->code = SHDCODE(shc_crt_glow_linearize); + sp->fbo_srgb = TRUE; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_gauss_horiz); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_gauss_vert); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_VIEWPORT; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_threshold); + sp->fbo_srgb = TRUE; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_blur_horiz); + sp->mipmap_input = TRUE; + sp->linear = TRUE; + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 0.25f; + scale->y = 0.25f; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_blur_vert); + sp->linear = TRUE; + sp->fbo_srgb = TRUE; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_resolve); + sp->linear = TRUE; + break; + case sh_crt_crtglow_gauss_ntsc_3phase: + shdpass(); + sp->code = SHDCODE(shc_ntsc_ntsc_pass1_composite_3phase); + sp->frame_count_mod = 2; + sp->fbo_flt = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 4.0f; + scale->y = 1.0f; + shdpass(); + sp->code = SHDCODE(shc_ntsc_ntsc_pass2_3phase_linear); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 0.5f; + scale->y = 1.0f; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_gauss_horiz); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_gauss_vert); + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_VIEWPORT; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_threshold); + sp->fbo_srgb = TRUE; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_blur_horiz); + sp->mipmap_input = TRUE; + sp->linear = TRUE; + sp->fbo_srgb = TRUE; + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 0.25f; + scale->y = 0.25f; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_blur_vert); + sp->linear = TRUE; + sp->fbo_srgb = TRUE; + shdpass(); + sp->code = SHDCODE(shc_crt_glow_resolve); + sp->linear = TRUE; + break; + case sh_crt_crt_hyllian: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_hyllian); + break; + case sh_crt_crt_lottes: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_lottes); + break; + case sh_crt_crt_reverse_aa: + shdpass(); + sp->code = SHDCODE(shc_crt_crt_reverse_aa); + se_soft_stretch(); + break; + case sh_crt_dotmask: + shdpass(); + sp->code = SHDCODE(shc_crt_dotmask); + se_soft_stretch(); + break; + case sh_eagle_super_eagle: + shdpass(); + sp->code = SHDCODE(shc_eagle_super_eagle); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 2.0f; + scale->y = 2.0f; + shdpass(); + sp->code = SHDCODE(shc_no_filter); + sp->linear = TRUE; + break; + case sh_hunterk_borders_1080p_bigblur: + shdpass(); + sp->code = SHDCODE(shc_no_filter); + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_bigblur_horiz); + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_bigblur_vert); + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_bigblur_1080p); + + lutpass(); + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_borders_1080p_color_grid: + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_color_grid_1080p); + + lutpass(); + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_borders_1080p_mudlord: + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_mudlord_1080p); + + lutpass(); + lp->linear = FALSE; + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_borders_1080p_shiny_iterations: + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_shiny_iterations_1080p); + + lutpass(); + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_borders_1080p_snow: + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_snow_1080p); + + lutpass(); + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_borders_1080p_voronoi: + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_voronoi_1080p); + + lutpass(); + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_borders_1080p_water: + shdpass(); + sp->code = SHDCODE(shc_hunterk_resources_water_1080p); + + lutpass(); + LPPATH(lut_hunterk_borders_1080p_border_1080p); + LPNAME("bg"); + break; + case sh_hunterk_handheld_nds: + shdpass(); + sp->code = SHDCODE(shc_hunterk_misc_color_mangler); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_hunterk_handheld_lcd_cgwg_lcd_grid); + type->x = SHADER_SCALE_VIEWPORT; + type->y = SHADER_SCALE_VIEWPORT; + shdpass(); + sp->code = SHDCODE(shc_hunterk_misc_image_adjustment); + + prmshd("display_gamma", 1.9f); + prmshd("target_gamma", 2.2f); + prmshd("sat", 1.04f); + prmshd("lum", 1.0f); + prmshd("cntrst", 1.0f); + prmshd("blr", 0.0f); + prmshd("blg", 0.0f); + prmshd("blb", 0.0f); + prmshd("r", 0.77f); + prmshd("g", 0.69f); + prmshd("b", 0.8f); + prmshd("rg", 0.06f); + prmshd("rb", 0.06f); + prmshd("gr", 0.22f); + prmshd("gb", 0.1f); + prmshd("br", 0.0f); + prmshd("bg", 0.24f); + prmshd("GRID_STRENGTH", 0.15f); + prmshd("target_gamma", 2.2f); + prmshd("monitor_gamma", 2.2f); + prmshd("overscan_percent_x", 0.0f); + prmshd("overscan_percent_y", 0.0f); + prmshd("saturation", 1.0f); + prmshd("contrast", 1.0f); + prmshd("luminance", 1.2f); + prmshd("bright_boost", 0.0f); + prmshd("R", 1.0f); + prmshd("G", 1.0f); + prmshd("B", 1.0f); + break; + case sh_hunterk_hqx_hq3x: + shdpass(); + sp->code = SHDCODE(shc_hunterk_hqx_pass1); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + shdpass(); + sp->code = SHDCODE(shc_hunterk_hqx_hq3x); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + scale->x = 3.0f; + scale->y = 3.0f; + + lutpass(); + lp->linear = FALSE; + LPPATH(lut_hunterk_hqx_resources_hq3x); + LPNAME("LUT"); + break; + case sh_hunterk_motionblur_motionblur_simple: + shdpass(); + sp->code = SHDCODE(shc_hunterk_motionblur_motionblur_simple); + break; + case sh_motionblur_feedback: + shdpass(); + se->feedback_pass = 0; + sp->code = SHDCODE(shc_motionblur_feedback); + type->x = SHADER_SCALE_INPUT; + type->y = SHADER_SCALE_INPUT; + break; + case sh_mudlord_emboss: + shdpass(); + sp->code = SHDCODE(shc_mudlord_emboss); + se_soft_stretch(); + break; + case sh_mudlord_mud_mudlord: + shdpass(); + sp->code = SHDCODE(shc_mudlord_mud_mudlord); + se_soft_stretch(); + break; + case sh_mudlord_noise_mudlord: + shdpass(); + sp->code = SHDCODE(shc_mudlord_noise_mudlord); + se_soft_stretch(); + break; + case sh_mudlord_oldtv: + shdpass(); + sp->code = SHDCODE(shc_mudlord_oldtv); + se_soft_stretch(); + break; + case sh_waterpaint_water: + shdpass(); + sp->code = SHDCODE(shc_waterpaint_water); + break; + + + case sh_test: + /**/ + shdpass(); + sp->code = SHDCODE(shc_hunterk_motionblur_braid_rewind); + /**/ + //se_soft_stretch(); + break; + } + + + + { + int index = se->pass - 1; + + _shdpass(index); + if ((type->x != SHADER_SCALE_DEFAULT) || (type->y != SHADER_SCALE_DEFAULT)) { + se->pass++; + _shdpass(index + 1); + sp_set_default(sp); + sp->code = SHDCODE(shc_no_filter); + type->x = type->y = SHADER_SCALE_VIEWPORT; + } + } + + se->last_pass = se->pass - 1; + + // pragma parameters + for (i = 0; i < se->pass; i++) { + _shdpass(i); + cgp_pragma_param(sp->code); + } +} +const char *shader_code_blend(void) { + return (SHDCODE(shc_blend)); +} + +static void sp_set_default(_shader_pass *sp) { + _xy_uint *type = &sp->sc.type; + _xy_float *scale = &sp->sc.scale; + _xy_uint *abs = &sp->sc.abs; + + sp->code = NULL; + memset(sp->path, 0x00, sizeof(sp->path)); + memset(sp->alias, 0x00, sizeof(sp->alias)); + sp->linear = FALSE; + sp->mipmap_input = FALSE; + sp->fbo_flt = sp->fbo_srgb = FALSE; + sp->wrap = TEXTURE_WRAP_BORDER; + sp->frame_count_mod = 0; + type->x = type->y = SHADER_SCALE_DEFAULT; + scale->x = scale->y = 1.0f; + abs->x = abs->y = 0; +} +static void lp_set_default(_lut_pass *lp) { + memset(lp->path, 0x00, sizeof(lp->path)); + memset(lp->name, 0x00, sizeof(lp->name)); + lp->linear = FALSE; + lp->mipmap = FALSE; + lp->wrap = TEXTURE_WRAP_BORDER; +} +static void ps_set_default(_param_shd *ps) { + memset(ps, 0x00, sizeof(_param_shd)); +} +static void se_set_default(void) { + _shader_effect *se = &shader_effect; + int i; + + se->pass = se->last_pass = se->running_pass = 0; + for (i = 0; i < LENGTH(se->sp); i++) { + sp_set_default(&se->sp[i]); + } + + se->luts = 0; + for (i = 0; i < LENGTH(se->lp); i++) { + lp_set_default(&se->lp[i]); + } + + se->params = 0; + for (i = 0; i < LENGTH(se->param); i++) { + ps_set_default(&se->param[i]); + } + + se->feedback_pass = -1; +} +static void se_soft_stretch(void) { + if (shader_effect.sp[shader_effect.pass - 1].linear || + !(opengl.interpolation || opengl.PSS)) { + return; + } + + shader_effect.pass++; + + if (!opengl.interpolation && opengl.PSS) { + shader_effect.sp[shader_effect.pass - 2].sc.scale.x = (float) cfg->scale; + shader_effect.sp[shader_effect.pass - 2].sc.scale.y = (float) cfg->scale; + shader_effect.sp[shader_effect.pass - 2].sc.type.x = SHADER_SCALE_INPUT; + shader_effect.sp[shader_effect.pass - 2].sc.type.y = SHADER_SCALE_INPUT; + } + + shader_effect.sp[shader_effect.pass - 1].code = SHDCODE(shc_no_filter); + shader_effect.sp[shader_effect.pass - 1].linear = TRUE; + shader_effect.sp[shader_effect.pass - 2].sc.type.x = SHADER_SCALE_DEFAULT; + shader_effect.sp[shader_effect.pass - 2].sc.type.y = SHADER_SCALE_DEFAULT; +} diff --git a/src/video/sdl/shaders.h b/src/video/sdl/shaders.h index 484023764..874137756 100644 --- a/src/video/sdl/shaders.h +++ b/src/video/sdl/shaders.h @@ -19,53 +19,82 @@ #ifndef SHADERS_H_ #define SHADERS_H_ -enum shader_type { - SHADER_COLOR, - SHADER_NO_FILTER, - SHADER_PHOSPHOR, - SHADER_SCANLINE, - SHADER_CRT, - SHADER_DONTBLOOM, - SHADER_TOTAL, - SHADER_NONE = 255 +#include "gfx.h" + +enum max_pass { MAX_PASS = 24, MAX_PREV = 7, MAX_PARAM = 128 }; +enum texture_wrap_type { + TEXTURE_WRAP_BORDER, + TEXTURE_WRAP_EDGE, + TEXTURE_WRAP_REPEAT, + TEXTURE_WRAP_MIRRORED_REPEAT +}; +enum shader_scale_type { + SHADER_SCALE_INPUT, + SHADER_SCALE_ABSOLUTE, + SHADER_SCALE_VIEWPORT, + SHADER_SCALE_DEFAULT }; -typedef struct { - GLuint id; - GLenum format; - GLenum type; - GLint format_internal; +typedef struct _xy_uint { + unsigned int x, y; +} _xy_uint; +typedef struct _xy_float { + float x, y; +} _xy_float; +typedef struct _wh_uint { + unsigned int w, h; +} _wh_uint; +typedef struct _shader_scale { + _xy_uint type; + _xy_float scale; + _xy_uint abs; +} _shader_scale; +typedef struct _shader_pass { + const char *code; + char path[LENGTH_FILE_NAME_LONG]; + char alias[64]; + + uint8_t mipmap_input; + uint8_t linear; + uint8_t fbo_flt; + uint8_t fbo_srgb; + uint8_t wrap; + int frame_count_mod; + + _shader_scale sc; +} _shader_pass; +typedef struct _lut_pass { + char name[64]; + char path[LENGTH_FILE_NAME_LONG]; + + uint8_t mipmap; + uint8_t linear; + uint8_t wrap; +} _lut_pass; +typedef struct _param_shd { + char name[64]; + char desc[64]; - GLfloat w; - GLfloat h; -} _texture; -typedef struct { - const GLchar *vertex; - const GLchar *fragment; -} _shader_code; -typedef struct { - GLuint prg; - GLuint vrt; - GLuint frg; + float value; //current + float initial; + float min; + float max; + float step; +} _param_shd; +typedef struct _shader_effect { + uint8_t pass; + uint8_t last_pass; + uint8_t running_pass; + _shader_pass sp[MAX_PASS + 1]; - GLuint id; - _shader_code *code; + uint8_t luts; + _lut_pass lp[MAX_PASS]; - struct { - struct { - GLint screen_emu; - GLint video_mode; - GLint texture; - } size; - struct { - GLint scr; - } texture; - GLint frame_counter; - GLint pixel_aspect_ratio; - GLint full_interpolation; - GLint param; - } loc; -} _shader; + uint8_t params; + _param_shd param[MAX_PARAM]; + + int8_t feedback_pass; +} _shader_effect; #if defined (__cplusplus) #define EXTERNC extern "C" @@ -73,20 +102,8 @@ typedef struct { #define EXTERNC #endif -EXTERNC _shader shader; +EXTERNC _shader_effect shader_effect; #undef EXTERNC #endif /* SHADERS_H_ */ - -#if defined (_SHADERS_CODE_) -static _shader_code shader_code[SHADER_TOTAL] = { -#include "shaders/color.h" -#include "shaders/no_filter.h" -#include "shaders/phosphor.h" -#include "shaders/scanline.h" -#include "shaders/crt.h" -#include "shaders/dbl.h" -}; -#undef _SHADERS_CODE_ -#endif diff --git a/src/video/sdl/shaders/anti-aliasing/advanced-aa.h b/src/video/sdl/shaders/anti-aliasing/advanced-aa.h new file mode 100644 index 000000000..93dd5ae88 --- /dev/null +++ b/src/video/sdl/shaders/anti-aliasing/advanced-aa.h @@ -0,0 +1,295 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t41;\n" +"COMPAT_VARYING vec4 _t31;\n" +"COMPAT_VARYING vec4 _t21;\n" +"COMPAT_VARYING vec4 _t11;\n" +"COMPAT_VARYING vec2 _CT;\n" +"COMPAT_VARYING vec4 _position2;\n" +"COMPAT_VARYING vec4 _color2;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord2;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord2;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color2;\n" +"};\n" +"struct VERTEX_INPUT {\n" +" vec4 _position2;\n" +" vec2 _CT;\n" +" vec4 _t11;\n" +" vec4 _t21;\n" +" vec4 _t31;\n" +" vec4 _t41;\n" +"};\n" +"VERTEX_OUTPUT _ret_0;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"input_dummy _IN1;\n" +"vec4 _r0009;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" VERTEX_OUTPUT _OUT;\n" +" vec2 _ps;\n" +" float _dx;\n" +" float _dy;\n" +" vec2 _texCoord;\n" +" _r0009 = VertexCoord.x*MVPMatrix[0];\n" +" _r0009 = _r0009 + VertexCoord.y*MVPMatrix[1];\n" +" _r0009 = _r0009 + VertexCoord.z*MVPMatrix[2];\n" +" _r0009 = _r0009 + VertexCoord.w*MVPMatrix[3];\n" +" if (TextureSize.x == 0.00000000E+00) { \n" +" _TMP1 = TextureSize.x;\n" +" } else {\n" +" _TMP1 = TextureSize.x;\n" +" } \n" +" if (TextureSize.y == 0.00000000E+00) { \n" +" _TMP2 = TextureSize.y;\n" +" } else {\n" +" _TMP2 = TextureSize.y;\n" +" } \n" +" _ps = vec2(1.00000000E+00/_TMP1, 1.00000000E+00/_TMP2);\n" +" _dx = _ps.x*5.00000000E-01;\n" +" _dy = _ps.y*5.00000000E-01;\n" +" _texCoord = TexCoord.xy + vec2( 1.00000001E-07, 1.00000001E-07);\n" +" _OUT._t1.xy = _texCoord + vec2(-_dx, 0.00000000E+00);\n" +" _OUT._t2.xy = _texCoord + vec2(_dx, 0.00000000E+00);\n" +" _OUT._t3.xy = _texCoord + vec2(0.00000000E+00, -_dy);\n" +" _OUT._t4.xy = _texCoord + vec2(0.00000000E+00, _dy);\n" +" _OUT._t1.zw = _texCoord + vec2(-_dx, -_dy);\n" +" _OUT._t2.zw = _texCoord + vec2(-_dx, _dy);\n" +" _OUT._t3.zw = _texCoord + vec2(_dx, -_dy);\n" +" _OUT._t4.zw = _texCoord + vec2(_dx, _dy);\n" +" _ret_0._position1 = _r0009;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord2 = _texCoord;\n" +" _ret_0._t1 = _OUT._t1;\n" +" _ret_0._t2 = _OUT._t2;\n" +" _ret_0._t3 = _OUT._t3;\n" +" _ret_0._t4 = _OUT._t4;\n" +" gl_Position = _r0009;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _texCoord;\n" +" TEX1 = _OUT._t1;\n" +" TEX2 = _OUT._t2;\n" +" TEX3 = _OUT._t3;\n" +" TEX4 = _OUT._t4;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord2;\n" +" TEX1 = _ret_0._t1;\n" +" TEX2 = _ret_0._t2;\n" +" TEX3 = _ret_0._t3;\n" +" TEX4 = _ret_0._t4;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t21;\n" +"COMPAT_VARYING vec4 _t11;\n" +"COMPAT_VARYING vec2 _CT;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _t41;\n" +"COMPAT_VARYING vec4 _t31;\n" +"COMPAT_VARYING vec4 _t22;\n" +"COMPAT_VARYING vec4 _t12;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _color;\n" +" vec2 _texCoord;\n" +" vec4 _t12;\n" +" vec4 _t22;\n" +" vec4 _t31;\n" +" vec4 _t41;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color1;\n" +"};\n" +"struct VERTEX_INPUT {\n" +" vec2 _CT;\n" +" vec4 _t11;\n" +" vec4 _t21;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +"};\n" +"float _TMP20;\n" +"vec3 _TMP19;\n" +"float _TMP18;\n" +"vec3 _TMP17;\n" +"float _TMP16;\n" +"vec3 _TMP15;\n" +"float _TMP14;\n" +"vec3 _TMP13;\n" +"float _TMP12;\n" +"vec3 _TMP11;\n" +"float _TMP10;\n" +"vec3 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"vec3 _a0045;\n" +"vec3 _a0049;\n" +"vec3 _a0053;\n" +"vec3 _a0057;\n" +"vec3 _a0061;\n" +"vec3 _a0065;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"uniform vec3 _dt;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" output_dummy _OUT;\n" +" float _d1;\n" +" float _d2;\n" +" float _hl;\n" +" float _vl;\n" +" float _k1;\n" +" float _k2;\n" +" vec3 _t1;\n" +" vec3 _t2;\n" +" vec3 _TMP25;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX1.zw);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, TEX3.xy);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, TEX3.zw);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, TEX1.xy);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP5 = COMPAT_TEXTURE(Texture, TEX2.xy);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, TEX2.zw);\n" +" _TMP7 = COMPAT_TEXTURE(Texture, TEX4.xy);\n" +" _TMP8 = COMPAT_TEXTURE(Texture, TEX4.zw);\n" +" _a0045 = _TMP0.xyz - _TMP8.xyz;\n" +" _TMP9 = abs(_a0045);\n" +" _TMP10 = dot(_TMP9, _dt);\n" +" _d1 = _TMP10 + 9.99999975E-05;\n" +" _a0049 = _TMP2.xyz - _TMP6.xyz;\n" +" _TMP11 = abs(_a0049);\n" +" _TMP12 = dot(_TMP11, _dt);\n" +" _d2 = _TMP12 + 9.99999975E-05;\n" +" _a0053 = _TMP3.xyz - _TMP5.xyz;\n" +" _TMP13 = abs(_a0053);\n" +" _TMP14 = dot(_TMP13, _dt);\n" +" _hl = _TMP14 + 9.99999975E-05;\n" +" _a0057 = _TMP1.xyz - _TMP7.xyz;\n" +" _TMP15 = abs(_a0057);\n" +" _TMP16 = dot(_TMP15, _dt);\n" +" _vl = _TMP16 + 9.99999975E-05;\n" +" _k1 = 5.00000000E-01*(_hl + _vl);\n" +" _k2 = 5.00000000E-01*(_d1 + _d2);\n" +" _t1 = (_hl*(_TMP1.xyz + _TMP7.xyz) + _vl*(_TMP3.xyz + _TMP5.xyz) + _k1*_TMP4.xyz)/(2.50000000E+00*(_hl + _vl));\n" +" _t2 = (_d1*(_TMP2.xyz + _TMP6.xyz) + _d2*(_TMP0.xyz + _TMP8.xyz) + _k2*_TMP4.xyz)/(2.50000000E+00*(_d1 + _d2));\n" +" _a0061 = _t1 - _TMP4.xyz;\n" +" _TMP17 = abs(_a0061);\n" +" _TMP18 = dot(_TMP17, _dt);\n" +" _k1 = _TMP18 + 9.99999975E-05;\n" +" _a0065 = _t2 - _TMP4.xyz;\n" +" _TMP19 = abs(_a0065);\n" +" _TMP20 = dot(_TMP19, _dt);\n" +" _k2 = _TMP20 + 9.99999975E-05;\n" +" _TMP25 = (_k1*_t2 + _k2*_t1)/(_k1 + _k2);\n" +" _OUT._color1 = vec4(_TMP25.x, _TMP25.y, _TMP25.z, 1.00000000E+00);\n" +" FragColor = _OUT._color1;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/anti-aliasing/fx-aa.h b/src/video/sdl/shaders/anti-aliasing/fx-aa.h new file mode 100644 index 000000000..e3fa63960 --- /dev/null +++ b/src/video/sdl/shaders/anti-aliasing/fx-aa.h @@ -0,0 +1,222 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _vpos1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _position1;\n" +" vec4 _vpos1;\n" +" vec2 _texCoord1;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"VERTEX_OUTPUT _ret_0;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _ret_0._position1 = _r0006;\n" +" _ret_0._vpos1 = _r0006;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" TEX1 = _r0006;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" TEX1 = _ret_0._vpos1;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _vpos;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _vpos;\n" +" vec2 _texCoord;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"vec4 _TMP19;\n" +"vec4 _TMP18;\n" +"vec4 _TMP17;\n" +"vec4 _TMP16;\n" +"vec2 _TMP15;\n" +"vec2 _TMP14;\n" +"float _TMP13;\n" +"float _TMP12;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"float _TMP9;\n" +"float _TMP8;\n" +"float _TMP7;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _c0026;\n" +"vec2 _c0028;\n" +"vec2 _c0030;\n" +"vec2 _c0032;\n" +"float _a0062;\n" +"vec2 _b0070;\n" +"vec2 _c0074;\n" +"vec2 _c0076;\n" +"vec2 _c0078;\n" +"vec2 _c0080;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" output_dummy _OUT;\n" +" vec2 _inverse_resolution;\n" +" float _lumaNW;\n" +" float _lumaNE;\n" +" float _lumaSW;\n" +" float _lumaSE;\n" +" float _lumaM;\n" +" float _lumaMin;\n" +" float _lumaMax;\n" +" vec2 _dir;\n" +" float _dirReduce;\n" +" float _rcpDirMin;\n" +" vec3 _rgbA;\n" +" vec3 _rgbB;\n" +" float _lumaB;\n" +" _inverse_resolution = 1.00000000E+00/InputSize.xy;\n" +" _c0026 = (TEX0.xy + vec2( -1.00000000E+00, -1.00000000E+00))*_inverse_resolution;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _c0026);\n" +" _c0028 = (TEX0.xy + vec2( 1.00000000E+00, -1.00000000E+00))*_inverse_resolution;\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0028);\n" +" _c0030 = (TEX0.xy + vec2( -1.00000000E+00, 1.00000000E+00))*_inverse_resolution;\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0030);\n" +" _c0032 = (TEX0.xy + vec2( 1.00000000E+00, 1.00000000E+00))*_inverse_resolution;\n" +" _TMP3 = COMPAT_TEXTURE(Texture, _c0032);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _lumaNW = dot(_TMP0.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaNE = dot(_TMP1.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaSW = dot(_TMP2.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaSE = dot(_TMP3.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaM = dot(_TMP4.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _TMP5 = min(_lumaNW, _lumaNE);\n" +" _TMP6 = min(_lumaSW, _lumaSE);\n" +" _TMP7 = min(_TMP5, _TMP6);\n" +" _lumaMin = min(_lumaM, _TMP7);\n" +" _TMP8 = max(_lumaNW, _lumaNE);\n" +" _TMP9 = max(_lumaSW, _lumaSE);\n" +" _TMP10 = max(_TMP8, _TMP9);\n" +" _lumaMax = max(_lumaM, _TMP10);\n" +" _dir.x = -((_lumaNW + _lumaNE) - (_lumaSW + _lumaSE));\n" +" _dir.y = (_lumaNW + _lumaSW) - (_lumaNE + _lumaSE);\n" +" _a0062 = (_lumaNW + _lumaNE + _lumaSW + _lumaSE)*3.12500000E-02;\n" +" _dirReduce = max(_a0062, 3.90625000E-03);\n" +" _TMP11 = abs(_dir.x);\n" +" _TMP12 = abs(_dir.y);\n" +" _TMP13 = min(_TMP11, _TMP12);\n" +" _rcpDirMin = 1.00000000E+00/(_TMP13 + _dirReduce);\n" +" _b0070 = _dir*_rcpDirMin;\n" +" _TMP14 = max(vec2( -8.00000000E+00, -8.00000000E+00), _b0070);\n" +" _TMP15 = min(vec2( 8.00000000E+00, 8.00000000E+00), _TMP14);\n" +" _dir = _TMP15*_inverse_resolution;\n" +" _c0074 = TEX0.xy + _dir*-1.66666657E-01;\n" +" _TMP16 = COMPAT_TEXTURE(Texture, _c0074);\n" +" _c0076 = TEX0.xy + _dir*1.66666687E-01;\n" +" _TMP17 = COMPAT_TEXTURE(Texture, _c0076);\n" +" _rgbA = 5.00000000E-01*(_TMP16.xyz + _TMP17.xyz);\n" +" _c0078 = TEX0.xy*_inverse_resolution + _dir*-5.00000000E-01;\n" +" _TMP18 = COMPAT_TEXTURE(Texture, _c0078);\n" +" _c0080 = TEX0.xy + _dir*5.00000000E-01;\n" +" _TMP19 = COMPAT_TEXTURE(Texture, _c0080);\n" +" _rgbB = _rgbA*5.00000000E-01 + 2.50000000E-01*(_TMP18.xyz + _TMP19.xyz);\n" +" _lumaB = dot(_rgbB, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" if (_lumaB < _lumaMin || _lumaB > _lumaMax) { \n" +" _OUT._color = vec4(_rgbA.x, _rgbA.y, _rgbA.z, 1.00000000E+00);\n" +" } else {\n" +" _OUT._color = vec4(_rgbB.x, _rgbB.y, _rgbB.z, 1.00000000E+00);\n" +" } \n" +" FragColor = _OUT._color;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/anti-aliasing/fxaa-edge-detect.h b/src/video/sdl/shaders/anti-aliasing/fxaa-edge-detect.h new file mode 100644 index 000000000..2cc65a1db --- /dev/null +++ b/src/video/sdl/shaders/anti-aliasing/fxaa-edge-detect.h @@ -0,0 +1,182 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _M;\n" +"COMPAT_VARYING vec2 _DR;\n" +"COMPAT_VARYING vec2 _DL;\n" +"COMPAT_VARYING vec2 _UR;\n" +"COMPAT_VARYING vec2 _UL;\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _vpos1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _position1;\n" +" vec4 _vpos1;\n" +" vec2 _texCoord1;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"struct deltas {\n" +" vec2 _UL;\n" +" vec2 _UR;\n" +" vec2 _DL;\n" +" vec2 _DR;\n" +" vec2 _M;\n" +"};\n" +"VERTEX_OUTPUT _ret_0;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _ret_0._position1 = _r0006;\n" +" _ret_0._vpos1 = _r0006;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" TEX1 = _r0006;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" TEX1 = _ret_0._vpos1;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _M;\n" +"COMPAT_VARYING vec2 _DR;\n" +"COMPAT_VARYING vec2 _DL;\n" +"COMPAT_VARYING vec2 _UR;\n" +"COMPAT_VARYING vec2 _UL;\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _vpos;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _vpos;\n" +" vec2 _texCoord;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"struct deltas {\n" +" vec2 _UL;\n" +" vec2 _UR;\n" +" vec2 _DL;\n" +" vec2 _DR;\n" +" vec2 _M;\n" +"};\n" +"float _TMP12;\n" +"float _TMP11;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" output_dummy _OUT;\n" +" vec2 _ps;\n" +" float _lumaUL;\n" +" float _lumaUR;\n" +" float _lumaDL;\n" +" float _lumaDR;\n" +" vec2 _dir;\n" +" deltas _TMP16;\n" +" _ps = vec2(9.99899983E-01/TextureSize.x, 9.99899983E-01/TextureSize.y);\n" +" _TMP16._UL = TEX0.xy + vec2(-_ps.x, -_ps.y);\n" +" _TMP16._UR = TEX0.xy + vec2(_ps.x, -_ps.y);\n" +" _TMP16._DL = TEX0.xy + vec2(-_ps.x, _ps.y);\n" +" _TMP16._DR = TEX0.xy + vec2(_ps.x, _ps.y);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _TMP16._UL);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _TMP16._UR);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _TMP16._DL);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, _TMP16._DR);\n" +" _lumaUL = dot(_TMP0.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaUR = dot(_TMP1.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaDL = dot(_TMP2.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _lumaDR = dot(_TMP3.xyz, vec3( 2.98999995E-01, 5.87000012E-01, 1.14000000E-01));\n" +" _dir.x = -((_lumaUL + _lumaUR) - (_lumaDR + _lumaDL));\n" +" _dir.y = (_lumaUR + _lumaDR) - (_lumaUL + _lumaDL);\n" +" _TMP11 = abs(_dir.x);\n" +" _TMP12 = abs(_dir.y);\n" +" _OUT._color = vec4(_TMP11 + _TMP12, _TMP11 + _TMP12, _TMP11 + _TMP12, _TMP11 + _TMP12);\n" +" FragColor = _OUT._color;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/blend.h b/src/video/sdl/shaders/blend.h new file mode 100644 index 000000000..c5418f283 --- /dev/null +++ b/src/video/sdl/shaders/blend.h @@ -0,0 +1,23 @@ +{ +"#if defined(VERTEX)\n" +"attribute vec2 TexCoord;\n" +"attribute vec2 VertexCoord;\n" +"attribute vec4 Color;\n" +"uniform mat4 MVPMatrix;\n" +"varying vec2 tex_coord;\n" +"varying vec4 color;\n" +"void main() {\n" +" gl_Position = MVPMatrix * vec4(VertexCoord, 0.0, 1.0);\n" +" tex_coord = TexCoord;\n" +" color = Color;\n" +"}\n" +"#elif defined(FRAGMENT)\n" +"uniform sampler2D Texture;\n" +"varying vec2 tex_coord;\n" +"varying vec4 color;\n" +"void main() {\n" +" gl_FragColor = color * texture2D(Texture, tex_coord);\n" +"}\n" +"#endif\n" +}, + diff --git a/src/video/sdl/shaders/color.h b/src/video/sdl/shaders/color.h deleted file mode 100644 index cbce16633..000000000 --- a/src/video/sdl/shaders/color.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/*****************************************************************************************/ -/* COLOR */ -/*****************************************************************************************/ -{ - // vertex shader - "void main(void) {\n" - " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" - " gl_FrontColor = gl_Color;\n" - "}", - // fragment shader - "void main(void) {\n" - " gl_FragColor = gl_Color;\n" - "}" -}, diff --git a/src/video/sdl/shaders/crt.h b/src/video/sdl/shaders/crt.h deleted file mode 100644 index a5670896b..000000000 --- a/src/video/sdl/shaders/crt.h +++ /dev/null @@ -1,360 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/*****************************************************************************************/ -/* CRT */ -/*****************************************************************************************/ -{ - // vertex shader - "varying float CRTgamma;\n" - "varying float monitorgamma;\n" - "varying vec2 overscan;\n" - "varying vec2 aspect;\n" - "varying float d;\n" - "varying float R;\n" - "varying float cornersize;\n" - "varying float cornersmooth;\n" - - "varying vec3 stretch;\n" - "varying vec2 sinangle;\n" - "varying vec2 cosangle;\n" - - "uniform vec2 size_screen_emu;\n" - "uniform vec2 size_texture;\n" - "uniform float pixel_aspect_ratio;\n" - - "varying vec2 texCoord;\n" - "varying vec2 one;\n" - "varying float mod_factor;\n" - - "#define FIX(c) max(abs(c), 1e-5);\n" - - "float intersect(vec2 xy) {\n" - " float A = dot(xy,xy)+d*d;\n" - " float B = 2.0*(R*(dot(xy,sinangle)-d*cosangle.x*cosangle.y)-d*d);\n" - " float C = d*d + 2.0*R*d*cosangle.x*cosangle.y;\n" - " return (-B-sqrt(B*B-4.0*A*C))/(2.0*A);\n" - "}\n" - - "vec2 bkwtrans(vec2 xy) {\n" - " float c = intersect(xy);\n" - " vec2 point = c*xy;\n" - " point -= -R*sinangle;\n" - " point /= vec2(R);\n" - " vec2 tang = sinangle/cosangle;\n" - " vec2 poc = point/cosangle;\n" - " float A = dot(tang,tang)+1.0;\n" - " float B = -2.0*dot(poc,tang);\n" - " float C = dot(poc,poc)-1.0;\n" - " float a = (-B+sqrt(B*B-4.0*A*C))/(2.0*A);\n" - " vec2 uv = (point-a*sinangle)/cosangle;\n" - " float r = R*acos(a);\n" - " return uv*r/sin(r/R);\n" - "}\n" - - "vec2 fwtrans(vec2 uv) {\n" - " float r = FIX(sqrt(dot(uv,uv)));\n" - " uv *= sin(r/R)/r;\n" - " float x = 1.0-cos(r/R);\n" - " float D = d/R + x*cosangle.x*cosangle.y+dot(uv,sinangle);\n" - " return d*(uv*cosangle-x*sinangle)/D;\n" - "}\n" - - "vec3 maxscale() {\n" - " vec2 c = bkwtrans(-R * sinangle / (1.0 + R/d*cosangle.x*cosangle.y));\n" - " vec2 a = 0.5*aspect;\n" - " vec2 lo = vec2(fwtrans(vec2(-a.x,c.y)).x,\n" - " fwtrans(vec2(c.x,-a.y)).y)/aspect;\n" - " vec2 hi = vec2(fwtrans(vec2(+a.x,c.y)).x,\n" - " fwtrans(vec2(c.x,+a.y)).y)/aspect;\n" - " return vec3((hi+lo)*aspect*0.5,max(hi.x-lo.x,hi.y-lo.y));\n" - "}\n" - - "void main() {\n" - " gl_FrontColor = gl_Color;\n" - " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" - " texCoord = gl_MultiTexCoord0.xy;\n" - - " // START of parameters\n" - - " // gamma of simulated CRT\n" - " CRTgamma = 2.4;\n" - " // gamma of display monitor (typically 2.2 is correct)\n" - " monitorgamma = 2.2;\n" - " // overscan (e.g. 1.02 for 2% overscan)\n" - " overscan = vec2(1.01,1.01);\n" - " // aspect ratio\n" - " aspect = vec2(1.0, 0.75);\n" - " // lengths are measured in units of (approximately) the width\n" - " // of the monitor simulated distance from viewer to monitor\n" - " d = 2.0;\n" - " // radius of curvature\n" - " R = 1.5;\n" - " // tilt angle in radians\n" - " // (behavior might be a bit wrong if both components are\n" - " // nonzero)\n" - " const vec2 angle = vec2(0.0,-0.15);\n" - " // size of curved corners\n" - " cornersize = 0.03;\n" - " // border smoothness parameter\n" - " // decrease if borders are too aliased\n" - " cornersmooth = 1000.0;\n" - - " // END of parameters\n" - - " // Precalculate a bunch of useful values we'll need in the fragment shader.\n" - " sinangle = sin(angle);\n" - " cosangle = cos(angle);\n" - " stretch = maxscale();\n" - - " // The size of one texel, in texture-coordinates.\n" - " one = 1.0 / (vec2(256.0) * (size_screen_emu.x / size_screen_emu.y));\n" - - " // Resulting X pixel-coordinate of the pixel we're drawing.\n" - " mod_factor = texCoord.x * (256.0 * pixel_aspect_ratio);\n" - "}", - // fragment shader - "// Macros.\n" - "#define FIX(c) max(abs(c), 1e-5);\n" - "#define PI 3.141592653589\n" - - "uniform vec2 size_screen_emu;\n" - "uniform vec2 size_texture;\n" - "uniform float param;\n" - "uniform float full_interpolation;\n" - - "uniform sampler2D texture_scr;\n" - - "varying vec2 texCoord;\n" - "varying vec2 one;\n" - "varying float mod_factor;\n" - - "varying float CRTgamma;\n" - "varying float monitorgamma;\n" - - "varying vec2 overscan;\n" - "varying vec2 aspect;\n" - - "varying float d;\n" - "varying float R;\n" - - "varying float cornersize;\n" - "varying float cornersmooth;\n" - - "varying vec3 stretch;\n" - "varying vec2 sinangle;\n" - "varying vec2 cosangle;\n" - - "float intersect(vec2 xy) {\n" - " float A = dot(xy,xy)+d*d;\n" - " float B = 2.0*(R*(dot(xy,sinangle)-d*cosangle.x*cosangle.y)-d*d);\n" - " float C = d*d + 2.0*R*d*cosangle.x*cosangle.y;\n" - " return (-B-sqrt(B*B-4.0*A*C))/(2.0*A);\n" - "}\n" - - "vec2 bkwtrans(vec2 xy) {\n" - " float c = intersect(xy);\n" - " vec2 point = c*xy;\n" - " point -= -R*sinangle;\n" - " point /= vec2(R);\n" - " vec2 tang = sinangle/cosangle;\n" - " vec2 poc = point/cosangle;\n" - " float A = dot(tang,tang)+1.0;\n" - " float B = -2.0*dot(poc,tang);\n" - " float C = dot(poc,poc)-1.0;\n" - " float a = (-B+sqrt(B*B-4.0*A*C))/(2.0*A);\n" - " vec2 uv = (point-a*sinangle)/cosangle;\n" - " float r = FIX(R*acos(a));\n" - " return uv*r/sin(r/R);\n" - "}\n" - - "vec2 transform(vec2 coord) {\n" - " coord *= (256.0 / size_screen_emu);\n" - " coord = (coord-0.5)*aspect*stretch.z+stretch.xy;\n" - " return (bkwtrans(coord)/overscan/aspect+0.5) * (size_screen_emu / 256.0);\n" - "}\n" - - "float corner(vec2 coord) {\n" - " coord *= (256.0 / size_screen_emu);\n" - " coord = (coord - 0.5) * overscan + 0.5;\n" - " coord = min(coord, 1.0-coord) * aspect;\n" - " vec2 cdist = vec2(cornersize);\n" - " coord = (cdist - min(coord,cdist));\n" - " float dist = sqrt(dot(coord,coord));\n" - " return clamp((cdist.x-dist)*cornersmooth,0.0, 1.0);\n" - "}\n" - - "// Calculate the influence of a scanline on the current pixel.\n" - "// 'distance' is the distance in texture coordinates from the current\n" - "// pixel to the scanline in question.\n" - "// 'color' is the colour of the scanline at the horizontal location of\n" - "// the current pixel.\n" - "vec4 scanlineWeights(float distance, vec4 color) {\n" - " // 'wid' controls the width of the scanline beam, for each RGB\n" - " // channel The 'weights' lines basically specify the formula\n" - " // that gives you the profile of the beam, i.e. the intensity as\n" - " // a function of distance from the vertical center of the\n" - " // scanline. In this case, it is gaussian if width=2, and\n" - " // becomes nongaussian for larger widths. Ideally this should\n" - " // be normalized so that the integral across the beam is\n" - " // independent of its width. That is, for a narrower beam\n" - " // 'weights' should have a higher peak at the center of the\n" - " // scanline than for a wider beam.\n" - " if (param == 1.0) {\n" - " // Use the older, purely gaussian beam profile\n" - " vec4 wid = 0.3 + 0.1 * pow(color, vec4(3.0));\n" - " vec4 weights = vec4(distance / wid);\n" - " return 0.4 * exp(-weights * weights) / wid;\n" - " } else {\n" - " vec4 wid = 2.0 + 2.0 * pow(color, vec4(4.0));\n" - " vec4 weights = vec4(distance / 0.3);\n" - " return 1.4 * exp(-pow(weights * inversesqrt(0.5 * wid), wid)) / (0.6 + 0.2 * wid);\n" - " }\n" - "}\n" - - "void main() {\n" - " vec2 xy;\n" - " vec4 col;\n" - " vec4 col2;\n" - - " // Here's a helpful diagram to keep in mind while trying to\n" - " // understand the code:\n" - " //\n" - " // | | | | |\n" - " // -------------------------------\n" - " // | | | | |\n" - " // | 01 | 11 | 21 | 31 | <-- current scanline\n" - " // | | @ | | |\n" - " // -------------------------------\n" - " // | | | | |\n" - " // | 02 | 12 | 22 | 32 | <-- next scanline\n" - " // | | | | |\n" - " // -------------------------------\n" - " // | | | | |\n" - " //\n" - " // Each character-cell represents a pixel on the output\n" - " // surface, '@' represents the current pixel (always somewhere\n" - " // in the bottom half of the current scan-line, or the top-half\n" - " // of the next scanline). The grid of lines represents the\n" - " // edges of the texels of the underlying texture.\n" - - " // Texture coordinates of the texel containing the active pixel.\n" - " if (param == 0.0) {\n" - " // Enable screen curvature.\n" - " xy = transform(texCoord);\n" - " } else {\n" - " xy = texCoord;\n" - " }\n" - - " float cval = corner(xy);\n" - - " // Of all the pixels that are mapped onto the texel we are\n" - " // currently rendering, which pixel are we currently rendering?\n" - " vec2 ratio_scale = (xy * 256.0) + 0.5;\n" - - " vec2 uv_ratio = fract(ratio_scale);\n" - - " // Snap to the center of the underlying texel.\n" - " xy = (floor(ratio_scale) - 0.5) / 256.0;\n" - - " // Calculate Lanczos scaling coefficients describing the effect\n" - " // of various neighbour texels in a scanline on the current\n" - " // pixel.\n" - " vec4 coeffs = PI * vec4(1.0 + uv_ratio.x, uv_ratio.x, 1.0 - uv_ratio.x, 2.0 - uv_ratio.x);\n" - - " // Prevent division by zero.\n" - " coeffs = FIX(coeffs);\n" - - " // Lanczos2 kernel.\n" - " coeffs = 2.0 * sin(coeffs) * sin(coeffs / 2.0) / (coeffs * coeffs);\n" - - " // Normalize.\n" - " coeffs /= dot(coeffs, vec4(1.0));\n" - - " // Calculate the effective colour of the current and next\n" - " // scanlines at the horizontal location of the current pixel,\n" - " // using the Lanczos coefficients above.\n" - " if (full_interpolation == 1.0) {\n" - " // LINEAR_PROCESSING ON (slow)\n" - " col = clamp(mat4(" - " pow(texture2D(texture_scr, xy + vec2(-one.x, 0.0)), vec4(CRTgamma))," - " pow(texture2D(texture_scr, xy), vec4(CRTgamma))," - " pow(texture2D(texture_scr, xy + vec2(one.x, 0.0)), vec4(CRTgamma))," - " pow(texture2D(texture_scr, xy + vec2(2.0 * one.x, 0.0)), vec4(CRTgamma))) * coeffs," - " 0.0, 1.0);\n" - " col2 = clamp(mat4(" - " pow(texture2D(texture_scr, xy + vec2(-one.x, one.y)), vec4(CRTgamma))," - " pow(texture2D(texture_scr, xy + vec2(0.0, one.y)), vec4(CRTgamma))," - " pow(texture2D(texture_scr, xy + one), vec4(CRTgamma))," - " pow(texture2D(texture_scr, xy + vec2(2.0 * one.x, one.y)), vec4(CRTgamma))) * coeffs," - " 0.0, 1.0);\n" - " } else {\n" - " // LINEAR_PROCESSING OFF (gain speed)\n" - " col = clamp(mat4(" - " texture2D(texture_scr, xy + vec2(-one.x, 0.0))," - " texture2D(texture_scr, xy)," - " texture2D(texture_scr, xy + vec2(one.x, 0.0))," - " texture2D(texture_scr, xy + vec2(2.0 * one.x, 0.0))) * coeffs," - " 0.0, 1.0);\n" - " col2 = clamp(mat4(" - " texture2D(texture_scr, xy + vec2(-one.x, one.y))," - " texture2D(texture_scr, xy + vec2(0.0, one.y))," - " texture2D(texture_scr, xy + one)," - " texture2D(texture_scr, xy + vec2(2.0 * one.x, one.y))) * coeffs," - " 0.0, 1.0);\n" - " col = pow(col , vec4(CRTgamma));\n" - " col2 = pow(col2, vec4(CRTgamma));\n" - " }\n" - - " // Calculate the influence of the current and next scanlines on\n" - " // the current pixel.\n" - " vec4 weights = scanlineWeights(uv_ratio.y, col);\n" - " vec4 weights2 = scanlineWeights(1.0 - uv_ratio.y, col2);\n" - - "// Enable 3x oversampling of the beam profile\n" - " if (param == 0.0) {\n" - " float filter = fwidth(ratio_scale.y);\n" - " uv_ratio.y =uv_ratio.y+1.0/3.0*filter;\n" - " weights = (weights+scanlineWeights(uv_ratio.y, col))/3.0;\n" - " weights2=(weights2+scanlineWeights(abs(1.0-uv_ratio.y), col2))/3.0;\n" - " uv_ratio.y =uv_ratio.y-2.0/3.0*filter;\n" - " weights=weights+scanlineWeights(abs(uv_ratio.y), col)/3.0;\n" - " weights2=weights2+scanlineWeights(abs(1.0-uv_ratio.y), col2)/3.0;\n" - " }\n" - - " vec3 mul_res = (col * weights + col2 * weights2).rgb * cval;\n" - - " // dot-mask emulation:\n" - " // Output pixels are alternately tinted green and magenta.\n" - " vec3 dotMaskWeights = mix(" - " vec3(1.0, 0.7, 1.0)," - " vec3(0.7, 1.0, 0.7)," - " floor(mod(mod_factor, 2.0))" - " );\n" - - " mul_res *= dotMaskWeights;\n" - - " // Convert the image gamma for display on our output device.\n" - " mul_res = pow(mul_res, vec3(1.0 / monitorgamma));\n" - - " // Color the texel.\n" - " vec4 scr = vec4(mul_res, 1.0);\n" - - " gl_FragColor = scr * gl_Color;\n" - "}" -}, diff --git a/src/video/sdl/shaders/crt/4xbr-hybrid-crt.h b/src/video/sdl/shaders/crt/4xbr-hybrid-crt.h new file mode 100644 index 000000000..12bcd3e46 --- /dev/null +++ b/src/video/sdl/shaders/crt/4xbr-hybrid-crt.h @@ -0,0 +1,834 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord2;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord2;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"out_vertex _ret_0;\n" +"input_dummy _IN1;\n" +"vec4 _r0010;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" vec2 _ps;\n" +" vec2 _texCoord;\n" +" _r0010 = VertexCoord.x*MVPMatrix[0];\n" +" _r0010 = _r0010 + VertexCoord.y*MVPMatrix[1];\n" +" _r0010 = _r0010 + VertexCoord.z*MVPMatrix[2];\n" +" _r0010 = _r0010 + VertexCoord.w*MVPMatrix[3];\n" +" _ps = vec2(1.00000000E+00/TextureSize.x, 1.00000000E+00/TextureSize.y);\n" +" _texCoord = TexCoord.xy + vec2( 1.00000001E-07, 1.00000001E-07);\n" +" _OUT._t1 = _texCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), float(float((-2.00000000E+00*_ps.y))));\n" +" _OUT._t2 = _texCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), float(float(-_ps.y)));\n" +" _OUT._t3 = _texCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), 0.00000000E+00);\n" +" _OUT._t4 = _texCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), float(float(_ps.y)));\n" +" _OUT._t5 = _texCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), float(float((2.00000000E+00*_ps.y))));\n" +" _OUT._t6 = _texCoord.xyyy + vec4(float(float((-2.00000000E+00*_ps.x))), float(float(-_ps.y)), 0.00000000E+00, float(float(_ps.y)));\n" +" _OUT._t7 = _texCoord.xyyy + vec4(float(float((2.00000000E+00*_ps.x))), float(float(-_ps.y)), 0.00000000E+00, float(float(_ps.y)));\n" +" _ret_0._position1 = _r0010;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord2 = _texCoord;\n" +" _ret_0._t1 = _OUT._t1;\n" +" _ret_0._t2 = _OUT._t2;\n" +" _ret_0._t3 = _OUT._t3;\n" +" _ret_0._t4 = _OUT._t4;\n" +" _ret_0._t5 = _OUT._t5;\n" +" _ret_0._t6 = _OUT._t6;\n" +" _ret_0._t7 = _OUT._t7;\n" +" gl_Position = vec4(float(_r0010.x), float(_r0010.y), float(_r0010.z), float(_r0010.w));\n" +" COL0 = COLOR;\n" +" TEX0.xy = _texCoord;\n" +" TEX1 = _OUT._t1;\n" +" TEX2 = _OUT._t2;\n" +" TEX3 = _OUT._t3;\n" +" TEX4 = _OUT._t4;\n" +" TEX5 = _OUT._t5;\n" +" TEX6 = _OUT._t6;\n" +" TEX7 = _OUT._t7;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord2;\n" +" TEX1 = _ret_0._t1;\n" +" TEX2 = _ret_0._t2;\n" +" TEX3 = _ret_0._t3;\n" +" TEX4 = _ret_0._t4;\n" +" TEX5 = _ret_0._t5;\n" +" TEX6 = _ret_0._t6;\n" +" TEX7 = _ret_0._t7;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color1;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color1;\n" +" vec2 _texCoord;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP76;\n" +"vec3 _TMP92;\n" +"float _TMP91;\n" +"float _TMP90;\n" +"float _TMP89;\n" +"vec3 _TMP75;\n" +"float _TMP88;\n" +"float _TMP87;\n" +"float _TMP86;\n" +"float _TMP95;\n" +"float _TMP74;\n" +"float _TMP73;\n" +"float _TMP72;\n" +"vec3 _TMP94;\n" +"vec3 _TMP71;\n" +"vec3 _TMP70;\n" +"vec3 _TMP69;\n" +"vec3 _TMP68;\n" +"vec3 _TMP67;\n" +"vec3 _TMP66;\n" +"vec3 _TMP65;\n" +"vec3 _TMP64;\n" +"vec3 _TMP63;\n" +"vec3 _TMP62;\n" +"vec4 _TMP61;\n" +"float _TMP60;\n" +"float _TMP59;\n" +"float _TMP58;\n" +"vec3 _TMP85;\n" +"vec3 _TMP56;\n" +"vec3 _TMP55;\n" +"vec3 _TMP54;\n" +"vec3 _TMP53;\n" +"vec4 _TMP46;\n" +"vec4 _TMP45;\n" +"vec4 _TMP96;\n" +"bvec4 _TMP44;\n" +"bvec4 _TMP43;\n" +"bvec4 _TMP42;\n" +"bvec4 _TMP41;\n" +"bvec4 _TMP40;\n" +"bvec4 _TMP39;\n" +"bvec4 _TMP38;\n" +"bvec4 _TMP37;\n" +"bvec4 _TMP36;\n" +"bvec4 _TMP35;\n" +"bvec4 _TMP34;\n" +"bvec4 _TMP33;\n" +"bvec4 _TMP32;\n" +"bvec4 _TMP31;\n" +"bvec4 _TMP30;\n" +"bvec4 _TMP29;\n" +"bvec4 _TMP28;\n" +"bvec4 _TMP27;\n" +"float _TMP93;\n" +"vec4 _TMP20;\n" +"vec4 _TMP19;\n" +"vec4 _TMP18;\n" +"vec4 _TMP17;\n" +"vec4 _TMP16;\n" +"vec4 _TMP15;\n" +"vec4 _TMP14;\n" +"vec4 _TMP13;\n" +"vec4 _TMP12;\n" +"vec4 _TMP11;\n" +"vec4 _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _x0110;\n" +"vec4 _r0154;\n" +"vec4 _r0164;\n" +"vec4 _r0174;\n" +"vec4 _r0184;\n" +"vec4 _r0194;\n" +"vec4 _r0204;\n" +"vec4 _TMP215;\n" +"vec4 _a0218;\n" +"vec4 _TMP221;\n" +"vec4 _a0224;\n" +"vec4 _TMP227;\n" +"vec4 _a0230;\n" +"vec4 _TMP233;\n" +"vec4 _a0236;\n" +"vec4 _TMP239;\n" +"vec4 _a0242;\n" +"vec4 _TMP245;\n" +"vec4 _a0248;\n" +"vec4 _TMP251;\n" +"vec4 _a0254;\n" +"vec4 _TMP257;\n" +"vec4 _a0260;\n" +"vec4 _TMP263;\n" +"vec4 _a0266;\n" +"vec4 _TMP269;\n" +"vec4 _a0272;\n" +"vec4 _TMP275;\n" +"vec4 _a0278;\n" +"vec4 _TMP281;\n" +"vec4 _a0284;\n" +"vec4 _TMP287;\n" +"vec4 _a0290;\n" +"vec4 _TMP293;\n" +"vec4 _a0296;\n" +"vec4 _TMP299;\n" +"vec4 _a0302;\n" +"vec4 _TMP305;\n" +"vec4 _a0308;\n" +"vec4 _TMP311;\n" +"vec4 _a0314;\n" +"vec4 _TMP317;\n" +"vec4 _a0320;\n" +"vec4 _x0324;\n" +"vec4 _TMP325;\n" +"vec4 _x0334;\n" +"vec4 _TMP335;\n" +"vec4 _x0344;\n" +"vec4 _TMP345;\n" +"vec4 _TMP353;\n" +"vec4 _a0356;\n" +"vec4 _TMP357;\n" +"vec4 _a0360;\n" +"vec4 _TMP361;\n" +"vec4 _a0364;\n" +"vec4 _TMP365;\n" +"vec4 _a0368;\n" +"vec4 _TMP369;\n" +"vec4 _a0372;\n" +"vec4 _TMP375;\n" +"vec4 _a0378;\n" +"vec4 _TMP379;\n" +"vec4 _a0382;\n" +"vec4 _TMP383;\n" +"vec4 _a0386;\n" +"vec4 _TMP387;\n" +"vec4 _a0390;\n" +"vec4 _TMP391;\n" +"vec4 _a0394;\n" +"vec4 _TMP395;\n" +"vec4 _a0398;\n" +"vec4 _TMP399;\n" +"vec4 _a0402;\n" +"vec4 _TMP403;\n" +"vec4 _a0406;\n" +"vec4 _TMP407;\n" +"vec4 _a0410;\n" +"vec4 _TMP411;\n" +"vec4 _a0414;\n" +"vec4 _TMP415;\n" +"vec4 _a0418;\n" +"vec3 _b0422;\n" +"vec3 _b0426;\n" +"vec3 _TMP427;\n" +"vec3 _a0428;\n" +"vec3 _b0436;\n" +"vec3 _b0440;\n" +"vec3 _TMP441;\n" +"vec3 _a0442;\n" +"vec4 _a0448;\n" +"vec4 _a0450;\n" +"vec4 _a0452;\n" +"vec3 _b0458;\n" +"vec3 _b0460;\n" +"vec3 _df0462;\n" +"vec3 _a0464;\n" +"vec3 _df0466;\n" +"vec3 _a0468;\n" +"vec3 _TMP497;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" bvec4 _edr;\n" +" bvec4 _edr_left;\n" +" bvec4 _edr_up;\n" +" bvec4 _px;\n" +" bvec4 _interp_restriction_lv1;\n" +" bvec4 _interp_restriction_lv2_left;\n" +" bvec4 _interp_restriction_lv2_up;\n" +" bvec4 _nc;\n" +" bvec4 _nc30;\n" +" bvec4 _nc60;\n" +" bvec4 _nc45;\n" +" vec4 _fx;\n" +" vec4 _fx_left;\n" +" vec4 _fx_up;\n" +" vec3 _res1;\n" +" vec3 _res2;\n" +" vec3 _pix1;\n" +" vec3 _pix2;\n" +" float _blend1;\n" +" float _blend2;\n" +" vec2 _fp;\n" +" vec3 _A11;\n" +" vec3 _B11;\n" +" vec3 _C1;\n" +" vec3 _A3;\n" +" vec3 _B3;\n" +" vec3 _C;\n" +" vec3 _D;\n" +" vec3 _E;\n" +" vec3 _F;\n" +" vec3 _G;\n" +" vec3 _H;\n" +" vec3 _I;\n" +" vec3 _G5;\n" +" vec3 _H5;\n" +" vec3 _I5;\n" +" vec3 _A0;\n" +" vec3 _D0;\n" +" vec3 _G0;\n" +" vec3 _C4;\n" +" vec3 _F4;\n" +" vec3 _I4;\n" +" vec4 _b1;\n" +" vec4 _c3;\n" +" vec4 _e1;\n" +" vec4 _i4;\n" +" vec4 _i5;\n" +" vec4 _h5;\n" +" vec4 _fx45;\n" +" vec4 _fx30;\n" +" vec4 _fx60;\n" +" vec3 _res;\n" +" vec3 _n1;\n" +" vec3 _n2;\n" +" vec3 _n3;\n" +" vec3 _n4;\n" +" vec3 _s;\n" +" vec3 _aa;\n" +" vec3 _bb;\n" +" vec3 _cc;\n" +" vec3 _dd;\n" +" vec3 _t;\n" +" vec3 _m;\n" +" vec3 _s1;\n" +" vec3 _s0;\n" +" vec4 _maximo;\n" +" vec3 _color;\n" +" float _ddy;\n" +" float _v_weight_00;\n" +" vec3 _coords10;\n" +" vec3 _colorNB;\n" +" float _v_weight_10;\n" +" _x0110 = TEX0.xy*TextureSize;\n" +" _fp = fract(_x0110);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX1.xw);\n" +" _A11 = vec3(float(_TMP0.x), float(_TMP0.y), float(_TMP0.z));\n" +" _TMP1 = COMPAT_TEXTURE(Texture, TEX1.yw);\n" +" _B11 = vec3(float(_TMP1.x), float(_TMP1.y), float(_TMP1.z));\n" +" _TMP2 = COMPAT_TEXTURE(Texture, TEX1.zw);\n" +" _C1 = vec3(float(_TMP2.x), float(_TMP2.y), float(_TMP2.z));\n" +" _TMP3 = COMPAT_TEXTURE(Texture, TEX2.xw);\n" +" _A3 = vec3(float(_TMP3.x), float(_TMP3.y), float(_TMP3.z));\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX2.yw);\n" +" _B3 = vec3(float(_TMP4.x), float(_TMP4.y), float(_TMP4.z));\n" +" _TMP5 = COMPAT_TEXTURE(Texture, TEX2.zw);\n" +" _C = vec3(float(_TMP5.x), float(_TMP5.y), float(_TMP5.z));\n" +" _TMP6 = COMPAT_TEXTURE(Texture, TEX3.xw);\n" +" _D = vec3(float(_TMP6.x), float(_TMP6.y), float(_TMP6.z));\n" +" _TMP7 = COMPAT_TEXTURE(Texture, TEX3.yw);\n" +" _E = vec3(float(_TMP7.x), float(_TMP7.y), float(_TMP7.z));\n" +" _TMP8 = COMPAT_TEXTURE(Texture, TEX3.zw);\n" +" _F = vec3(float(_TMP8.x), float(_TMP8.y), float(_TMP8.z));\n" +" _TMP9 = COMPAT_TEXTURE(Texture, TEX4.xw);\n" +" _G = vec3(float(_TMP9.x), float(_TMP9.y), float(_TMP9.z));\n" +" _TMP10 = COMPAT_TEXTURE(Texture, TEX4.yw);\n" +" _H = vec3(float(_TMP10.x), float(_TMP10.y), float(_TMP10.z));\n" +" _TMP11 = COMPAT_TEXTURE(Texture, TEX4.zw);\n" +" _I = vec3(float(_TMP11.x), float(_TMP11.y), float(_TMP11.z));\n" +" _TMP12 = COMPAT_TEXTURE(Texture, TEX5.xw);\n" +" _G5 = vec3(float(_TMP12.x), float(_TMP12.y), float(_TMP12.z));\n" +" _TMP13 = COMPAT_TEXTURE(Texture, TEX5.yw);\n" +" _H5 = vec3(float(_TMP13.x), float(_TMP13.y), float(_TMP13.z));\n" +" _TMP14 = COMPAT_TEXTURE(Texture, TEX5.zw);\n" +" _I5 = vec3(float(_TMP14.x), float(_TMP14.y), float(_TMP14.z));\n" +" _TMP15 = COMPAT_TEXTURE(Texture, TEX6.xy);\n" +" _A0 = vec3(float(_TMP15.x), float(_TMP15.y), float(_TMP15.z));\n" +" _TMP16 = COMPAT_TEXTURE(Texture, TEX6.xz);\n" +" _D0 = vec3(float(_TMP16.x), float(_TMP16.y), float(_TMP16.z));\n" +" _TMP17 = COMPAT_TEXTURE(Texture, TEX6.xw);\n" +" _G0 = vec3(float(_TMP17.x), float(_TMP17.y), float(_TMP17.z));\n" +" _TMP18 = COMPAT_TEXTURE(Texture, TEX7.xy);\n" +" _C4 = vec3(float(_TMP18.x), float(_TMP18.y), float(_TMP18.z));\n" +" _TMP19 = COMPAT_TEXTURE(Texture, TEX7.xz);\n" +" _F4 = vec3(float(_TMP19.x), float(_TMP19.y), float(_TMP19.z));\n" +" _TMP20 = COMPAT_TEXTURE(Texture, TEX7.xw);\n" +" _I4 = vec3(float(_TMP20.x), float(_TMP20.y), float(_TMP20.z));\n" +" _TMP93 = dot(vec3(float(_B3.x), float(_B3.y), float(_B3.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0154.x = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_D.x), float(_D.y), float(_D.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0154.y = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_H.x), float(_H.y), float(_H.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0154.z = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_F.x), float(_F.y), float(_F.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0154.w = float(_TMP93);\n" +" _b1 = vec4(float(_r0154.x), float(_r0154.y), float(_r0154.z), float(_r0154.w));\n" +" _TMP93 = dot(vec3(float(_C.x), float(_C.y), float(_C.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0164.x = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_A3.x), float(_A3.y), float(_A3.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0164.y = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_G.x), float(_G.y), float(_G.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0164.z = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_I.x), float(_I.y), float(_I.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0164.w = float(_TMP93);\n" +" _c3 = vec4(float(_r0164.x), float(_r0164.y), float(_r0164.z), float(_r0164.w));\n" +" _TMP93 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0174.x = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0174.y = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0174.z = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0174.w = float(_TMP93);\n" +" _e1 = vec4(float(_r0174.x), float(_r0174.y), float(_r0174.z), float(_r0174.w));\n" +" _TMP93 = dot(vec3(float(_I4.x), float(_I4.y), float(_I4.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0184.x = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_C1.x), float(_C1.y), float(_C1.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0184.y = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_A0.x), float(_A0.y), float(_A0.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0184.z = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_G5.x), float(_G5.y), float(_G5.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0184.w = float(_TMP93);\n" +" _i4 = vec4(float(_r0184.x), float(_r0184.y), float(_r0184.z), float(_r0184.w));\n" +" _TMP93 = dot(vec3(float(_I5.x), float(_I5.y), float(_I5.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0194.x = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_C4.x), float(_C4.y), float(_C4.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0194.y = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_A11.x), float(_A11.y), float(_A11.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0194.z = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_G0.x), float(_G0.y), float(_G0.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0194.w = float(_TMP93);\n" +" _i5 = vec4(float(_r0194.x), float(_r0194.y), float(_r0194.z), float(_r0194.w));\n" +" _TMP93 = dot(vec3(float(_H5.x), float(_H5.y), float(_H5.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0204.x = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_F4.x), float(_F4.y), float(_F4.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0204.y = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_B11.x), float(_B11.y), float(_B11.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0204.z = float(_TMP93);\n" +" _TMP93 = dot(vec3(float(_D0.x), float(_D0.y), float(_D0.z)), vec3( 1.43593750E+01, 2.81718750E+01, 5.47265625E+00));\n" +" _r0204.w = float(_TMP93);\n" +" _h5 = vec4(float(_r0204.x), float(_r0204.y), float(_r0204.z), float(_r0204.w));\n" +" _fx = vec4( 1.00000000E+00, -1.00000000E+00, -1.00000000E+00, 1.00000000E+00)*_fp.y + vec4( 1.00000000E+00, 1.00000000E+00, -1.00000000E+00, -1.00000000E+00)*_fp.x;\n" +" _fx_left = vec4( 1.00000000E+00, -1.00000000E+00, -1.00000000E+00, 1.00000000E+00)*_fp.y + vec4( 5.00000000E-01, 2.00000000E+00, -5.00000000E-01, -2.00000000E+00)*_fp.x;\n" +" _fx_up = vec4( 1.00000000E+00, -1.00000000E+00, -1.00000000E+00, 1.00000000E+00)*_fp.y + vec4( 2.00000000E+00, 5.00000000E-01, -2.00000000E+00, -5.00000000E-01)*_fp.x;\n" +" _a0218 = _e1 - _b1;\n" +" _TMP215 = abs(_a0218);\n" +" _TMP27 = bvec4(_TMP215.x < 2.00000000E+00, _TMP215.y < 2.00000000E+00, _TMP215.z < 2.00000000E+00, _TMP215.w < 2.00000000E+00);\n" +" _a0224 = _e1 - _b1.yzwx;\n" +" _TMP221 = abs(_a0224);\n" +" _TMP28 = bvec4(_TMP221.x < 2.00000000E+00, _TMP221.y < 2.00000000E+00, _TMP221.z < 2.00000000E+00, _TMP221.w < 2.00000000E+00);\n" +" _a0230 = _e1 - _c3.yzwx;\n" +" _TMP227 = abs(_a0230);\n" +" _TMP29 = bvec4(_TMP227.x < 2.00000000E+00, _TMP227.y < 2.00000000E+00, _TMP227.z < 2.00000000E+00, _TMP227.w < 2.00000000E+00);\n" +" _a0236 = _b1.wxyz - _h5.yzwx;\n" +" _TMP233 = abs(_a0236);\n" +" _TMP30 = bvec4(_TMP233.x < 2.00000000E+00, _TMP233.y < 2.00000000E+00, _TMP233.z < 2.00000000E+00, _TMP233.w < 2.00000000E+00);\n" +" _a0242 = _b1.wxyz - _c3;\n" +" _TMP239 = abs(_a0242);\n" +" _TMP31 = bvec4(_TMP239.x < 2.00000000E+00, _TMP239.y < 2.00000000E+00, _TMP239.z < 2.00000000E+00, _TMP239.w < 2.00000000E+00);\n" +" _a0248 = _b1.zwxy - _h5;\n" +" _TMP245 = abs(_a0248);\n" +" _TMP32 = bvec4(_TMP245.x < 2.00000000E+00, _TMP245.y < 2.00000000E+00, _TMP245.z < 2.00000000E+00, _TMP245.w < 2.00000000E+00);\n" +" _a0254 = _b1.zwxy - _c3.zwxy;\n" +" _TMP251 = abs(_a0254);\n" +" _TMP33 = bvec4(_TMP251.x < 2.00000000E+00, _TMP251.y < 2.00000000E+00, _TMP251.z < 2.00000000E+00, _TMP251.w < 2.00000000E+00);\n" +" _a0260 = _b1.wxyz - _b1;\n" +" _TMP257 = abs(_a0260);\n" +" _TMP34 = bvec4(_TMP257.x < 1.50000000E+01, _TMP257.y < 1.50000000E+01, _TMP257.z < 1.50000000E+01, _TMP257.w < 1.50000000E+01);\n" +" _a0266 = _b1.wxyz - _c3;\n" +" _TMP263 = abs(_a0266);\n" +" _TMP35 = bvec4(_TMP263.x < 1.50000000E+01, _TMP263.y < 1.50000000E+01, _TMP263.z < 1.50000000E+01, _TMP263.w < 1.50000000E+01);\n" +" _a0272 = _b1.zwxy - _b1.yzwx;\n" +" _TMP269 = abs(_a0272);\n" +" _TMP36 = bvec4(_TMP269.x < 1.50000000E+01, _TMP269.y < 1.50000000E+01, _TMP269.z < 1.50000000E+01, _TMP269.w < 1.50000000E+01);\n" +" _a0278 = _b1.zwxy - _c3.zwxy;\n" +" _TMP275 = abs(_a0278);\n" +" _TMP37 = bvec4(_TMP275.x < 1.50000000E+01, _TMP275.y < 1.50000000E+01, _TMP275.z < 1.50000000E+01, _TMP275.w < 1.50000000E+01);\n" +" _a0284 = _e1 - _c3.wxyz;\n" +" _TMP281 = abs(_a0284);\n" +" _TMP38 = bvec4(_TMP281.x < 1.50000000E+01, _TMP281.y < 1.50000000E+01, _TMP281.z < 1.50000000E+01, _TMP281.w < 1.50000000E+01);\n" +" _a0290 = _b1.wxyz - _h5.yzwx;\n" +" _TMP287 = abs(_a0290);\n" +" _TMP39 = bvec4(_TMP287.x < 1.50000000E+01, _TMP287.y < 1.50000000E+01, _TMP287.z < 1.50000000E+01, _TMP287.w < 1.50000000E+01);\n" +" _a0296 = _b1.wxyz - _i4;\n" +" _TMP293 = abs(_a0296);\n" +" _TMP40 = bvec4(_TMP293.x < 1.50000000E+01, _TMP293.y < 1.50000000E+01, _TMP293.z < 1.50000000E+01, _TMP293.w < 1.50000000E+01);\n" +" _a0302 = _b1.zwxy - _h5;\n" +" _TMP299 = abs(_a0302);\n" +" _TMP41 = bvec4(_TMP299.x < 1.50000000E+01, _TMP299.y < 1.50000000E+01, _TMP299.z < 1.50000000E+01, _TMP299.w < 1.50000000E+01);\n" +" _a0308 = _b1.zwxy - _i5;\n" +" _TMP305 = abs(_a0308);\n" +" _TMP42 = bvec4(_TMP305.x < 1.50000000E+01, _TMP305.y < 1.50000000E+01, _TMP305.z < 1.50000000E+01, _TMP305.w < 1.50000000E+01);\n" +" _a0314 = _e1 - _c3.zwxy;\n" +" _TMP311 = abs(_a0314);\n" +" _TMP43 = bvec4(_TMP311.x < 1.50000000E+01, _TMP311.y < 1.50000000E+01, _TMP311.z < 1.50000000E+01, _TMP311.w < 1.50000000E+01);\n" +" _a0320 = _e1 - _c3;\n" +" _TMP317 = abs(_a0320);\n" +" _TMP44 = bvec4(_TMP317.x < 1.50000000E+01, _TMP317.y < 1.50000000E+01, _TMP317.z < 1.50000000E+01, _TMP317.w < 1.50000000E+01);\n" +" _interp_restriction_lv1 = bvec4(_e1.x != _b1.w && _e1.x != _b1.z && (_TMP27.x || _TMP28.x || !_TMP29.x) && (_TMP30.x || _TMP31.x || _TMP32.x || _TMP33.x) && (!_TMP34.x && !_TMP35.x || !_TMP36.x && !_TMP37.x || _TMP38.x && (!_TMP39.x && !_TMP40.x || !_TMP41.x && !_TMP42.x) || _TMP43.x || _TMP44.x), _e1.y != _b1.x && _e1.y != _b1.w && (_TMP27.y || _TMP28.y || !_TMP29.y) && (_TMP30.y || _TMP31.y || _TMP32.y || _TMP33.y) && (!_TMP34.y && !_TMP35.y || !_TMP36.y && !_TMP37.y || _TMP38.y && (!_TMP39.y && !_TMP40.y || !_TMP41.y && !_TMP42.y) || _TMP43.y || _TMP44.y), _e1.z != _b1.y && _e1.z != _b1.x && (_TMP27.z || _TMP28.z || !_TMP29.z) && (_TMP30.z || _TMP31.z || _TMP32.z || _TMP33.z) && (!_TMP34.z && !_TMP35.z || !_TMP36.z && !_TMP37.z || _TMP38.z && (!_TMP39.z && !_TMP40.z || !_TMP41.z && !_TMP42.z) || _TMP43.z || _TMP44.z), _e1.w != _b1.z && _e1.w != _b1.y && (_TMP27.w || _TMP28.w || !_TMP29.w) && (_TMP30.w || _TMP31.w || _TMP32.w || _TMP33.w) && (!_TMP34.w && !_TMP35.w || !_TMP36.w && !_TMP37.w || _TMP38.w && (!_TMP39.w && !_TMP40.w || !_TMP41.w && !_TMP42.w) || _TMP43.w || _TMP44.w));\n" +" _interp_restriction_lv2_left = bvec4(_e1.x != _c3.z && _b1.y != _c3.z, _e1.y != _c3.w && _b1.z != _c3.w, _e1.z != _c3.x && _b1.w != _c3.x, _e1.w != _c3.y && _b1.x != _c3.y);\n" +" _interp_restriction_lv2_up = bvec4(_e1.x != _c3.x && _b1.x != _c3.x, _e1.y != _c3.y && _b1.y != _c3.y, _e1.z != _c3.z && _b1.z != _c3.z, _e1.w != _c3.w && _b1.w != _c3.w);\n" +" _x0324 = (_fx - vec4( 1.10000002E+00, 9.99999940E-02, -8.99999976E-01, 9.99999940E-02))/vec4( 7.99999952E-01, 7.99999952E-01, 7.99999952E-01, 7.99999952E-01);\n" +" _TMP96 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0324);\n" +" _TMP325 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP96);\n" +" _fx45 = _TMP325*_TMP325*(3.00000000E+00 - 2.00000000E+00*_TMP325);\n" +" _x0334 = (_fx_left - vec4( 6.00000024E-01, 6.00000024E-01, -8.99999976E-01, -4.00000006E-01))/vec4( 7.99999952E-01, 7.99999952E-01, 7.99999952E-01, 8.00000012E-01);\n" +" _TMP96 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0334);\n" +" _TMP335 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP96);\n" +" _fx30 = _TMP335*_TMP335*(3.00000000E+00 - 2.00000000E+00*_TMP335);\n" +" _x0344 = (_fx_up - vec4( 1.60000002E+00, -4.00000006E-01, -1.39999998E+00, 9.99999940E-02))/vec4( 8.00000072E-01, 8.00000012E-01, 7.99999952E-01, 7.99999952E-01);\n" +" _TMP96 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0344);\n" +" _TMP345 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP96);\n" +" _fx60 = _TMP345*_TMP345*(3.00000000E+00 - 2.00000000E+00*_TMP345);\n" +" _a0356 = _e1 - _c3;\n" +" _TMP353 = abs(_a0356);\n" +" _a0360 = _e1 - _c3.zwxy;\n" +" _TMP357 = abs(_a0360);\n" +" _a0364 = _c3.wxyz - _h5;\n" +" _TMP361 = abs(_a0364);\n" +" _a0368 = _c3.wxyz - _h5.yzwx;\n" +" _TMP365 = abs(_a0368);\n" +" _a0372 = _b1.zwxy - _b1.wxyz;\n" +" _TMP369 = abs(_a0372);\n" +" _TMP45 = _TMP353 + _TMP357 + _TMP361 + _TMP365 + 4.00000000E+00*_TMP369;\n" +" _a0378 = _b1.zwxy - _b1.yzwx;\n" +" _TMP375 = abs(_a0378);\n" +" _a0382 = _b1.zwxy - _i5;\n" +" _TMP379 = abs(_a0382);\n" +" _a0386 = _b1.wxyz - _i4;\n" +" _TMP383 = abs(_a0386);\n" +" _a0390 = _b1.wxyz - _b1;\n" +" _TMP387 = abs(_a0390);\n" +" _a0394 = _e1 - _c3.wxyz;\n" +" _TMP391 = abs(_a0394);\n" +" _TMP46 = _TMP375 + _TMP379 + _TMP383 + _TMP387 + 4.00000000E+00*_TMP391;\n" +" _edr = bvec4((_TMP45 + 3.50000000E+00).x < _TMP46.x && _interp_restriction_lv1.x, (_TMP45 + 3.50000000E+00).y < _TMP46.y && _interp_restriction_lv1.y, (_TMP45 + 3.50000000E+00).z < _TMP46.z && _interp_restriction_lv1.z, (_TMP45 + 3.50000000E+00).w < _TMP46.w && _interp_restriction_lv1.w);\n" +" _a0398 = _b1.wxyz - _c3.zwxy;\n" +" _TMP395 = abs(_a0398);\n" +" _a0402 = _b1.zwxy - _c3;\n" +" _TMP399 = abs(_a0402);\n" +" _edr_left = bvec4((2.00000000E+00*_TMP395).x <= _TMP399.x && _interp_restriction_lv2_left.x, (2.00000000E+00*_TMP395).y <= _TMP399.y && _interp_restriction_lv2_left.y, (2.00000000E+00*_TMP395).z <= _TMP399.z && _interp_restriction_lv2_left.z, (2.00000000E+00*_TMP395).w <= _TMP399.w && _interp_restriction_lv2_left.w);\n" +" _a0406 = _b1.wxyz - _c3.zwxy;\n" +" _TMP403 = abs(_a0406);\n" +" _a0410 = _b1.zwxy - _c3;\n" +" _TMP407 = abs(_a0410);\n" +" _edr_up = bvec4(_TMP403.x >= (2.00000000E+00*_TMP407).x && _interp_restriction_lv2_up.x, _TMP403.y >= (2.00000000E+00*_TMP407).y && _interp_restriction_lv2_up.y, _TMP403.z >= (2.00000000E+00*_TMP407).z && _interp_restriction_lv2_up.z, _TMP403.w >= (2.00000000E+00*_TMP407).w && _interp_restriction_lv2_up.w);\n" +" _nc45 = bvec4(_edr.x && bool(_fx45.x), _edr.y && bool(_fx45.y), _edr.z && bool(_fx45.z), _edr.w && bool(_fx45.w));\n" +" _nc30 = bvec4(_edr.x && _edr_left.x && bool(_fx30.x), _edr.y && _edr_left.y && bool(_fx30.y), _edr.z && _edr_left.z && bool(_fx30.z), _edr.w && _edr_left.w && bool(_fx30.w));\n" +" _nc60 = bvec4(_edr.x && _edr_up.x && bool(_fx60.x), _edr.y && _edr_up.y && bool(_fx60.y), _edr.z && _edr_up.z && bool(_fx60.z), _edr.w && _edr_up.w && bool(_fx60.w));\n" +" _a0414 = _e1 - _b1.wxyz;\n" +" _TMP411 = abs(_a0414);\n" +" _a0418 = _e1 - _b1.zwxy;\n" +" _TMP415 = abs(_a0418);\n" +" _px = bvec4(_TMP411.x <= _TMP415.x, _TMP411.y <= _TMP415.y, _TMP411.z <= _TMP415.z, _TMP411.w <= _TMP415.w);\n" +" _n1 = vec3(float(_B11.x), float(_B11.y), float(_B11.z));\n" +" _n2 = vec3(float(_B3.x), float(_B3.y), float(_B3.z));\n" +" _s = vec3(float(_E.x), float(_E.y), float(_E.z));\n" +" _n3 = vec3(float(_H.x), float(_H.y), float(_H.z));\n" +" _n4 = vec3(float(_H5.x), float(_H5.y), float(_H5.z));\n" +" _aa = _n2 - _n1;\n" +" _bb = _s - _n2;\n" +" _cc = _n3 - _s;\n" +" _dd = _n4 - _n3;\n" +" _t = (7.00000000E+00*(_bb + _cc) - 3.00000000E+00*(_aa + _dd))/1.60000000E+01;\n" +" _m = vec3(_s.x < 5.00000000E-01 ? (2.00000000E+00*_s).x : (2.00000000E+00*(1.00000000E+00 - _s)).x, _s.y < 5.00000000E-01 ? (2.00000000E+00*_s).y : (2.00000000E+00*(1.00000000E+00 - _s)).y, _s.z < 5.00000000E-01 ? (2.00000000E+00*_s).z : (2.00000000E+00*(1.00000000E+00 - _s)).z);\n" +" _TMP53 = abs(_bb);\n" +" _b0422 = 6.49999976E-01*_TMP53;\n" +" _m = min(_m, _b0422);\n" +" _TMP54 = abs(_cc);\n" +" _b0426 = 6.49999976E-01*_TMP54;\n" +" _m = min(_m, _b0426);\n" +" _a0428 = -_m;\n" +" _TMP85 = min(_m, _t);\n" +" _TMP427 = max(_a0428, _TMP85);\n" +" _s1 = (2.00000000E+00*_fp.y - 1.00000000E+00)*_TMP427 + _s;\n" +" _n1 = vec3(float(_D0.x), float(_D0.y), float(_D0.z));\n" +" _n2 = vec3(float(_D.x), float(_D.y), float(_D.z));\n" +" _n3 = vec3(float(_F.x), float(_F.y), float(_F.z));\n" +" _n4 = vec3(float(_F4.x), float(_F4.y), float(_F4.z));\n" +" _aa = _n2 - _n1;\n" +" _bb = _s1 - _n2;\n" +" _cc = _n3 - _s1;\n" +" _dd = _n4 - _n3;\n" +" _t = (7.00000000E+00*(_bb + _cc) - 3.00000000E+00*(_aa + _dd))/1.60000000E+01;\n" +" _m = vec3(_s1.x < 5.00000000E-01 ? (2.00000000E+00*_s1).x : (2.00000000E+00*(1.00000000E+00 - _s1)).x, _s1.y < 5.00000000E-01 ? (2.00000000E+00*_s1).y : (2.00000000E+00*(1.00000000E+00 - _s1)).y, _s1.z < 5.00000000E-01 ? (2.00000000E+00*_s1).z : (2.00000000E+00*(1.00000000E+00 - _s1)).z);\n" +" _TMP55 = abs(_bb);\n" +" _b0436 = 6.49999976E-01*_TMP55;\n" +" _m = min(_m, _b0436);\n" +" _TMP56 = abs(_cc);\n" +" _b0440 = 6.49999976E-01*_TMP56;\n" +" _m = min(_m, _b0440);\n" +" _a0442 = -_m;\n" +" _TMP85 = min(_m, _t);\n" +" _TMP441 = max(_a0442, _TMP85);\n" +" _s0 = (2.00000000E+00*_fp.x - 1.00000000E+00)*_TMP441 + _s1;\n" +" _nc = bvec4(_nc30.x || _nc60.x || _nc45.x, _nc30.y || _nc60.y || _nc45.y, _nc30.z || _nc60.z || _nc45.z, _nc30.w || _nc60.w || _nc45.w);\n" +" _blend2 = 0.00000000E+00;\n" +" _blend1 = 0.00000000E+00;\n" +" _a0448 = vec4(float(_nc45.x), float(_nc45.y), float(_nc45.z), float(_nc45.w));\n" +" _TMP58 = dot(_a0448, _fx45);\n" +" _a0450 = vec4(float(_nc30.x), float(_nc30.y), float(_nc30.z), float(_nc30.w));\n" +" _TMP59 = dot(_a0450, _fx30);\n" +" _a0452 = vec4(float(_nc60.x), float(_nc60.y), float(_nc60.z), float(_nc60.w));\n" +" _TMP60 = dot(_a0452, _fx60);\n" +" _TMP61 = max(vec4(_TMP59, _TMP59, _TMP59, _TMP59), vec4(_TMP60, _TMP60, _TMP60, _TMP60));\n" +" _maximo = max(_TMP61, vec4(_TMP58, _TMP58, _TMP58, _TMP58));\n" +" if (_nc.x) { \n" +" if (_px.x) { \n" +" _TMP62 = _F;\n" +" } else {\n" +" _TMP62 = _H;\n" +" } \n" +" _pix1 = _TMP62;\n" +" _blend1 = _maximo.x;\n" +" } else {\n" +" if (_nc.y) { \n" +" if (_px.y) { \n" +" _TMP63 = _B3;\n" +" } else {\n" +" _TMP63 = _F;\n" +" } \n" +" _pix1 = _TMP63;\n" +" _blend1 = _maximo.y;\n" +" } else {\n" +" if (_nc.z) { \n" +" if (_px.z) { \n" +" _TMP64 = _D;\n" +" } else {\n" +" _TMP64 = _B3;\n" +" } \n" +" _pix1 = _TMP64;\n" +" _blend1 = _maximo.z;\n" +" } else {\n" +" if (_nc.w) { \n" +" if (_px.w) { \n" +" _TMP65 = _H;\n" +" } else {\n" +" _TMP65 = _D;\n" +" } \n" +" _pix1 = _TMP65;\n" +" _blend1 = _maximo.w;\n" +" } \n" +" } \n" +" } \n" +" } \n" +" if (_nc.w) { \n" +" if (_px.w) { \n" +" _TMP66 = _H;\n" +" } else {\n" +" _TMP66 = _D;\n" +" } \n" +" _pix2 = _TMP66;\n" +" _blend2 = _maximo.w;\n" +" } else {\n" +" if (_nc.z) { \n" +" if (_px.z) { \n" +" _TMP67 = _D;\n" +" } else {\n" +" _TMP67 = _B3;\n" +" } \n" +" _pix2 = _TMP67;\n" +" _blend2 = _maximo.z;\n" +" } else {\n" +" if (_nc.y) { \n" +" if (_px.y) { \n" +" _TMP68 = _B3;\n" +" } else {\n" +" _TMP68 = _F;\n" +" } \n" +" _pix2 = _TMP68;\n" +" _blend2 = _maximo.y;\n" +" } else {\n" +" if (_nc.x) { \n" +" if (_px.x) { \n" +" _TMP69 = _F;\n" +" } else {\n" +" _TMP69 = _H;\n" +" } \n" +" _pix2 = _TMP69;\n" +" _blend2 = _maximo.x;\n" +" } \n" +" } \n" +" } \n" +" } \n" +" _b0458 = vec3(float(_pix1.x), float(_pix1.y), float(_pix1.z));\n" +" _TMP70 = _s0 + _blend1*(_b0458 - _s0);\n" +" _res1 = vec3(float(_TMP70.x), float(_TMP70.y), float(_TMP70.z));\n" +" _b0460 = vec3(float(_pix2.x), float(_pix2.y), float(_pix2.z));\n" +" _TMP71 = _s0 + _blend2*(_b0460 - _s0);\n" +" _res2 = vec3(float(_TMP71.x), float(_TMP71.y), float(_TMP71.z));\n" +" _a0464 = _E - _res1;\n" +" _TMP94 = abs(vec3(float(_a0464.x), float(_a0464.y), float(_a0464.z)));\n" +" _df0462 = vec3(float(_TMP94.x), float(_TMP94.y), float(_TMP94.z));\n" +" _TMP72 = _df0462.x + _df0462.y + _df0462.z;\n" +" _a0468 = _E - _res2;\n" +" _TMP94 = abs(vec3(float(_a0468.x), float(_a0468.y), float(_a0468.z)));\n" +" _df0466 = vec3(float(_TMP94.x), float(_TMP94.y), float(_TMP94.z));\n" +" _TMP73 = _df0466.x + _df0466.y + _df0466.z;\n" +" _TMP74 = float((_TMP73 >= _TMP72));\n" +" _res = _res1 + _TMP74*(_res2 - _res1);\n" +" _TMP95 = pow(float(_res.x), 2.40039062E+00);\n" +" _TMP86 = float(_TMP95);\n" +" _TMP95 = pow(float(_res.y), 2.40039062E+00);\n" +" _TMP87 = float(_TMP95);\n" +" _TMP95 = pow(float(_res.z), 2.40039062E+00);\n" +" _TMP88 = float(_TMP95);\n" +" _TMP75 = vec3(_TMP86, _TMP87, _TMP88);\n" +" _color = vec3(float(_TMP75.x), float(_TMP75.y), float(_TMP75.z));\n" +" _ddy = _fp.y - 5.00000000E-01;\n" +" _v_weight_00 = _ddy/5.79999983E-01;\n" +" if (_v_weight_00 > 1.00000000E+00) { \n" +" _v_weight_00 = 1.00000000E+00;\n" +" } \n" +" _v_weight_00 = 1.00000000E+00 - _v_weight_00*_v_weight_00;\n" +" _v_weight_00 = _v_weight_00*_v_weight_00;\n" +" _color = _color*vec3(_v_weight_00, _v_weight_00, _v_weight_00);\n" +" if (_ddy > 0.00000000E+00) { \n" +" _coords10 = vec3(float(_H.x), float(_H.y), float(_H.z));\n" +" _ddy = 1.00000000E+00 - _ddy;\n" +" } else {\n" +" _coords10 = vec3(float(_B3.x), float(_B3.y), float(_B3.z));\n" +" _ddy = 1.00000000E+00 + _ddy;\n" +" } \n" +" _TMP89 = pow(_coords10.x, 2.40000010E+00);\n" +" _TMP90 = pow(_coords10.y, 2.40000010E+00);\n" +" _TMP91 = pow(_coords10.z, 2.40000010E+00);\n" +" _colorNB = vec3(_TMP89, _TMP90, _TMP91);\n" +" _v_weight_10 = _ddy/5.79999983E-01;\n" +" if (_v_weight_10 > 1.00000000E+00) { \n" +" _v_weight_10 = 1.00000000E+00;\n" +" } \n" +" _v_weight_10 = 1.00000000E+00 - _v_weight_10*_v_weight_10;\n" +" _v_weight_10 = _v_weight_10*_v_weight_10;\n" +" _color = _color + _colorNB*vec3(_v_weight_10, _v_weight_10, _v_weight_10);\n" +" _color = _color*vec3( 1.45000005E+00, 1.45000005E+00, 1.45000005E+00);\n" +" _TMP89 = pow(_color.x, 4.54545438E-01);\n" +" _TMP90 = pow(_color.y, 4.54545438E-01);\n" +" _TMP91 = pow(_color.z, 4.54545438E-01);\n" +" _TMP76 = vec3(_TMP89, _TMP90, _TMP91);\n" +" _TMP92 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _TMP76);\n" +" _TMP497 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP92);\n" +" _ret_0 = vec4(_TMP497.x, _TMP497.y, _TMP497.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-caligari.h b/src/video/sdl/shaders/crt/crt-caligari.h new file mode 100644 index 000000000..d9fe7ec23 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-caligari.h @@ -0,0 +1,241 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _oney;\n" +"COMPAT_VARYING vec2 _onex;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"struct tex_coords {\n" +" vec2 _texCoord;\n" +" vec2 _onex;\n" +" vec2 _oney;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" tex_coords _coords;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _coords._texCoord = TexCoord.xy;\n" +" _coords._onex = vec2(1.00000000E+00/TextureSize.x, 0.00000000E+00);\n" +" _coords._oney = vec2(0.00000000E+00, 1.00000000E+00/TextureSize.y);\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +" TEX1.xy = _coords._onex;\n" +" TEX2.xy = _coords._oney;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _oney;\n" +"COMPAT_VARYING vec2 _onex;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"struct tex_coords {\n" +" vec2 _texCoord;\n" +" vec2 _onex;\n" +" vec2 _oney;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _TMP5;\n" +"vec4 _TMP10;\n" +"float _TMP9;\n" +"float _TMP8;\n" +"float _TMP7;\n" +"float _TMP6;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec2 _TMP0;\n" +"input_dummy _IN1;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0028;\n" +"vec2 _c0040;\n" +"vec2 _c0052;\n" +"vec4 _TMP73;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _coords;\n" +" vec2 _pixel_center;\n" +" vec2 _texture_coords;\n" +" vec4 _color;\n" +" float _dx;\n" +" float _h_weight_00;\n" +" vec2 _coords01;\n" +" vec4 _colorNB;\n" +" float _h_weight_01;\n" +" float _dy;\n" +" float _v_weight_00;\n" +" vec2 _coords10;\n" +" float _v_weight_10;\n" +" _coords = TEX0.xy*TextureSize;\n" +" _TMP0 = floor(_coords);\n" +" _pixel_center = _TMP0 + vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _texture_coords = _pixel_center/TextureSize;\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _texture_coords);\n" +" _TMP6 = pow(_TMP1.x, 2.40000010E+00);\n" +" _TMP7 = pow(_TMP1.y, 2.40000010E+00);\n" +" _TMP8 = pow(_TMP1.z, 2.40000010E+00);\n" +" _TMP9 = pow(_TMP1.w, 2.40000010E+00);\n" +" _color = vec4(_TMP6, _TMP7, _TMP8, _TMP9);\n" +" _dx = _coords.x - _pixel_center.x;\n" +" _h_weight_00 = _dx/8.99999976E-01;\n" +" if (_h_weight_00 > 1.00000000E+00) { \n" +" _h_weight_00 = 1.00000000E+00;\n" +" } \n" +" _h_weight_00 = 1.00000000E+00 - _h_weight_00*_h_weight_00;\n" +" _h_weight_00 = _h_weight_00*_h_weight_00;\n" +" _color = _color*vec4(_h_weight_00, _h_weight_00, _h_weight_00, _h_weight_00);\n" +" if (_dx > 0.00000000E+00) { \n" +" _coords01 = TEX1.xy;\n" +" _dx = 1.00000000E+00 - _dx;\n" +" } else {\n" +" _coords01 = -TEX1.xy;\n" +" _dx = 1.00000000E+00 + _dx;\n" +" } \n" +" _c0028 = _texture_coords + _coords01;\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0028);\n" +" _TMP6 = pow(_TMP2.x, 2.40000010E+00);\n" +" _TMP7 = pow(_TMP2.y, 2.40000010E+00);\n" +" _TMP8 = pow(_TMP2.z, 2.40000010E+00);\n" +" _TMP9 = pow(_TMP2.w, 2.40000010E+00);\n" +" _colorNB = vec4(_TMP6, _TMP7, _TMP8, _TMP9);\n" +" _h_weight_01 = _dx/8.99999976E-01;\n" +" if (_h_weight_01 > 1.00000000E+00) { \n" +" _h_weight_01 = 1.00000000E+00;\n" +" } \n" +" _h_weight_01 = 1.00000000E+00 - _h_weight_01*_h_weight_01;\n" +" _h_weight_01 = _h_weight_01*_h_weight_01;\n" +" _color = _color + _colorNB*vec4(_h_weight_01, _h_weight_01, _h_weight_01, _h_weight_01);\n" +" _dy = _coords.y - _pixel_center.y;\n" +" _v_weight_00 = _dy/6.49999976E-01;\n" +" if (_v_weight_00 > 1.00000000E+00) { \n" +" _v_weight_00 = 1.00000000E+00;\n" +" } \n" +" _v_weight_00 = 1.00000000E+00 - _v_weight_00*_v_weight_00;\n" +" _v_weight_00 = _v_weight_00*_v_weight_00;\n" +" _color = _color*vec4(_v_weight_00, _v_weight_00, _v_weight_00, _v_weight_00);\n" +" if (_dy > 0.00000000E+00) { \n" +" _coords10 = TEX2.xy;\n" +" _dy = 1.00000000E+00 - _dy;\n" +" } else {\n" +" _coords10 = -TEX2.xy;\n" +" _dy = 1.00000000E+00 + _dy;\n" +" } \n" +" _c0040 = _texture_coords + _coords10;\n" +" _TMP3 = COMPAT_TEXTURE(Texture, _c0040);\n" +" _TMP6 = pow(_TMP3.x, 2.40000010E+00);\n" +" _TMP7 = pow(_TMP3.y, 2.40000010E+00);\n" +" _TMP8 = pow(_TMP3.z, 2.40000010E+00);\n" +" _TMP9 = pow(_TMP3.w, 2.40000010E+00);\n" +" _colorNB = vec4(_TMP6, _TMP7, _TMP8, _TMP9);\n" +" _v_weight_10 = _dy/6.49999976E-01;\n" +" if (_v_weight_10 > 1.00000000E+00) { \n" +" _v_weight_10 = 1.00000000E+00;\n" +" } \n" +" _v_weight_10 = 1.00000000E+00 - _v_weight_10*_v_weight_10;\n" +" _v_weight_10 = _v_weight_10*_v_weight_10;\n" +" _color = _color + _colorNB*vec4(_v_weight_10*_h_weight_00, _v_weight_10*_h_weight_00, _v_weight_10*_h_weight_00, _v_weight_10*_h_weight_00);\n" +" _c0052 = _texture_coords + _coords01 + _coords10;\n" +" _TMP4 = COMPAT_TEXTURE(Texture, _c0052);\n" +" _TMP6 = pow(_TMP4.x, 2.40000010E+00);\n" +" _TMP7 = pow(_TMP4.y, 2.40000010E+00);\n" +" _TMP8 = pow(_TMP4.z, 2.40000010E+00);\n" +" _TMP9 = pow(_TMP4.w, 2.40000010E+00);\n" +" _colorNB = vec4(_TMP6, _TMP7, _TMP8, _TMP9);\n" +" _color = _color + _colorNB*vec4(_v_weight_10*_h_weight_01, _v_weight_10*_h_weight_01, _v_weight_10*_h_weight_01, _v_weight_10*_h_weight_01);\n" +" _color = _color*vec4( 1.45000005E+00, 1.45000005E+00, 1.45000005E+00, 1.45000005E+00);\n" +" _TMP6 = pow(_color.x, 4.54545438E-01);\n" +" _TMP7 = pow(_color.y, 4.54545438E-01);\n" +" _TMP8 = pow(_color.z, 4.54545438E-01);\n" +" _TMP9 = pow(_color.w, 4.54545438E-01);\n" +" _TMP5 = vec4(_TMP6, _TMP7, _TMP8, _TMP9);\n" +" _TMP10 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _TMP5);\n" +" _TMP73 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP10);\n" +" FragColor = _TMP73;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-cgwg-fast.h b/src/video/sdl/shaders/crt/crt-cgwg-fast.h new file mode 100644 index 000000000..1bde42563 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-cgwg-fast.h @@ -0,0 +1,326 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 VARratio_scale;\n" +"COMPAT_VARYING float VARmod_factor;\n" +"COMPAT_VARYING vec2 VARc32;\n" +"COMPAT_VARYING vec2 VARc22;\n" +"COMPAT_VARYING vec2 VARc12;\n" +"COMPAT_VARYING vec2 VARc02;\n" +"COMPAT_VARYING vec2 VARc31;\n" +"COMPAT_VARYING vec2 VARc21;\n" +"COMPAT_VARYING vec2 VARc11;\n" +"COMPAT_VARYING vec2 VARc01;\n" +"struct tex_coords {\n" +" vec2 VARc01;\n" +" vec2 VARc11;\n" +" vec2 VARc21;\n" +" vec2 VARc31;\n" +" vec2 VARc02;\n" +" vec2 VARc12;\n" +" vec2 VARc22;\n" +" vec2 VARc32;\n" +" float VARmod_factor;\n" +" vec2 VARratio_scale;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"tex_coords _coords1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _delta;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _delta = 1.00000000E+00/TextureSize;\n" +" VARc01 = TexCoord.xy + vec2(-_delta.x, 0.00000000E+00);\n" +" VARc11 = TexCoord.xy;\n" +" VARc21 = TexCoord.xy + vec2(_delta.x, 0.00000000E+00);\n" +" VARc31 = TexCoord.xy + vec2(2.00000000E+00*_delta.x, 0.00000000E+00);\n" +" VARc02 = TexCoord.xy + vec2(-_delta.x, _delta.y);\n" +" VARc12 = TexCoord.xy + vec2(0.00000000E+00, _delta.y);\n" +" VARc22 = TexCoord.xy + vec2(_delta.x, _delta.y);\n" +" VARc32 = TexCoord.xy + vec2(2.00000000E+00*_delta.x, _delta.y);\n" +" VARmod_factor = (TexCoord.x*OutputSize.x*TextureSize.x)/InputSize.x;\n" +" VARratio_scale = TexCoord.xy*TextureSize;\n" +" gl_Position = _r0006;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 VARratio_scale;\n" +"COMPAT_VARYING float VARmod_factor;\n" +"COMPAT_VARYING vec2 VARc32;\n" +"COMPAT_VARYING vec2 VARc22;\n" +"COMPAT_VARYING vec2 VARc12;\n" +"COMPAT_VARYING vec2 VARc02;\n" +"COMPAT_VARYING vec2 VARc31;\n" +"COMPAT_VARYING vec2 VARc21;\n" +"COMPAT_VARYING vec2 VARc11;\n" +"COMPAT_VARYING vec2 VARc01;\n" +"struct tex_coords {\n" +" vec2 VARc01;\n" +" vec2 VARc11;\n" +" vec2 VARc21;\n" +" vec2 VARc31;\n" +" vec2 VARc02;\n" +" vec2 VARc12;\n" +" vec2 VARc22;\n" +" vec2 VARc32;\n" +" float VARmod_factor;\n" +" vec2 VARratio_scale;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP21;\n" +"float _TMP28;\n" +"float _TMP27;\n" +"float _TMP26;\n" +"float _TMP20;\n" +"float _TMP35;\n" +"float _TMP34;\n" +"float _TMP33;\n" +"float _TMP32;\n" +"vec3 _TMP16;\n" +"vec3 _TMP15;\n" +"float _TMP31;\n" +"float _TMP30;\n" +"float _TMP29;\n" +"vec3 _TMP14;\n" +"vec3 _TMP13;\n" +"vec3 _TMP36;\n" +"float _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"float _TMP25;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"tex_coords _co1;\n" +"uniform sampler2D Texture;\n" +"vec4 _x0062;\n" +"vec4 _x0072;\n" +"vec3 _r0084;\n" +"vec3 _TMP87;\n" +"vec3 _r0094;\n" +"vec3 _TMP97;\n" +"vec3 _x0136;\n" +"vec3 _x0144;\n" +"vec3 _TMP167;\n" +"vec3 _TMP177;\n" +"float VARc0188;\n" +"float _a0190;\n" +"vec3 _a0200;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _uv_ratio;\n" +" vec3 _col;\n" +" vec3 _col2;\n" +" vec4 _coeffs;\n" +" vec3 _weights;\n" +" vec3 _weights2;\n" +" vec3 _wid;\n" +" vec3 _wid2;\n" +" vec3 _sqrt1;\n" +" vec3 _sqrt2;\n" +" vec3 _pow_mul1;\n" +" vec3 _pow_mul2;\n" +" vec3 _div1;\n" +" vec3 _div2;\n" +" vec3 _pow1;\n" +" vec3 _pow2;\n" +" vec3 _multi;\n" +" vec3 _mcol;\n" +" _uv_ratio = fract(VARratio_scale);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, VARc01);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, VARc11);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, VARc21);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, VARc31);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, VARc02);\n" +" _TMP5 = COMPAT_TEXTURE(Texture, VARc12);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, VARc22);\n" +" _TMP7 = COMPAT_TEXTURE(Texture, VARc32);\n" +" _coeffs = vec4(1.00000000E+00 + _uv_ratio.x, _uv_ratio.x, 1.00000000E+00 - _uv_ratio.x, 2.00000000E+00 - _uv_ratio.x) + 4.99999989E-03;\n" +" _x0062 = 3.14159274E+00*_coeffs;\n" +" _TMP22 = sin(_x0062.x);\n" +" _TMP23 = sin(_x0062.y);\n" +" _TMP24 = sin(_x0062.z);\n" +" _TMP25 = sin(_x0062.w);\n" +" _TMP8 = vec4(_TMP22, _TMP23, _TMP24, _TMP25);\n" +" _x0072 = 1.57079637E+00*_coeffs;\n" +" _TMP22 = sin(_x0072.x);\n" +" _TMP23 = sin(_x0072.y);\n" +" _TMP24 = sin(_x0072.z);\n" +" _TMP25 = sin(_x0072.w);\n" +" _TMP9 = vec4(_TMP22, _TMP23, _TMP24, _TMP25);\n" +" _coeffs = (_TMP8*_TMP9)/(_coeffs*_coeffs);\n" +" _TMP10 = dot(_coeffs, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _coeffs = _coeffs/_TMP10;\n" +" _weights = vec3(3.32999992E+00*_uv_ratio.y, 3.32999992E+00*_uv_ratio.y, 3.32999992E+00*_uv_ratio.y);\n" +" _weights2 = vec3(_uv_ratio.y*-3.32999992E+00 + 3.32999992E+00, _uv_ratio.y*-3.32999992E+00 + 3.32999992E+00, _uv_ratio.y*-3.32999992E+00 + 3.32999992E+00);\n" +" _r0084 = _coeffs.x*_TMP0.xyz;\n" +" _r0084 = _r0084 + _coeffs.y*_TMP1.xyz;\n" +" _r0084 = _r0084 + _coeffs.z*_TMP2.xyz;\n" +" _r0084 = _r0084 + _coeffs.w*_TMP3.xyz;\n" +" _TMP36 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _r0084);\n" +" _TMP87 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP36);\n" +" _r0094 = _coeffs.x*_TMP4.xyz;\n" +" _r0094 = _r0094 + _coeffs.y*_TMP5.xyz;\n" +" _r0094 = _r0094 + _coeffs.z*_TMP6.xyz;\n" +" _r0094 = _r0094 + _coeffs.w*_TMP7.xyz;\n" +" _TMP36 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _r0094);\n" +" _TMP97 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP36);\n" +" _TMP26 = pow(_TMP87.x, 4.00000000E+00);\n" +" _TMP27 = pow(_TMP87.y, 4.00000000E+00);\n" +" _TMP28 = pow(_TMP87.z, 4.00000000E+00);\n" +" _TMP13 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _wid = 2.00000000E+00*_TMP13 + 2.00000000E+00;\n" +" _TMP26 = pow(_TMP97.x, 4.00000000E+00);\n" +" _TMP27 = pow(_TMP97.y, 4.00000000E+00);\n" +" _TMP28 = pow(_TMP97.z, 4.00000000E+00);\n" +" _TMP14 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _wid2 = 2.00000000E+00*_TMP14 + 2.00000000E+00;\n" +" _TMP26 = pow(_TMP87.x, 2.70000005E+00);\n" +" _TMP27 = pow(_TMP87.y, 2.70000005E+00);\n" +" _TMP28 = pow(_TMP87.z, 2.70000005E+00);\n" +" _col = vec3(_TMP26, _TMP27, _TMP28);\n" +" _TMP26 = pow(_TMP97.x, 2.70000005E+00);\n" +" _TMP27 = pow(_TMP97.y, 2.70000005E+00);\n" +" _TMP28 = pow(_TMP97.z, 2.70000005E+00);\n" +" _col2 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _x0136 = 5.00000000E-01*_wid;\n" +" _TMP29 = inversesqrt(_x0136.x);\n" +" _TMP30 = inversesqrt(_x0136.y);\n" +" _TMP31 = inversesqrt(_x0136.z);\n" +" _sqrt1 = vec3(_TMP29, _TMP30, _TMP31);\n" +" _x0144 = 5.00000000E-01*_wid2;\n" +" _TMP29 = inversesqrt(_x0144.x);\n" +" _TMP30 = inversesqrt(_x0144.y);\n" +" _TMP31 = inversesqrt(_x0144.z);\n" +" _sqrt2 = vec3(_TMP29, _TMP30, _TMP31);\n" +" _pow_mul1 = _weights*_sqrt1;\n" +" _pow_mul2 = _weights2*_sqrt2;\n" +" _div1 = 1.31999999E-01*_wid + 3.91999990E-01;\n" +" _div2 = 1.31999999E-01*_wid2 + 3.91999990E-01;\n" +" _TMP26 = pow(_pow_mul1.x, _wid.x);\n" +" _TMP27 = pow(_pow_mul1.y, _wid.y);\n" +" _TMP28 = pow(_pow_mul1.z, _wid.z);\n" +" _TMP15 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _pow1 = -_TMP15;\n" +" _TMP26 = pow(_pow_mul2.x, _wid2.x);\n" +" _TMP27 = pow(_pow_mul2.y, _wid2.y);\n" +" _TMP28 = pow(_pow_mul2.z, _wid2.z);\n" +" _TMP16 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _pow2 = -_TMP16;\n" +" _TMP26 = pow(2.71828198E+00, _pow1.x);\n" +" _TMP27 = pow(2.71828198E+00, _pow1.y);\n" +" _TMP28 = pow(2.71828198E+00, _pow1.z);\n" +" _TMP167 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _weights = _TMP167/_div1;\n" +" _TMP26 = pow(2.71828198E+00, _pow2.x);\n" +" _TMP27 = pow(2.71828198E+00, _pow2.y);\n" +" _TMP28 = pow(2.71828198E+00, _pow2.z);\n" +" _TMP177 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _weights2 = _TMP177/_div2;\n" +" _multi = _col*_weights + _col2*_weights2;\n" +" _a0190 = VARmod_factor/2.00000000E+00;\n" +" _TMP32 = abs(_a0190);\n" +" _TMP33 = fract(_TMP32);\n" +" _TMP34 = abs(2.00000000E+00);\n" +" VARc0188 = _TMP33*_TMP34;\n" +" if (VARmod_factor < 0.00000000E+00) { \n" +" _TMP35 = -VARc0188;\n" +" } else {\n" +" _TMP35 = VARc0188;\n" +" } \n" +" _TMP20 = floor(_TMP35);\n" +" _mcol = vec3( 1.00000000E+00, 6.99999988E-01, 1.00000000E+00) + _TMP20*vec3( -3.00000012E-01, 3.00000012E-01, -3.00000012E-01);\n" +" _a0200 = _mcol*_multi;\n" +" _TMP26 = pow(_a0200.x, 4.54544991E-01);\n" +" _TMP27 = pow(_a0200.y, 4.54544991E-01);\n" +" _TMP28 = pow(_a0200.z, 4.54544991E-01);\n" +" _TMP21 = vec3(_TMP26, _TMP27, _TMP28);\n" +" _ret_0 = vec4(_TMP21.x, _TMP21.y, _TMP21.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-easymode-halation/blur_horiz.h b/src/video/sdl/shaders/crt/crt-easymode-halation/blur_horiz.h new file mode 100644 index 000000000..0f6c45a15 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-easymode-halation/blur_horiz.h @@ -0,0 +1,123 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP1;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP5;\n" +"float _x0006;\n" +"vec2 _c0010;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _col;\n" +" float _dx;\n" +" float _k_total;\n" +" int _i1;\n" +" vec3 _TMP4;\n" +" _col = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _dx = 1.00000000E+00/TextureSize.x;\n" +" _k_total = 0.00000000E+00;\n" +" _i1 = -4;\n" +" for (; _i1 <= 4; _i1 = _i1 + 1) { \n" +" _x0006 = float((-3.49999994E-01*float(_i1)*float(_i1)));\n" +" _TMP5 = pow(2.71828198E+00, _x0006);\n" +" _k_total = _k_total + _TMP5;\n" +" _c0010 = TEX0.xy + vec2(float(_i1)*_dx, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0010);\n" +" _col = _col + _TMP5*_TMP1.xyz;\n" +" } \n" +" _TMP4 = _col/_k_total;\n" +" _ret_0 = vec4(_TMP4.x, _TMP4.y, _TMP4.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-easymode-halation/blur_vert.h b/src/video/sdl/shaders/crt/crt-easymode-halation/blur_vert.h new file mode 100644 index 000000000..69ed8a0bd --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-easymode-halation/blur_vert.h @@ -0,0 +1,123 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP1;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP5;\n" +"float _x0006;\n" +"vec2 _c0010;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _col;\n" +" float _dy;\n" +" float _k_total;\n" +" int _i1;\n" +" vec3 _TMP4;\n" +" _col = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _dy = 1.00000000E+00/TextureSize.y;\n" +" _k_total = 0.00000000E+00;\n" +" _i1 = -4;\n" +" for (; _i1 <= 4; _i1 = _i1 + 1) { \n" +" _x0006 = float((-3.49999994E-01*float(_i1)*float(_i1)));\n" +" _TMP5 = pow(2.71828198E+00, _x0006);\n" +" _k_total = _k_total + _TMP5;\n" +" _c0010 = TEX0.xy + vec2(0.00000000E+00, float(_i1)*_dy);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0010);\n" +" _col = _col + _TMP5*_TMP1.xyz;\n" +" } \n" +" _TMP4 = _col/_k_total;\n" +" _ret_0 = vec4(_TMP4.x, _TMP4.y, _TMP4.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-easymode-halation/crt-easymode-halation.h b/src/video/sdl/shaders/crt/crt-easymode-halation/crt-easymode-halation.h new file mode 100644 index 000000000..320359424 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-easymode-halation/crt-easymode-halation.h @@ -0,0 +1,521 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct prev {\n" +"float _placeholder26;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct prev {\n" +"float _placeholder33;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP52;\n" +"float _TMP51;\n" +"float _TMP50;\n" +"vec3 _TMP56;\n" +"float _TMP49;\n" +"float _TMP48;\n" +"float _TMP47;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"float _TMP31;\n" +"float _TMP21;\n" +"float _TMP20;\n" +"float _TMP18;\n" +"float _TMP17;\n" +"vec4 _TMP16;\n" +"vec4 _TMP55;\n" +"vec4 _TMP46;\n" +"vec4 _TMP45;\n" +"vec4 _TMP44;\n" +"vec4 _TMP43;\n" +"float _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"float _TMP42;\n" +"float _TMP41;\n" +"float _TMP40;\n" +"float _TMP39;\n" +"vec4 _TMP7;\n" +"float _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"float _TMP38;\n" +"float _TMP37;\n" +"float _TMP53;\n" +"vec2 _TMP2;\n" +"float _TMP36;\n" +"float _TMP54;\n" +"float _TMP35;\n" +"float _TMP34;\n" +"vec2 _TMP33;\n" +"vec2 _TMP32;\n" +"float _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"prev _PASSPREV41;\n" +"float _x0065;\n" +"vec2 _co0067;\n" +"vec2 _co_weight0067;\n" +"vec2 _t0069;\n" +"vec2 _co0071;\n" +"vec2 _co_weight0071;\n" +"vec2 _t0073;\n" +"vec2 _co0075;\n" +"float _corner_weight0075;\n" +"vec2 _b0077;\n" +"float _x0087;\n" +"float _TMP88;\n" +"float _TMP104;\n" +"float _x_step0105;\n" +"float _curve0105;\n" +"float _a0109;\n" +"float _val0113;\n" +"float _a0113;\n" +"float _TMP116;\n" +"float _x_step0117;\n" +"float _curve0117;\n" +"float _a0121;\n" +"float _val0125;\n" +"float _a0125;\n" +"vec4 _TMP130;\n" +"vec4 _x0145;\n" +"vec4 _TMP158;\n" +"vec4 _x0173;\n" +"vec2 _co0185;\n" +"vec2 _c0187;\n" +"vec2 _c0191;\n" +"vec2 _c0193;\n" +"vec4 _sample_min0195;\n" +"vec4 _sample_max0195;\n" +"vec4 _r0197;\n" +"vec4 _TMP202;\n" +"vec2 _c0211;\n" +"vec2 _c0215;\n" +"vec2 _c0217;\n" +"vec4 _sample_min0219;\n" +"vec4 _sample_max0219;\n" +"vec4 _r0221;\n" +"vec4 _TMP226;\n" +"vec2 _co0233;\n" +"vec2 _c0235;\n" +"vec2 _c0239;\n" +"vec2 _c0241;\n" +"vec4 _sample_min0243;\n" +"vec4 _sample_max0243;\n" +"vec4 _r0245;\n" +"vec4 _TMP250;\n" +"vec2 _co0257;\n" +"vec2 _c0259;\n" +"vec2 _c0263;\n" +"vec2 _c0265;\n" +"vec4 _sample_min0267;\n" +"vec4 _sample_max0267;\n" +"vec4 _r0269;\n" +"vec4 _TMP274;\n" +"vec4 _sample_min0281;\n" +"vec4 _sample_max0281;\n" +"vec4 _r0283;\n" +"vec4 _TMP288;\n" +"float _TMP302;\n" +"vec2 _x0313;\n" +"float _x0321;\n" +"float _x0323;\n" +"float _x0327;\n" +"float _x0329;\n" +"float _x0331;\n" +"float _t0335;\n" +"float _t0337;\n" +"float _TMP342;\n" +"float _pos0351;\n" +"float _weight0351;\n" +"float _a0353;\n" +"float _x0355;\n" +"vec3 _x0357;\n" +"vec3 _TMP358;\n" +"float _weight0365;\n" +"float _a0367;\n" +"float _x0369;\n" +"vec3 _x0371;\n" +"vec3 _TMP372;\n" +"float _pos0379;\n" +"float _weight0379;\n" +"float _a0381;\n" +"float _x0383;\n" +"vec3 _x0385;\n" +"vec3 _TMP386;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform sampler2D PassPrev4Texture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _tex_size;\n" +" vec2 _midpoint;\n" +" float _scan_offset;\n" +" vec2 _co4;\n" +" vec2 _xy;\n" +" vec2 _dx1;\n" +" vec2 _dy;\n" +" vec2 _pix_co;\n" +" vec2 _tex_co;\n" +" vec2 _dist;\n" +" vec3 _col1;\n" +" vec3 _col2;\n" +" vec4 _coeffs_x;\n" +" vec4 _coeffs_y;\n" +" float _rgb_max;\n" +" float _sample_offset;\n" +" float _scan_pos;\n" +" float _scan_strength;\n" +" float _mask_colors;\n" +" float _mask_dither;\n" +" vec2 _mod_fac;\n" +" int _dot_no;\n" +" int _dither;\n" +" float _mask_mul;\n" +" vec3 _mask_weight;\n" +" _tex_size = TextureSize;\n" +" _midpoint = vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _scan_offset = 0.00000000E+00;\n" +" if (InputSize.y >= 4.00000000E+02) { \n" +" _tex_size.y = TextureSize.y*5.00000000E-01;\n" +" _x0065 = float(FrameCount)/2.00000000E+00;\n" +" _TMP31 = floor(_x0065);\n" +" _TMP0 = float(FrameCount) - 2.00000000E+00*_TMP31;\n" +" if (bool(_TMP0)) { \n" +" _midpoint.y = 7.50000000E-01;\n" +" _scan_offset = 5.00000000E-01;\n" +" } else {\n" +" _midpoint.y = 2.50000000E-01;\n" +" } \n" +" } \n" +" _co4 = (TEX0.xy*_tex_size)/InputSize;\n" +" _co_weight0067 = vec2(_co4.y, _co4.x)*2.00000000E+00 - 1.00000000E+00;\n" +" _t0069 = _co_weight0067*_co_weight0067;\n" +" _co0067 = _co4 + _t0069*(_co4 - _co4);\n" +" _co_weight0071 = vec2(_co4.y, _co4.x)*2.00000000E+00 - 1.00000000E+00;\n" +" _t0073 = _co_weight0071*_co_weight0071;\n" +" _co0071 = _co4 + _t0073*(_co4 - _co4);\n" +" _b0077 = vec2( 1.00000000E+00, 1.00000000E+00) - _co0071;\n" +" _TMP32 = min(_co0071, _b0077);\n" +" _co0075 = _TMP32*vec2( 1.00000000E+00, 7.50000000E-01);\n" +" _TMP33 = min(_co0075, vec2( 0.00000000E+00, 0.00000000E+00));\n" +" _co0075 = vec2( 0.00000000E+00, 0.00000000E+00) - _TMP33;\n" +" _TMP34 = dot(_co0075, _co0075);\n" +" _TMP53 = inversesqrt(_TMP34);\n" +" _TMP35 = 1.00000000E+00/_TMP53;\n" +" _x0087 = (0.00000000E+00 - _TMP35)*1.50000000E+02;\n" +" _TMP47 = min(1.00000000E+00, _x0087);\n" +" _TMP88 = max(0.00000000E+00, _TMP47);\n" +" _TMP54 = floor(-0.00000000E+00);\n" +" _TMP36 = -_TMP54;\n" +" _corner_weight0075 = 1.00000000E+00 + _TMP36*(_TMP88 - 1.00000000E+00);\n" +" _xy = _co0067*(InputSize/_tex_size);\n" +" _dx1 = vec2(1.00000000E+00/TextureSize.x, 0.00000000E+00);\n" +" _dy = vec2(0.00000000E+00, 1.00000000E+00/_tex_size.y);\n" +" _pix_co = _xy*_tex_size - _midpoint;\n" +" _TMP2 = floor(_pix_co);\n" +" _tex_co = (_TMP2 + _midpoint)/_tex_size;\n" +" _dist = fract(_pix_co);\n" +" _x_step0105 = float((_dist.x >= 5.00000000E-01));\n" +" _a0109 = 2.50000000E-01 - (_dist.x - _x_step0105)*(_dist.x - _x_step0105);\n" +" _TMP53 = inversesqrt(_a0109);\n" +" _TMP37 = 1.00000000E+00/_TMP53;\n" +" _a0113 = 5.00000000E-01 - _dist.x;\n" +" _val0113 = float((_a0113 > 0.00000000E+00));\n" +" _TMP38 = _val0113 - float((_a0113 < 0.00000000E+00));\n" +" _curve0105 = 5.00000000E-01 - _TMP37*_TMP38;\n" +" _TMP104 = _dist.x + 3.60000014E-01*(_curve0105 - _dist.x);\n" +" _x_step0117 = float((_dist.y >= 5.00000000E-01));\n" +" _a0121 = 2.50000000E-01 - (_dist.y - _x_step0117)*(_dist.y - _x_step0117);\n" +" _TMP53 = inversesqrt(_a0121);\n" +" _TMP37 = 1.00000000E+00/_TMP53;\n" +" _a0125 = 5.00000000E-01 - _dist.y;\n" +" _val0125 = float((_a0125 > 0.00000000E+00));\n" +" _TMP38 = _val0125 - float((_a0125 < 0.00000000E+00));\n" +" _curve0117 = 5.00000000E-01 - _TMP37*_TMP38;\n" +" _TMP116 = _dist.y + (_curve0117 - _dist.y);\n" +" _coeffs_x = 3.14159274E+00*vec4(1.00000000E+00 + _TMP104, _TMP104, 1.00000000E+00 - _TMP104, 2.00000000E+00 - _TMP104);\n" +" _coeffs_y = 3.14159274E+00*vec4(1.00000000E+00 + _TMP116, _TMP116, 1.00000000E+00 - _TMP116, 2.00000000E+00 - _TMP116);\n" +" _TMP3 = abs(_coeffs_x);\n" +" _TMP130 = max(_TMP3, vec4( 9.99999975E-06, 9.99999975E-06, 9.99999975E-06, 9.99999975E-06));\n" +" _TMP39 = sin(_TMP130.x);\n" +" _TMP40 = sin(_TMP130.y);\n" +" _TMP41 = sin(_TMP130.z);\n" +" _TMP42 = sin(_TMP130.w);\n" +" _TMP4 = vec4(_TMP39, _TMP40, _TMP41, _TMP42);\n" +" _x0145 = _TMP130/2.00000000E+00;\n" +" _TMP39 = sin(_x0145.x);\n" +" _TMP40 = sin(_x0145.y);\n" +" _TMP41 = sin(_x0145.z);\n" +" _TMP42 = sin(_x0145.w);\n" +" _TMP5 = vec4(_TMP39, _TMP40, _TMP41, _TMP42);\n" +" _coeffs_x = ((2.00000000E+00*_TMP4)*_TMP5)/(_TMP130*_TMP130);\n" +" _TMP6 = dot(_coeffs_x, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _coeffs_x = _coeffs_x/_TMP6;\n" +" _TMP7 = abs(_coeffs_y);\n" +" _TMP158 = max(_TMP7, vec4( 9.99999975E-06, 9.99999975E-06, 9.99999975E-06, 9.99999975E-06));\n" +" _TMP39 = sin(_TMP158.x);\n" +" _TMP40 = sin(_TMP158.y);\n" +" _TMP41 = sin(_TMP158.z);\n" +" _TMP42 = sin(_TMP158.w);\n" +" _TMP8 = vec4(_TMP39, _TMP40, _TMP41, _TMP42);\n" +" _x0173 = _TMP158/2.00000000E+00;\n" +" _TMP39 = sin(_x0173.x);\n" +" _TMP40 = sin(_x0173.y);\n" +" _TMP41 = sin(_x0173.z);\n" +" _TMP42 = sin(_x0173.w);\n" +" _TMP9 = vec4(_TMP39, _TMP40, _TMP41, _TMP42);\n" +" _coeffs_y = ((2.00000000E+00*_TMP8)*_TMP9)/(_TMP158*_TMP158);\n" +" _TMP10 = dot(_coeffs_y, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _coeffs_y = _coeffs_y/_TMP10;\n" +" _co0185 = _tex_co - _dy;\n" +" _c0187 = _co0185 - _dx1;\n" +" _TMP43 = COMPAT_TEXTURE(PassPrev4Texture, _c0187);\n" +" _TMP44 = COMPAT_TEXTURE(PassPrev4Texture, _co0185);\n" +" _c0191 = _co0185 + _dx1;\n" +" _TMP45 = COMPAT_TEXTURE(PassPrev4Texture, _c0191);\n" +" _c0193 = _co0185 + 2.00000000E+00*_dx1;\n" +" _TMP46 = COMPAT_TEXTURE(PassPrev4Texture, _c0193);\n" +" _r0197 = _coeffs_x.x*_TMP43;\n" +" _r0197 = _r0197 + _coeffs_x.y*_TMP44;\n" +" _r0197 = _r0197 + _coeffs_x.z*_TMP45;\n" +" _r0197 = _r0197 + _coeffs_x.w*_TMP46;\n" +" _sample_min0195 = min(_TMP44, _TMP45);\n" +" _sample_max0195 = max(_TMP44, _TMP45);\n" +" _TMP55 = min(_sample_max0195, _r0197);\n" +" _TMP202 = max(_sample_min0195, _TMP55);\n" +" _c0211 = _tex_co - _dx1;\n" +" _TMP43 = COMPAT_TEXTURE(PassPrev4Texture, _c0211);\n" +" _TMP44 = COMPAT_TEXTURE(PassPrev4Texture, _tex_co);\n" +" _c0215 = _tex_co + _dx1;\n" +" _TMP45 = COMPAT_TEXTURE(PassPrev4Texture, _c0215);\n" +" _c0217 = _tex_co + 2.00000000E+00*_dx1;\n" +" _TMP46 = COMPAT_TEXTURE(PassPrev4Texture, _c0217);\n" +" _r0221 = _coeffs_x.x*_TMP43;\n" +" _r0221 = _r0221 + _coeffs_x.y*_TMP44;\n" +" _r0221 = _r0221 + _coeffs_x.z*_TMP45;\n" +" _r0221 = _r0221 + _coeffs_x.w*_TMP46;\n" +" _sample_min0219 = min(_TMP44, _TMP45);\n" +" _sample_max0219 = max(_TMP44, _TMP45);\n" +" _TMP55 = min(_sample_max0219, _r0221);\n" +" _TMP226 = max(_sample_min0219, _TMP55);\n" +" _co0233 = _tex_co + _dy;\n" +" _c0235 = _co0233 - _dx1;\n" +" _TMP43 = COMPAT_TEXTURE(PassPrev4Texture, _c0235);\n" +" _TMP44 = COMPAT_TEXTURE(PassPrev4Texture, _co0233);\n" +" _c0239 = _co0233 + _dx1;\n" +" _TMP45 = COMPAT_TEXTURE(PassPrev4Texture, _c0239);\n" +" _c0241 = _co0233 + 2.00000000E+00*_dx1;\n" +" _TMP46 = COMPAT_TEXTURE(PassPrev4Texture, _c0241);\n" +" _r0245 = _coeffs_x.x*_TMP43;\n" +" _r0245 = _r0245 + _coeffs_x.y*_TMP44;\n" +" _r0245 = _r0245 + _coeffs_x.z*_TMP45;\n" +" _r0245 = _r0245 + _coeffs_x.w*_TMP46;\n" +" _sample_min0243 = min(_TMP44, _TMP45);\n" +" _sample_max0243 = max(_TMP44, _TMP45);\n" +" _TMP55 = min(_sample_max0243, _r0245);\n" +" _TMP250 = max(_sample_min0243, _TMP55);\n" +" _co0257 = _tex_co + 2.00000000E+00*_dy;\n" +" _c0259 = _co0257 - _dx1;\n" +" _TMP43 = COMPAT_TEXTURE(PassPrev4Texture, _c0259);\n" +" _TMP44 = COMPAT_TEXTURE(PassPrev4Texture, _co0257);\n" +" _c0263 = _co0257 + _dx1;\n" +" _TMP45 = COMPAT_TEXTURE(PassPrev4Texture, _c0263);\n" +" _c0265 = _co0257 + 2.00000000E+00*_dx1;\n" +" _TMP46 = COMPAT_TEXTURE(PassPrev4Texture, _c0265);\n" +" _r0269 = _coeffs_x.x*_TMP43;\n" +" _r0269 = _r0269 + _coeffs_x.y*_TMP44;\n" +" _r0269 = _r0269 + _coeffs_x.z*_TMP45;\n" +" _r0269 = _r0269 + _coeffs_x.w*_TMP46;\n" +" _sample_min0267 = min(_TMP44, _TMP45);\n" +" _sample_max0267 = max(_TMP44, _TMP45);\n" +" _TMP55 = min(_sample_max0267, _r0269);\n" +" _TMP274 = max(_sample_min0267, _TMP55);\n" +" _r0283 = _coeffs_y.x*_TMP202;\n" +" _r0283 = _r0283 + _coeffs_y.y*_TMP226;\n" +" _r0283 = _r0283 + _coeffs_y.z*_TMP250;\n" +" _r0283 = _r0283 + _coeffs_y.w*_TMP274;\n" +" _sample_min0281 = min(_TMP226, _TMP250);\n" +" _sample_max0281 = max(_TMP226, _TMP250);\n" +" _TMP55 = min(_sample_max0281, _r0283);\n" +" _TMP288 = max(_sample_min0281, _TMP55);\n" +" _TMP16 = COMPAT_TEXTURE(Texture, _xy);\n" +" _TMP17 = max(_TMP288.y, _TMP288.z);\n" +" _rgb_max = max(_TMP288.x, _TMP17);\n" +" _sample_offset = (InputSize.y/OutputSize.y)*5.00000000E-01;\n" +" _scan_pos = _xy.y*_tex_size.y + _scan_offset;\n" +" _scan_strength = 4.00000006E-01 + _rgb_max*-2.00000003E-01;\n" +" _TMP47 = min(1.00000000E+00, _rgb_max);\n" +" _TMP302 = max(1.00000000E+00, _TMP47);\n" +" _mask_colors = floor(3.09999990E+00);\n" +" _TMP18 = fract(3.09999990E+00);\n" +" _mask_dither = _TMP18*1.00000000E+01;\n" +" _x0313 = (TEX0.xy*OutputSize*TextureSize)/InputSize;\n" +" _mod_fac = floor(_x0313);\n" +" _x0321 = _mod_fac.x/_mask_colors;\n" +" _TMP31 = floor(_x0321);\n" +" _TMP20 = _mod_fac.x - _mask_colors*_TMP31;\n" +" _dot_no = int(_TMP20);\n" +" _x0323 = _mod_fac.x/_mask_colors;\n" +" _TMP21 = floor(_x0323);\n" +" _x0327 = _TMP21/2.00000000E+00;\n" +" _TMP31 = floor(_x0327);\n" +" _TMP22 = _TMP21 - 2.00000000E+00*_TMP31;\n" +" _x0329 = _mod_fac.y + _TMP22;\n" +" _x0331 = _x0329/2.00000000E+00;\n" +" _TMP31 = floor(_x0331);\n" +" _TMP23 = _x0329 - 2.00000000E+00*_TMP31;\n" +" _dither = int(_TMP23);\n" +" if (_dot_no == 0) { \n" +" _t0335 = _mask_colors - 2.00000000E+00;\n" +" _mask_weight = vec3( 1.39999998E+00, 1.39999998E+00, 1.39999998E+00) + _t0335*vec3( 0.00000000E+00, -5.99999964E-01, -5.99999964E-01);\n" +" } else {\n" +" if (_dot_no == 1) { \n" +" _t0337 = _mask_colors - 2.00000000E+00;\n" +" _mask_weight = vec3( 8.00000012E-01, 8.00000012E-01, 8.00000012E-01) + _t0337*vec3( 0.00000000E+00, 5.99999964E-01, 0.00000000E+00);\n" +" } else {\n" +" _mask_weight = vec3( 8.00000012E-01, 8.00000012E-01, 1.39999998E+00);\n" +" } \n" +" } \n" +" if (bool(_dither)) { \n" +" _mask_mul = 8.00000012E-01;\n" +" } else {\n" +" _mask_mul = 1.39999998E+00;\n" +" } \n" +" _TMP24 = 1.00000000E+00 + _mask_dither*(_mask_mul - 1.00000000E+00);\n" +" _mask_weight = _mask_weight*_TMP24;\n" +" _TMP47 = min(1.00000000E+00, 4.00000000E+00);\n" +" _TMP342 = max(0.00000000E+00, _TMP47);\n" +" _mask_weight = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + _TMP342*(_mask_weight - vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _col2 = _TMP288.xyz*_mask_weight;\n" +" _pos0351 = _scan_pos - _sample_offset;\n" +" _a0353 = _pos0351*2.00000000E+00*3.14159274E+00;\n" +" _TMP48 = cos(_a0353);\n" +" _x0355 = _TMP48*5.00000000E-01 + 5.00000000E-01;\n" +" _TMP49 = pow(_x0355, _TMP302);\n" +" _weight0351 = 1.00000000E+00 - _TMP49;\n" +" _weight0351 = _weight0351*_scan_strength*2.00000000E+00 + (1.00000000E+00 - _scan_strength);\n" +" _x0357 = _col2*_weight0351;\n" +" _TMP56 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0357);\n" +" _TMP358 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP56);\n" +" _a0367 = _scan_pos*2.00000000E+00*3.14159274E+00;\n" +" _TMP48 = cos(_a0367);\n" +" _x0369 = _TMP48*5.00000000E-01 + 5.00000000E-01;\n" +" _TMP49 = pow(_x0369, _TMP302);\n" +" _weight0365 = 1.00000000E+00 - _TMP49;\n" +" _weight0365 = _weight0365*_scan_strength*2.00000000E+00 + (1.00000000E+00 - _scan_strength);\n" +" _x0371 = _col2*_weight0365;\n" +" _TMP56 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0371);\n" +" _TMP372 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP56);\n" +" _col1 = _TMP358 + _TMP372;\n" +" _pos0379 = _scan_pos + _sample_offset;\n" +" _a0381 = _pos0379*2.00000000E+00*3.14159274E+00;\n" +" _TMP48 = cos(_a0381);\n" +" _x0383 = _TMP48*5.00000000E-01 + 5.00000000E-01;\n" +" _TMP49 = pow(_x0383, _TMP302);\n" +" _weight0379 = 1.00000000E+00 - _TMP49;\n" +" _weight0379 = _weight0379*_scan_strength*2.00000000E+00 + (1.00000000E+00 - _scan_strength);\n" +" _x0385 = _col2*_weight0379;\n" +" _TMP56 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0385);\n" +" _TMP386 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP56);\n" +" _col1 = _col1 + _TMP386;\n" +" _col1 = _col1/3.00000000E+00;\n" +" _col1 = _col1*vec3(_corner_weight0075, _corner_weight0075, _corner_weight0075);\n" +" _col1 = _col1 + ((_TMP16.xyz*_mask_weight)*2.99999993E-02)*vec3(_corner_weight0075, _corner_weight0075, _corner_weight0075);\n" +" _TMP50 = pow(_col1.x, 4.54545438E-01);\n" +" _TMP51 = pow(_col1.y, 4.54545438E-01);\n" +" _TMP52 = pow(_col1.z, 4.54545438E-01);\n" +" _col1 = vec3(_TMP50, _TMP51, _TMP52);\n" +" _ret_0 = vec4(_col1.x, _col1.y, _col1.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-easymode-halation/linearize.h b/src/video/sdl/shaders/crt/crt-easymode-halation/linearize.h new file mode 100644 index 000000000..89c9ecf14 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-easymode-halation/linearize.h @@ -0,0 +1,92 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"vec4 _ret_0;\n" +"vec4 _TMP0;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"uniform sampler2D Texture;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP1 = pow(_TMP0.x, 2.40000010E+00);\n" +" _TMP2 = pow(_TMP0.y, 2.40000010E+00);\n" +" _TMP3 = pow(_TMP0.z, 2.40000010E+00);\n" +" _TMP4 = pow(_TMP0.w, 2.40000010E+00);\n" +" _ret_0 = vec4(_TMP1, _TMP2, _TMP3, _TMP4);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-easymode-halation/threshold.h b/src/video/sdl/shaders/crt/crt-easymode-halation/threshold.h new file mode 100644 index 000000000..32ee2a99b --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-easymode-halation/threshold.h @@ -0,0 +1,118 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct prev {\n" +"float _placeholder26;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct prev {\n" +"float _placeholder27;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"vec3 _TMP2;\n" +"uniform sampler2D Texture;\n" +"prev _PASSPREV31;\n" +"vec3 _x0012;\n" +"vec3 _TMP13;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform sampler2D PassPrev3Texture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP1 = COMPAT_TEXTURE(PassPrev3Texture, TEX0.xy);\n" +" _x0012 = _TMP0.xyz - _TMP1.xyz;\n" +" _TMP2 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0012);\n" +" _TMP13 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP2);\n" +" _ret_0 = vec4(_TMP13.x, _TMP13.y, _TMP13.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-easymode.h b/src/video/sdl/shaders/crt/crt-easymode.h new file mode 100644 index 000000000..d35a8524f --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-easymode.h @@ -0,0 +1,321 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP30;\n" +"float _TMP29;\n" +"float _TMP28;\n" +"float _TMP13;\n" +"float _TMP32;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"float _TMP31;\n" +"float _TMP9;\n" +"float _TMP8;\n" +"float _TMP15;\n" +"float _TMP14;\n" +"float _TMP33;\n" +"vec4 _TMP34;\n" +"vec4 _TMP27;\n" +"vec4 _TMP25;\n" +"vec4 _TMP23;\n" +"vec4 _TMP21;\n" +"vec4 _TMP26;\n" +"vec4 _TMP24;\n" +"vec4 _TMP22;\n" +"vec4 _TMP20;\n" +"float _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"float _TMP19;\n" +"float _TMP18;\n" +"float _TMP17;\n" +"float _TMP16;\n" +"vec4 _TMP1;\n" +"vec2 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP43;\n" +"float _x_step0044;\n" +"float _curve0044;\n" +"float _a0048;\n" +"float _val0052;\n" +"float _a0052;\n" +"vec4 _TMP57;\n" +"vec4 _x0072;\n" +"vec2 _c0086;\n" +"vec4 _x0088;\n" +"vec4 _x0094;\n" +"vec2 _c0098;\n" +"vec4 _x0100;\n" +"vec2 _c0104;\n" +"vec4 _x0106;\n" +"vec4 _sample_min0110;\n" +"vec4 _sample_max0110;\n" +"vec4 _r0112;\n" +"vec4 _TMP117;\n" +"vec2 _co0124;\n" +"vec2 _c0126;\n" +"vec4 _x0128;\n" +"vec4 _x0134;\n" +"vec2 _c0138;\n" +"vec4 _x0140;\n" +"vec2 _c0144;\n" +"vec4 _x0146;\n" +"vec4 _sample_min0150;\n" +"vec4 _sample_max0150;\n" +"vec4 _r0152;\n" +"vec4 _TMP157;\n" +"float _TMP163;\n" +"float _x_step0164;\n" +"float _curve0164;\n" +"float _a0168;\n" +"float _val0172;\n" +"float _a0172;\n" +"float _TMP183;\n" +"float _TMP189;\n" +"float _x0190;\n" +"float _a0196;\n" +"float _x0198;\n" +"vec2 _x0200;\n" +"float _x0208;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _dx1;\n" +" vec2 _dy;\n" +" vec2 _pix_co;\n" +" vec2 _tex_co;\n" +" vec2 _dist;\n" +" vec3 _col2;\n" +" vec3 _col21;\n" +" vec4 _coeffs1;\n" +" float _luma;\n" +" float _bright;\n" +" float _scan_weight;\n" +" vec2 _mod_fac;\n" +" int _dot_no;\n" +" vec3 _mask_weight;\n" +" vec3 _TMP37;\n" +" _dx1 = vec2(1.00000000E+00/TextureSize.x, 0.00000000E+00);\n" +" _dy = vec2(0.00000000E+00, 1.00000000E+00/TextureSize.y);\n" +" _pix_co = TEX0.xy*TextureSize - vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _TMP0 = floor(_pix_co);\n" +" _tex_co = (_TMP0 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize;\n" +" _dist = fract(_pix_co);\n" +" _x_step0044 = float((_dist.x >= 5.00000000E-01));\n" +" _a0048 = 2.50000000E-01 - (_dist.x - _x_step0044)*(_dist.x - _x_step0044);\n" +" _TMP33 = inversesqrt(_a0048);\n" +" _TMP14 = 1.00000000E+00/_TMP33;\n" +" _a0052 = 5.00000000E-01 - _dist.x;\n" +" _val0052 = float((_a0052 > 0.00000000E+00));\n" +" _TMP15 = _val0052 - float((_a0052 < 0.00000000E+00));\n" +" _curve0044 = 5.00000000E-01 - _TMP14*_TMP15;\n" +" _TMP43 = _dist.x + 2.50000000E-01*(_curve0044 - _dist.x);\n" +" _coeffs1 = 3.14159274E+00*vec4(1.00000000E+00 + _TMP43, _TMP43, 1.00000000E+00 - _TMP43, 2.00000000E+00 - _TMP43);\n" +" _TMP1 = abs(_coeffs1);\n" +" _TMP57 = max(_TMP1, vec4( 9.99999975E-06, 9.99999975E-06, 9.99999975E-06, 9.99999975E-06));\n" +" _TMP16 = sin(_TMP57.x);\n" +" _TMP17 = sin(_TMP57.y);\n" +" _TMP18 = sin(_TMP57.z);\n" +" _TMP19 = sin(_TMP57.w);\n" +" _TMP2 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _x0072 = _TMP57/2.00000000E+00;\n" +" _TMP16 = sin(_x0072.x);\n" +" _TMP17 = sin(_x0072.y);\n" +" _TMP18 = sin(_x0072.z);\n" +" _TMP19 = sin(_x0072.w);\n" +" _TMP3 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _coeffs1 = ((2.00000000E+00*_TMP2)*_TMP3)/(_TMP57*_TMP57);\n" +" _TMP4 = dot(_coeffs1, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _coeffs1 = _coeffs1/_TMP4;\n" +" _c0086 = _tex_co - _dx1;\n" +" _TMP20 = COMPAT_TEXTURE(Texture, _c0086);\n" +" _x0088 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP20 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP21 = _TMP20*_x0088;\n" +" _TMP22 = COMPAT_TEXTURE(Texture, _tex_co);\n" +" _x0094 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP22 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP23 = _TMP22*_x0094;\n" +" _c0098 = _tex_co + _dx1;\n" +" _TMP24 = COMPAT_TEXTURE(Texture, _c0098);\n" +" _x0100 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP24 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP25 = _TMP24*_x0100;\n" +" _c0104 = _tex_co + 2.00000000E+00*_dx1;\n" +" _TMP26 = COMPAT_TEXTURE(Texture, _c0104);\n" +" _x0106 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP26 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP27 = _TMP26*_x0106;\n" +" _r0112 = _coeffs1.x*_TMP21;\n" +" _r0112 = _r0112 + _coeffs1.y*_TMP23;\n" +" _r0112 = _r0112 + _coeffs1.z*_TMP25;\n" +" _r0112 = _r0112 + _coeffs1.w*_TMP27;\n" +" _sample_min0110 = min(_TMP23, _TMP25);\n" +" _sample_max0110 = max(_TMP23, _TMP25);\n" +" _TMP34 = min(_sample_max0110, _r0112);\n" +" _TMP117 = max(_sample_min0110, _TMP34);\n" +" _co0124 = _tex_co + _dy;\n" +" _c0126 = _co0124 - _dx1;\n" +" _TMP20 = COMPAT_TEXTURE(Texture, _c0126);\n" +" _x0128 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP20 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP21 = _TMP20*_x0128;\n" +" _TMP22 = COMPAT_TEXTURE(Texture, _co0124);\n" +" _x0134 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP22 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP23 = _TMP22*_x0134;\n" +" _c0138 = _co0124 + _dx1;\n" +" _TMP24 = COMPAT_TEXTURE(Texture, _c0138);\n" +" _x0140 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP24 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP25 = _TMP24*_x0140;\n" +" _c0144 = _co0124 + 2.00000000E+00*_dx1;\n" +" _TMP26 = COMPAT_TEXTURE(Texture, _c0144);\n" +" _x0146 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP26 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP27 = _TMP26*_x0146;\n" +" _r0152 = _coeffs1.x*_TMP21;\n" +" _r0152 = _r0152 + _coeffs1.y*_TMP23;\n" +" _r0152 = _r0152 + _coeffs1.z*_TMP25;\n" +" _r0152 = _r0152 + _coeffs1.w*_TMP27;\n" +" _sample_min0150 = min(_TMP23, _TMP25);\n" +" _sample_max0150 = max(_TMP23, _TMP25);\n" +" _TMP34 = min(_sample_max0150, _r0152);\n" +" _TMP157 = max(_sample_min0150, _TMP34);\n" +" _x_step0164 = float((_dist.y >= 5.00000000E-01));\n" +" _a0168 = 2.50000000E-01 - (_dist.y - _x_step0164)*(_dist.y - _x_step0164);\n" +" _TMP33 = inversesqrt(_a0168);\n" +" _TMP14 = 1.00000000E+00/_TMP33;\n" +" _a0172 = 5.00000000E-01 - _dist.y;\n" +" _val0172 = float((_a0172 > 0.00000000E+00));\n" +" _TMP15 = _val0172 - float((_a0172 < 0.00000000E+00));\n" +" _curve0164 = 5.00000000E-01 - _TMP14*_TMP15;\n" +" _TMP163 = _dist.y + (_curve0164 - _dist.y);\n" +" _col2 = _TMP117.xyz + _TMP163*(_TMP157.xyz - _TMP117.xyz);\n" +" _luma = dot(vec3( 2.12599993E-01, 7.15200007E-01, 7.22000003E-02), _col2);\n" +" _TMP8 = max(_col2.y, _col2.z);\n" +" _TMP9 = max(_col2.x, _TMP8);\n" +" _bright = (_TMP9 + _luma)/2.00000000E+00;\n" +" _TMP31 = min(6.49999976E-01, _bright);\n" +" _TMP183 = max(3.49999994E-01, _TMP31);\n" +" _x0190 = _bright*1.50000000E+00;\n" +" _TMP31 = min(1.50000000E+00, _x0190);\n" +" _TMP189 = max(1.50000000E+00, _TMP31);\n" +" _a0196 = TEX0.y*2.00000000E+00*3.14159274E+00*TextureSize.y;\n" +" _TMP10 = cos(_a0196);\n" +" _x0198 = _TMP10*5.00000000E-01 + 5.00000000E-01;\n" +" _TMP11 = pow(_x0198, _TMP189);\n" +" _scan_weight = 1.00000000E+00 - _TMP11;\n" +" _x0200 = (TEX0.xy*OutputSize*TextureSize)/InputSize;\n" +" _mod_fac = floor(_x0200);\n" +" _x0208 = _mod_fac.x/3.00000000E+00;\n" +" _TMP32 = floor(_x0208);\n" +" _TMP13 = _mod_fac.x - 3.00000000E+00*_TMP32;\n" +" _dot_no = int(_TMP13);\n" +" if (_dot_no == 0) { \n" +" _mask_weight = vec3( 1.00000000E+00, 6.99999988E-01, 6.99999988E-01);\n" +" } else {\n" +" if (_dot_no == 1) { \n" +" _mask_weight = vec3( 6.99999988E-01, 1.00000000E+00, 6.99999988E-01);\n" +" } else {\n" +" _mask_weight = vec3( 6.99999988E-01, 6.99999988E-01, 1.00000000E+00);\n" +" } \n" +" } \n" +" if (InputSize.y >= 4.00000000E+02) { \n" +" _scan_weight = 1.00000000E+00;\n" +" } \n" +" _col21 = _col2.xyz;\n" +" _col2 = _col2*vec3(_scan_weight, _scan_weight, _scan_weight);\n" +" _col2 = _col2 + _TMP183*(_col21 - _col2);\n" +" _col2 = _col2*_mask_weight;\n" +" _TMP28 = pow(_col2.x, 5.55555582E-01);\n" +" _TMP29 = pow(_col2.y, 5.55555582E-01);\n" +" _TMP30 = pow(_col2.z, 5.55555582E-01);\n" +" _col2 = vec3(_TMP28, _TMP29, _TMP30);\n" +" _TMP37 = _col2*1.20000005E+00;\n" +" _ret_0 = vec4(_TMP37.x, _TMP37.y, _TMP37.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-geom.h b/src/video/sdl/shaders/crt/crt-geom.h new file mode 100644 index 000000000..d3e87c8b9 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-geom.h @@ -0,0 +1,883 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARTextureSize;\n" +"COMPAT_VARYING vec2 VARcosangle;\n" +"COMPAT_VARYING vec2 VARsinangle;\n" +"COMPAT_VARYING vec3 VARstretch;\n" +"COMPAT_VARYING vec2 VARilfac;\n" +"COMPAT_VARYING float VARmod_factor;\n" +"COMPAT_VARYING vec2 VARone;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct input_dummy {\n" +" vec2 _tex_coord;\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord1;\n" +" vec2 VARone;\n" +" float VARmod_factor;\n" +" vec2 VARilfac;\n" +" vec3 VARstretch;\n" +" vec2 VARsinangle;\n" +" vec2 VARcosangle;\n" +" vec2 VARTextureSize;\n" +"};\n" +"out_vertex _ret_0;\n" +"float _TMP1;\n" +"float _TMP12;\n" +"float _TMP11;\n" +"vec2 _TMP10;\n" +"vec2 _TMP9;\n" +"float _TMP25;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"float _TMP21;\n" +"float _TMP20;\n" +"float _TMP29;\n" +"vec2 _TMP8;\n" +"vec2 _TMP7;\n" +"float _TMP19;\n" +"float _TMP18;\n" +"float _TMP17;\n" +"float _TMP30;\n" +"float _TMP16;\n" +"float _TMP15;\n" +"float _TMP14;\n" +"float _TMP13;\n" +"float _TMP28;\n" +"float _TMP27;\n" +"float _TMP26;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"input_dummy _IN1;\n" +"vec4 _r0037;\n" +"vec2 _c0051;\n" +"vec2 _lo0051;\n" +"vec2 _hi0051;\n" +"vec2 _TMP330051;\n" +"float _c0053;\n" +"vec2 _xy0053;\n" +"vec2 _point0053;\n" +"vec2 _tang0053;\n" +"vec2 _poc0053;\n" +"float _A0053;\n" +"float _B0053;\n" +"float _C0053;\n" +"float _a0053;\n" +"vec2 _uv0053;\n" +"float _r0053;\n" +"float _A0055;\n" +"float _B0055;\n" +"float _C0055;\n" +"float _a0061;\n" +"float _a0071;\n" +"float _negate0075;\n" +"float _x0075;\n" +"float _ret0075;\n" +"float _a0079;\n" +"float _a0083;\n" +"float _a0087;\n" +"vec2 _uv0089;\n" +"float _r0089;\n" +"float _x0089;\n" +"float _D0089;\n" +"float _a0101;\n" +"float _a0103;\n" +"vec2 _uv0107;\n" +"float _r0107;\n" +"float _x0107;\n" +"float _D0107;\n" +"float _a0119;\n" +"float _a0121;\n" +"vec2 _uv0125;\n" +"float _r0125;\n" +"float _x0125;\n" +"float _D0125;\n" +"float _a0137;\n" +"float _a0139;\n" +"vec2 _uv0143;\n" +"float _r0143;\n" +"float _x0143;\n" +"float _D0143;\n" +"float _a0155;\n" +"float _a0157;\n" +"float _a0161;\n" +"float _b0161;\n" +"float _x0163;\n" +"float _TMP164;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" _r0037 = VertexCoord.x*MVPMatrix[0];\n" +" _r0037 = _r0037 + VertexCoord.y*MVPMatrix[1];\n" +" _r0037 = _r0037 + VertexCoord.z*MVPMatrix[2];\n" +" _r0037 = _r0037 + VertexCoord.w*MVPMatrix[3];\n" +" _TMP3 = sin(0.00000000E+00);\n" +" _TMP4 = sin(0.00000000E+00);\n" +" _OUT.VARsinangle = vec2(_TMP3, _TMP4);\n" +" _TMP5 = cos(0.00000000E+00);\n" +" _TMP6 = cos(0.00000000E+00);\n" +" _OUT.VARcosangle = vec2(_TMP5, _TMP6);\n" +" _xy0053 = (-2.00000000E+00*_OUT.VARsinangle)/(1.00000000E+00 + 1.33333337E+00*_OUT.VARcosangle.x*_OUT.VARcosangle.y);\n" +" _TMP26 = dot(_xy0053, _xy0053);\n" +" _A0055 = _TMP26 + 2.25000000E+00;\n" +" _TMP27 = dot(_xy0053, _OUT.VARsinangle);\n" +" _B0055 = 2.00000000E+00*(2.00000000E+00*(_TMP27 - 1.50000000E+00*_OUT.VARcosangle.x*_OUT.VARcosangle.y) - 2.25000000E+00);\n" +" _C0055 = 2.25000000E+00 + 6.00000000E+00*_OUT.VARcosangle.x*_OUT.VARcosangle.y;\n" +" _a0061 = _B0055*_B0055 - 4.00000000E+00*_A0055*_C0055;\n" +" _TMP29 = inversesqrt(_a0061);\n" +" _TMP28 = 1.00000000E+00/_TMP29;\n" +" _c0053 = (-_B0055 - _TMP28)/(2.00000000E+00*_A0055);\n" +" _point0053 = vec2(_c0053, _c0053)*_xy0053;\n" +" _point0053 = _point0053 - vec2( -2.00000000E+00, -2.00000000E+00)*_OUT.VARsinangle;\n" +" _point0053 = _point0053/vec2( 2.00000000E+00, 2.00000000E+00);\n" +" _tang0053 = _OUT.VARsinangle/_OUT.VARcosangle;\n" +" _poc0053 = _point0053/_OUT.VARcosangle;\n" +" _TMP13 = dot(_tang0053, _tang0053);\n" +" _A0053 = _TMP13 + 1.00000000E+00;\n" +" _TMP14 = dot(_poc0053, _tang0053);\n" +" _B0053 = -2.00000000E+00*_TMP14;\n" +" _TMP15 = dot(_poc0053, _poc0053);\n" +" _C0053 = _TMP15 - 1.00000000E+00;\n" +" _a0071 = _B0053*_B0053 - 4.00000000E+00*_A0053*_C0053;\n" +" _TMP29 = inversesqrt(_a0071);\n" +" _TMP16 = 1.00000000E+00/_TMP29;\n" +" _a0053 = (-_B0053 + _TMP16)/(2.00000000E+00*_A0053);\n" +" _uv0053 = (_point0053 - _a0053*_OUT.VARsinangle)/_OUT.VARcosangle;\n" +" _negate0075 = float((_a0053 < 0.00000000E+00));\n" +" _x0075 = abs(_a0053);\n" +" _ret0075 = -1.87292993E-02*_x0075;\n" +" _ret0075 = _ret0075 + 7.42610022E-02;\n" +" _ret0075 = _ret0075*_x0075;\n" +" _ret0075 = _ret0075 - 2.12114394E-01;\n" +" _ret0075 = _ret0075*_x0075;\n" +" _ret0075 = _ret0075 + 1.57072902E+00;\n" +" _a0079 = 1.00000000E+00 - _x0075;\n" +" _TMP29 = inversesqrt(_a0079);\n" +" _TMP30 = 1.00000000E+00/_TMP29;\n" +" _ret0075 = _ret0075*_TMP30;\n" +" _ret0075 = _ret0075 - 2.00000000E+00*_negate0075*_ret0075;\n" +" _TMP17 = _negate0075*3.14159298E+00 + _ret0075;\n" +" _a0083 = 2.00000000E+00*_TMP17;\n" +" _TMP18 = abs(_a0083);\n" +" _r0053 = max(_TMP18, 9.99999975E-06);\n" +" _a0087 = _r0053/2.00000000E+00;\n" +" _TMP19 = sin(_a0087);\n" +" _c0051 = (_uv0053*_r0053)/_TMP19;\n" +" _uv0089 = vec2(-5.00000000E-01, _c0051.y);\n" +" _TMP20 = dot(_uv0089, _uv0089);\n" +" _TMP29 = inversesqrt(_TMP20);\n" +" _TMP21 = 1.00000000E+00/_TMP29;\n" +" _TMP22 = abs(_TMP21);\n" +" _r0089 = max(_TMP22, 9.99999975E-06);\n" +" _a0101 = _r0089/2.00000000E+00;\n" +" _TMP23 = sin(_a0101);\n" +" _uv0089 = _uv0089*(_TMP23/_r0089);\n" +" _a0103 = _r0089/2.00000000E+00;\n" +" _TMP24 = cos(_a0103);\n" +" _x0089 = 1.00000000E+00 - _TMP24;\n" +" _TMP25 = dot(_uv0089, _OUT.VARsinangle);\n" +" _D0089 = 7.50000000E-01 + _x0089*_OUT.VARcosangle.x*_OUT.VARcosangle.y + _TMP25;\n" +" _TMP7 = (1.50000000E+00*(_uv0089*_OUT.VARcosangle - _x0089*_OUT.VARsinangle))/_D0089;\n" +" _uv0107 = vec2(_c0051.x, -3.75000000E-01);\n" +" _TMP20 = dot(_uv0107, _uv0107);\n" +" _TMP29 = inversesqrt(_TMP20);\n" +" _TMP21 = 1.00000000E+00/_TMP29;\n" +" _TMP22 = abs(_TMP21);\n" +" _r0107 = max(_TMP22, 9.99999975E-06);\n" +" _a0119 = _r0107/2.00000000E+00;\n" +" _TMP23 = sin(_a0119);\n" +" _uv0107 = _uv0107*(_TMP23/_r0107);\n" +" _a0121 = _r0107/2.00000000E+00;\n" +" _TMP24 = cos(_a0121);\n" +" _x0107 = 1.00000000E+00 - _TMP24;\n" +" _TMP25 = dot(_uv0107, _OUT.VARsinangle);\n" +" _D0107 = 7.50000000E-01 + _x0107*_OUT.VARcosangle.x*_OUT.VARcosangle.y + _TMP25;\n" +" _TMP8 = (1.50000000E+00*(_uv0107*_OUT.VARcosangle - _x0107*_OUT.VARsinangle))/_D0107;\n" +" _lo0051 = vec2(_TMP7.x, _TMP8.y)/vec2( 1.00000000E+00, 7.50000000E-01);\n" +" _uv0125 = vec2(5.00000000E-01, _c0051.y);\n" +" _TMP20 = dot(_uv0125, _uv0125);\n" +" _TMP29 = inversesqrt(_TMP20);\n" +" _TMP21 = 1.00000000E+00/_TMP29;\n" +" _TMP22 = abs(_TMP21);\n" +" _r0125 = max(_TMP22, 9.99999975E-06);\n" +" _a0137 = _r0125/2.00000000E+00;\n" +" _TMP23 = sin(_a0137);\n" +" _uv0125 = _uv0125*(_TMP23/_r0125);\n" +" _a0139 = _r0125/2.00000000E+00;\n" +" _TMP24 = cos(_a0139);\n" +" _x0125 = 1.00000000E+00 - _TMP24;\n" +" _TMP25 = dot(_uv0125, _OUT.VARsinangle);\n" +" _D0125 = 7.50000000E-01 + _x0125*_OUT.VARcosangle.x*_OUT.VARcosangle.y + _TMP25;\n" +" _TMP9 = (1.50000000E+00*(_uv0125*_OUT.VARcosangle - _x0125*_OUT.VARsinangle))/_D0125;\n" +" _uv0143 = vec2(_c0051.x, 3.75000000E-01);\n" +" _TMP20 = dot(_uv0143, _uv0143);\n" +" _TMP29 = inversesqrt(_TMP20);\n" +" _TMP21 = 1.00000000E+00/_TMP29;\n" +" _TMP22 = abs(_TMP21);\n" +" _r0143 = max(_TMP22, 9.99999975E-06);\n" +" _a0155 = _r0143/2.00000000E+00;\n" +" _TMP23 = sin(_a0155);\n" +" _uv0143 = _uv0143*(_TMP23/_r0143);\n" +" _a0157 = _r0143/2.00000000E+00;\n" +" _TMP24 = cos(_a0157);\n" +" _x0143 = 1.00000000E+00 - _TMP24;\n" +" _TMP25 = dot(_uv0143, _OUT.VARsinangle);\n" +" _D0143 = 7.50000000E-01 + _x0143*_OUT.VARcosangle.x*_OUT.VARcosangle.y + _TMP25;\n" +" _TMP10 = (1.50000000E+00*(_uv0143*_OUT.VARcosangle - _x0143*_OUT.VARsinangle))/_D0143;\n" +" _hi0051 = vec2(_TMP9.x, _TMP10.y)/vec2( 1.00000000E+00, 7.50000000E-01);\n" +" _a0161 = _hi0051.x - _lo0051.x;\n" +" _b0161 = _hi0051.y - _lo0051.y;\n" +" _TMP11 = max(_a0161, _b0161);\n" +" _TMP330051 = ((_hi0051 + _lo0051)*vec2( 1.00000000E+00, 7.50000000E-01))*5.00000000E-01;\n" +" _OUT.VARstretch = vec3(_TMP330051.x, _TMP330051.y, _TMP11);\n" +" _OUT.VARTextureSize = vec2(TextureSize.x, TextureSize.y);\n" +" _x0163 = InputSize.y/2.00000000E+02;\n" +" _TMP1 = floor(_x0163);\n" +" _TMP12 = min(2.00000000E+00, _TMP1);\n" +" _TMP164 = max(1.00000000E+00, _TMP12);\n" +" _OUT.VARilfac = vec2(1.00000000E+00, _TMP164);\n" +" _OUT.VARone = _OUT.VARilfac/_OUT.VARTextureSize;\n" +" _OUT.VARmod_factor = (TexCoord.x*TextureSize.x*OutputSize.x)/InputSize.x;\n" +" _ret_0._position1 = _r0037;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" VARone = _OUT.VARone;\n" +" VARmod_factor = _OUT.VARmod_factor;\n" +" VARilfac = _OUT.VARilfac;\n" +" VARstretch = _OUT.VARstretch;\n" +" VARsinangle = _OUT.VARsinangle;\n" +" VARcosangle = _OUT.VARcosangle;\n" +" VARTextureSize = _OUT.VARTextureSize;\n" +" gl_Position = _r0037;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARTextureSize;\n" +"COMPAT_VARYING vec2 VARcosangle;\n" +"COMPAT_VARYING vec2 VARsinangle;\n" +"COMPAT_VARYING vec3 VARstretch;\n" +"COMPAT_VARYING vec2 VARilfac;\n" +"COMPAT_VARYING float VARmod_factor;\n" +"COMPAT_VARYING vec2 VARone;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct input_dummy {\n" +" vec2 _tex_coord;\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color1;\n" +" vec2 _texCoord;\n" +" vec2 VARone;\n" +" float VARmod_factor;\n" +" vec2 VARilfac;\n" +" vec3 VARstretch;\n" +" vec2 VARsinangle;\n" +" vec2 VARcosangle;\n" +" vec2 VARTextureSize;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP65;\n" +"float _TMP64;\n" +"float _TMP63;\n" +"float _TMP36;\n" +"float _TMP49;\n" +"float _TMP48;\n" +"float _TMP47;\n" +"float _TMP46;\n" +"vec4 _TMP34;\n" +"float _TMP33;\n" +"vec4 _TMP61;\n" +"float _TMP57;\n" +"float _TMP56;\n" +"float _TMP55;\n" +"float _TMP54;\n" +"vec4 _TMP60;\n" +"float _TMP73;\n" +"float _TMP72;\n" +"float _TMP71;\n" +"float _TMP70;\n" +"vec4 _TMP59;\n" +"vec4 _TMP32;\n" +"float _TMP31;\n" +"vec4 _TMP30;\n" +"float _TMP29;\n" +"vec4 _TMP28;\n" +"vec4 _TMP58;\n" +"vec4 _TMP26;\n" +"vec4 _TMP24;\n" +"vec4 _TMP22;\n" +"vec4 _TMP20;\n" +"vec4 _TMP25;\n" +"vec4 _TMP23;\n" +"vec4 _TMP21;\n" +"vec4 _TMP19;\n" +"vec4 _TMP17;\n" +"vec4 _TMP15;\n" +"vec4 _TMP13;\n" +"vec4 _TMP11;\n" +"vec4 _TMP16;\n" +"vec4 _TMP14;\n" +"vec4 _TMP12;\n" +"vec4 _TMP10;\n" +"float _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"float _TMP53;\n" +"float _TMP52;\n" +"float _TMP51;\n" +"float _TMP50;\n" +"vec4 _TMP6;\n" +"vec2 _TMP5;\n" +"float _TMP4;\n" +"float _TMP45;\n" +"float _TMP3;\n" +"float _TMP44;\n" +"vec2 _TMP2;\n" +"vec2 _TMP1;\n" +"vec2 _TMP0;\n" +"float _TMP43;\n" +"float _TMP42;\n" +"float _TMP41;\n" +"float _TMP69;\n" +"float _TMP40;\n" +"float _TMP39;\n" +"float _TMP38;\n" +"float _TMP37;\n" +"float _TMP68;\n" +"float _TMP67;\n" +"float _TMP66;\n" +"out_vertex _VAR1;\n" +"input_dummy _IN1;\n" +"uniform sampler2D Texture;\n" +"float _c0081;\n" +"vec2 _point0081;\n" +"vec2 _tang0081;\n" +"vec2 _poc0081;\n" +"float _A0081;\n" +"float _B0081;\n" +"float _C0081;\n" +"float _a0081;\n" +"vec2 _uv0081;\n" +"float _r0081;\n" +"float _A0083;\n" +"float _B0083;\n" +"float _C0083;\n" +"float _a0089;\n" +"float _a0099;\n" +"float _negate0103;\n" +"float _x0103;\n" +"float _ret0103;\n" +"float _a0107;\n" +"float _a0111;\n" +"float _a0115;\n" +"vec2 _b0117;\n" +"float _TMP126;\n" +"float _x0127;\n" +"float _c0133;\n" +"float _a0135;\n" +"vec4 _TMP146;\n" +"vec4 _x0161;\n" +"vec2 _c0173;\n" +"vec2 _c0197;\n" +"vec2 _c0209;\n" +"vec4 _r0221;\n" +"vec4 _TMP222;\n" +"vec2 _c0229;\n" +"vec2 _c0241;\n" +"vec2 _c0253;\n" +"vec2 _c0265;\n" +"vec4 _r0277;\n" +"vec4 _TMP278;\n" +"vec4 _wid0285;\n" +"vec4 _weights0285;\n" +"vec4 _x0297;\n" +"vec4 _a0307;\n" +"vec4 _TMP316;\n" +"vec4 _x0317;\n" +"vec4 _wid0329;\n" +"vec4 _weights0329;\n" +"float _distance0329;\n" +"vec4 _x0341;\n" +"vec4 _a0351;\n" +"vec4 _TMP360;\n" +"vec4 _x0361;\n" +"vec4 _wid0373;\n" +"vec4 _weights0373;\n" +"vec4 _x0385;\n" +"vec4 _a0395;\n" +"vec4 _TMP404;\n" +"vec4 _x0405;\n" +"float _a0417;\n" +"vec4 _wid0419;\n" +"vec4 _weights0419;\n" +"vec4 _x0431;\n" +"vec4 _a0441;\n" +"vec4 _TMP450;\n" +"vec4 _x0451;\n" +"vec4 _wid0465;\n" +"vec4 _weights0465;\n" +"vec4 _x0477;\n" +"vec4 _a0487;\n" +"vec4 _TMP496;\n" +"vec4 _x0497;\n" +"float _a0509;\n" +"vec4 _wid0511;\n" +"vec4 _weights0511;\n" +"vec4 _x0523;\n" +"vec4 _a0533;\n" +"vec4 _TMP542;\n" +"vec4 _x0543;\n" +"float _c0555;\n" +"float _a0557;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _xy2;\n" +" vec2 _cd1;\n" +" vec2 _cd2;\n" +" float _dist;\n" +" vec2 _ilfloat;\n" +" vec2 _ratio_scale;\n" +" float _filter;\n" +" vec2 _uv_ratio;\n" +" vec4 _coeffs;\n" +" vec4 _weights1;\n" +" vec4 _weights2;\n" +" vec3 _mul_res;\n" +" vec3 _dotMaskWeights;\n" +" _cd1 = TEX0.xy*(TextureSize/InputSize);\n" +" _cd1 = ((_cd1 - vec2( 5.00000000E-01, 5.00000000E-01))*vec2( 1.00000000E+00, 7.50000000E-01))*VARstretch.z + VARstretch.xy;\n" +" _TMP66 = dot(_cd1, _cd1);\n" +" _A0083 = _TMP66 + 2.25000000E+00;\n" +" _TMP67 = dot(_cd1, VARsinangle);\n" +" _B0083 = 2.00000000E+00*(2.00000000E+00*(_TMP67 - 1.50000000E+00*VARcosangle.x*VARcosangle.y) - 2.25000000E+00);\n" +" _C0083 = 2.25000000E+00 + 6.00000000E+00*VARcosangle.x*VARcosangle.y;\n" +" _a0089 = _B0083*_B0083 - 4.00000000E+00*_A0083*_C0083;\n" +" _TMP44 = inversesqrt(_a0089);\n" +" _TMP68 = 1.00000000E+00/_TMP44;\n" +" _c0081 = (-_B0083 - _TMP68)/(2.00000000E+00*_A0083);\n" +" _point0081 = vec2(_c0081, _c0081)*_cd1;\n" +" _point0081 = _point0081 - vec2( -2.00000000E+00, -2.00000000E+00)*VARsinangle;\n" +" _point0081 = _point0081/vec2( 2.00000000E+00, 2.00000000E+00);\n" +" _tang0081 = VARsinangle/VARcosangle;\n" +" _poc0081 = _point0081/VARcosangle;\n" +" _TMP37 = dot(_tang0081, _tang0081);\n" +" _A0081 = _TMP37 + 1.00000000E+00;\n" +" _TMP38 = dot(_poc0081, _tang0081);\n" +" _B0081 = -2.00000000E+00*_TMP38;\n" +" _TMP39 = dot(_poc0081, _poc0081);\n" +" _C0081 = _TMP39 - 1.00000000E+00;\n" +" _a0099 = _B0081*_B0081 - 4.00000000E+00*_A0081*_C0081;\n" +" _TMP44 = inversesqrt(_a0099);\n" +" _TMP40 = 1.00000000E+00/_TMP44;\n" +" _a0081 = (-_B0081 + _TMP40)/(2.00000000E+00*_A0081);\n" +" _uv0081 = (_point0081 - _a0081*VARsinangle)/VARcosangle;\n" +" _negate0103 = float((_a0081 < 0.00000000E+00));\n" +" _x0103 = abs(_a0081);\n" +" _ret0103 = -1.87292993E-02*_x0103;\n" +" _ret0103 = _ret0103 + 7.42610022E-02;\n" +" _ret0103 = _ret0103*_x0103;\n" +" _ret0103 = _ret0103 - 2.12114394E-01;\n" +" _ret0103 = _ret0103*_x0103;\n" +" _ret0103 = _ret0103 + 1.57072902E+00;\n" +" _a0107 = 1.00000000E+00 - _x0103;\n" +" _TMP44 = inversesqrt(_a0107);\n" +" _TMP69 = 1.00000000E+00/_TMP44;\n" +" _ret0103 = _ret0103*_TMP69;\n" +" _ret0103 = _ret0103 - 2.00000000E+00*_negate0103*_ret0103;\n" +" _TMP41 = _negate0103*3.14159298E+00 + _ret0103;\n" +" _a0111 = 2.00000000E+00*_TMP41;\n" +" _TMP42 = abs(_a0111);\n" +" _r0081 = max(_TMP42, 9.99999975E-06);\n" +" _a0115 = _r0081/2.00000000E+00;\n" +" _TMP43 = sin(_a0115);\n" +" _TMP0 = (_uv0081*_r0081)/_TMP43;\n" +" _xy2 = ((_TMP0/vec2( 1.00000000E+00, 7.50000000E-01) + vec2( 5.00000000E-01, 5.00000000E-01))*InputSize)/TextureSize;\n" +" _cd2 = _xy2*(TextureSize/InputSize);\n" +" _cd2 = (_cd2 - vec2( 5.00000000E-01, 5.00000000E-01)) + vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _b0117 = vec2( 1.00000000E+00, 1.00000000E+00) - _cd2;\n" +" _TMP1 = min(_cd2, _b0117);\n" +" _cd2 = _TMP1*vec2( 1.00000000E+00, 7.50000000E-01);\n" +" _TMP2 = min(_cd2, vec2( 2.99999993E-02, 2.99999993E-02));\n" +" _cd2 = vec2( 2.99999993E-02, 2.99999993E-02) - _TMP2;\n" +" _TMP3 = dot(_cd2, _cd2);\n" +" _TMP44 = inversesqrt(_TMP3);\n" +" _dist = 1.00000000E+00/_TMP44;\n" +" _x0127 = (2.99999993E-02 - _dist)*1.00000000E+03;\n" +" _TMP45 = min(1.00000000E+00, _x0127);\n" +" _TMP126 = max(0.00000000E+00, _TMP45);\n" +" if (VARilfac.y > 1.50000000E+00) { \n" +" _a0135 = float(FrameCount)/2.00000000E+00;\n" +" _TMP46 = abs(_a0135);\n" +" _TMP47 = fract(_TMP46);\n" +" _TMP48 = abs(2.00000000E+00);\n" +" _c0133 = _TMP47*_TMP48;\n" +" if (float(FrameCount) < 0.00000000E+00) { \n" +" _TMP49 = -_c0133;\n" +" } else {\n" +" _TMP49 = _c0133;\n" +" } \n" +" _TMP4 = _TMP49;\n" +" } else {\n" +" _TMP4 = 0.00000000E+00;\n" +" } \n" +" _ilfloat = vec2(0.00000000E+00, _TMP4);\n" +" _ratio_scale = ((_xy2*VARTextureSize - vec2( 5.00000000E-01, 5.00000000E-01)) + _ilfloat)/VARilfac;\n" +" _filter = InputSize.y/OutputSize.y;\n" +" _uv_ratio = fract(_ratio_scale);\n" +" _TMP5 = floor(_ratio_scale);\n" +" _xy2 = ((_TMP5*VARilfac + vec2( 5.00000000E-01, 5.00000000E-01)) - _ilfloat)/VARTextureSize;\n" +" _coeffs = 3.14159274E+00*vec4(1.00000000E+00 + _uv_ratio.x, _uv_ratio.x, 1.00000000E+00 - _uv_ratio.x, 2.00000000E+00 - _uv_ratio.x);\n" +" _TMP6 = abs(_coeffs);\n" +" _TMP146 = max(_TMP6, vec4( 9.99999975E-06, 9.99999975E-06, 9.99999975E-06, 9.99999975E-06));\n" +" _TMP50 = sin(_TMP146.x);\n" +" _TMP51 = sin(_TMP146.y);\n" +" _TMP52 = sin(_TMP146.z);\n" +" _TMP53 = sin(_TMP146.w);\n" +" _TMP7 = vec4(_TMP50, _TMP51, _TMP52, _TMP53);\n" +" _x0161 = _TMP146/2.00000000E+00;\n" +" _TMP50 = sin(_x0161.x);\n" +" _TMP51 = sin(_x0161.y);\n" +" _TMP52 = sin(_x0161.z);\n" +" _TMP53 = sin(_x0161.w);\n" +" _TMP8 = vec4(_TMP50, _TMP51, _TMP52, _TMP53);\n" +" _coeffs = ((2.00000000E+00*_TMP7)*_TMP8)/(_TMP146*_TMP146);\n" +" _TMP9 = dot(_coeffs, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _coeffs = _coeffs/_TMP9;\n" +" _c0173 = _xy2 + vec2(-VARone.x, 0.00000000E+00);\n" +" _TMP10 = COMPAT_TEXTURE(Texture, _c0173);\n" +" _TMP54 = pow(_TMP10.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP10.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP10.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP10.w, 2.40000010E+00);\n" +" _TMP11 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _TMP12 = COMPAT_TEXTURE(Texture, _xy2);\n" +" _TMP54 = pow(_TMP12.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP12.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP12.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP12.w, 2.40000010E+00);\n" +" _TMP13 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _c0197 = _xy2 + vec2(VARone.x, 0.00000000E+00);\n" +" _TMP14 = COMPAT_TEXTURE(Texture, _c0197);\n" +" _TMP54 = pow(_TMP14.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP14.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP14.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP14.w, 2.40000010E+00);\n" +" _TMP15 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _c0209 = _xy2 + vec2(2.00000000E+00*VARone.x, 0.00000000E+00);\n" +" _TMP16 = COMPAT_TEXTURE(Texture, _c0209);\n" +" _TMP54 = pow(_TMP16.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP16.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP16.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP16.w, 2.40000010E+00);\n" +" _TMP17 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _r0221 = _coeffs.x*_TMP11;\n" +" _r0221 = _r0221 + _coeffs.y*_TMP13;\n" +" _r0221 = _r0221 + _coeffs.z*_TMP15;\n" +" _r0221 = _r0221 + _coeffs.w*_TMP17;\n" +" _TMP58 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _r0221);\n" +" _TMP222 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP58);\n" +" _c0229 = _xy2 + vec2(-VARone.x, VARone.y);\n" +" _TMP19 = COMPAT_TEXTURE(Texture, _c0229);\n" +" _TMP54 = pow(_TMP19.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP19.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP19.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP19.w, 2.40000010E+00);\n" +" _TMP20 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _c0241 = _xy2 + vec2(0.00000000E+00, VARone.y);\n" +" _TMP21 = COMPAT_TEXTURE(Texture, _c0241);\n" +" _TMP54 = pow(_TMP21.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP21.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP21.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP21.w, 2.40000010E+00);\n" +" _TMP22 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _c0253 = _xy2 + VARone;\n" +" _TMP23 = COMPAT_TEXTURE(Texture, _c0253);\n" +" _TMP54 = pow(_TMP23.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP23.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP23.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP23.w, 2.40000010E+00);\n" +" _TMP24 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _c0265 = _xy2 + vec2(2.00000000E+00*VARone.x, VARone.y);\n" +" _TMP25 = COMPAT_TEXTURE(Texture, _c0265);\n" +" _TMP54 = pow(_TMP25.x, 2.40000010E+00);\n" +" _TMP55 = pow(_TMP25.y, 2.40000010E+00);\n" +" _TMP56 = pow(_TMP25.z, 2.40000010E+00);\n" +" _TMP57 = pow(_TMP25.w, 2.40000010E+00);\n" +" _TMP26 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _r0277 = _coeffs.x*_TMP20;\n" +" _r0277 = _r0277 + _coeffs.y*_TMP22;\n" +" _r0277 = _r0277 + _coeffs.z*_TMP24;\n" +" _r0277 = _r0277 + _coeffs.w*_TMP26;\n" +" _TMP58 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _r0277);\n" +" _TMP278 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP58);\n" +" _TMP54 = pow(_TMP222.x, 4.00000000E+00);\n" +" _TMP55 = pow(_TMP222.y, 4.00000000E+00);\n" +" _TMP56 = pow(_TMP222.z, 4.00000000E+00);\n" +" _TMP57 = pow(_TMP222.w, 4.00000000E+00);\n" +" _TMP59 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _wid0285 = 2.00000000E+00 + 2.00000000E+00*_TMP59;\n" +" _weights0285 = vec4(_uv_ratio.y/3.00000012E-01, _uv_ratio.y/3.00000012E-01, _uv_ratio.y/3.00000012E-01, _uv_ratio.y/3.00000012E-01);\n" +" _x0297 = 5.00000000E-01*_wid0285;\n" +" _TMP70 = inversesqrt(_x0297.x);\n" +" _TMP71 = inversesqrt(_x0297.y);\n" +" _TMP72 = inversesqrt(_x0297.z);\n" +" _TMP73 = inversesqrt(_x0297.w);\n" +" _TMP60 = vec4(_TMP70, _TMP71, _TMP72, _TMP73);\n" +" _a0307 = _weights0285*_TMP60;\n" +" _TMP54 = pow(_a0307.x, _wid0285.x);\n" +" _TMP55 = pow(_a0307.y, _wid0285.y);\n" +" _TMP56 = pow(_a0307.z, _wid0285.z);\n" +" _TMP57 = pow(_a0307.w, _wid0285.w);\n" +" _TMP61 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _x0317 = -_TMP61;\n" +" _TMP54 = pow(2.71828198E+00, _x0317.x);\n" +" _TMP55 = pow(2.71828198E+00, _x0317.y);\n" +" _TMP56 = pow(2.71828198E+00, _x0317.z);\n" +" _TMP57 = pow(2.71828198E+00, _x0317.w);\n" +" _TMP316 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _weights1 = (1.39999998E+00*_TMP316)/(6.00000024E-01 + 2.00000003E-01*_wid0285);\n" +" _distance0329 = 1.00000000E+00 - _uv_ratio.y;\n" +" _TMP54 = pow(_TMP278.x, 4.00000000E+00);\n" +" _TMP55 = pow(_TMP278.y, 4.00000000E+00);\n" +" _TMP56 = pow(_TMP278.z, 4.00000000E+00);\n" +" _TMP57 = pow(_TMP278.w, 4.00000000E+00);\n" +" _TMP59 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _wid0329 = 2.00000000E+00 + 2.00000000E+00*_TMP59;\n" +" _weights0329 = vec4(_distance0329/3.00000012E-01, _distance0329/3.00000012E-01, _distance0329/3.00000012E-01, _distance0329/3.00000012E-01);\n" +" _x0341 = 5.00000000E-01*_wid0329;\n" +" _TMP70 = inversesqrt(_x0341.x);\n" +" _TMP71 = inversesqrt(_x0341.y);\n" +" _TMP72 = inversesqrt(_x0341.z);\n" +" _TMP73 = inversesqrt(_x0341.w);\n" +" _TMP60 = vec4(_TMP70, _TMP71, _TMP72, _TMP73);\n" +" _a0351 = _weights0329*_TMP60;\n" +" _TMP54 = pow(_a0351.x, _wid0329.x);\n" +" _TMP55 = pow(_a0351.y, _wid0329.y);\n" +" _TMP56 = pow(_a0351.z, _wid0329.z);\n" +" _TMP57 = pow(_a0351.w, _wid0329.w);\n" +" _TMP61 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _x0361 = -_TMP61;\n" +" _TMP54 = pow(2.71828198E+00, _x0361.x);\n" +" _TMP55 = pow(2.71828198E+00, _x0361.y);\n" +" _TMP56 = pow(2.71828198E+00, _x0361.z);\n" +" _TMP57 = pow(2.71828198E+00, _x0361.w);\n" +" _TMP360 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _weights2 = (1.39999998E+00*_TMP360)/(6.00000024E-01 + 2.00000003E-01*_wid0329);\n" +" _uv_ratio.y = _uv_ratio.y + 3.33333343E-01*_filter;\n" +" _TMP54 = pow(_TMP222.x, 4.00000000E+00);\n" +" _TMP55 = pow(_TMP222.y, 4.00000000E+00);\n" +" _TMP56 = pow(_TMP222.z, 4.00000000E+00);\n" +" _TMP57 = pow(_TMP222.w, 4.00000000E+00);\n" +" _TMP59 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _wid0373 = 2.00000000E+00 + 2.00000000E+00*_TMP59;\n" +" _weights0373 = vec4(_uv_ratio.y/3.00000012E-01, _uv_ratio.y/3.00000012E-01, _uv_ratio.y/3.00000012E-01, _uv_ratio.y/3.00000012E-01);\n" +" _x0385 = 5.00000000E-01*_wid0373;\n" +" _TMP70 = inversesqrt(_x0385.x);\n" +" _TMP71 = inversesqrt(_x0385.y);\n" +" _TMP72 = inversesqrt(_x0385.z);\n" +" _TMP73 = inversesqrt(_x0385.w);\n" +" _TMP60 = vec4(_TMP70, _TMP71, _TMP72, _TMP73);\n" +" _a0395 = _weights0373*_TMP60;\n" +" _TMP54 = pow(_a0395.x, _wid0373.x);\n" +" _TMP55 = pow(_a0395.y, _wid0373.y);\n" +" _TMP56 = pow(_a0395.z, _wid0373.z);\n" +" _TMP57 = pow(_a0395.w, _wid0373.w);\n" +" _TMP61 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _x0405 = -_TMP61;\n" +" _TMP54 = pow(2.71828198E+00, _x0405.x);\n" +" _TMP55 = pow(2.71828198E+00, _x0405.y);\n" +" _TMP56 = pow(2.71828198E+00, _x0405.z);\n" +" _TMP57 = pow(2.71828198E+00, _x0405.w);\n" +" _TMP404 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _TMP28 = (1.39999998E+00*_TMP404)/(6.00000024E-01 + 2.00000003E-01*_wid0373);\n" +" _weights1 = (_weights1 + _TMP28)/3.00000000E+00;\n" +" _a0417 = 1.00000000E+00 - _uv_ratio.y;\n" +" _TMP29 = abs(_a0417);\n" +" _TMP54 = pow(_TMP278.x, 4.00000000E+00);\n" +" _TMP55 = pow(_TMP278.y, 4.00000000E+00);\n" +" _TMP56 = pow(_TMP278.z, 4.00000000E+00);\n" +" _TMP57 = pow(_TMP278.w, 4.00000000E+00);\n" +" _TMP59 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _wid0419 = 2.00000000E+00 + 2.00000000E+00*_TMP59;\n" +" _weights0419 = vec4(_TMP29/3.00000012E-01, _TMP29/3.00000012E-01, _TMP29/3.00000012E-01, _TMP29/3.00000012E-01);\n" +" _x0431 = 5.00000000E-01*_wid0419;\n" +" _TMP70 = inversesqrt(_x0431.x);\n" +" _TMP71 = inversesqrt(_x0431.y);\n" +" _TMP72 = inversesqrt(_x0431.z);\n" +" _TMP73 = inversesqrt(_x0431.w);\n" +" _TMP60 = vec4(_TMP70, _TMP71, _TMP72, _TMP73);\n" +" _a0441 = _weights0419*_TMP60;\n" +" _TMP54 = pow(_a0441.x, _wid0419.x);\n" +" _TMP55 = pow(_a0441.y, _wid0419.y);\n" +" _TMP56 = pow(_a0441.z, _wid0419.z);\n" +" _TMP57 = pow(_a0441.w, _wid0419.w);\n" +" _TMP61 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _x0451 = -_TMP61;\n" +" _TMP54 = pow(2.71828198E+00, _x0451.x);\n" +" _TMP55 = pow(2.71828198E+00, _x0451.y);\n" +" _TMP56 = pow(2.71828198E+00, _x0451.z);\n" +" _TMP57 = pow(2.71828198E+00, _x0451.w);\n" +" _TMP450 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _TMP30 = (1.39999998E+00*_TMP450)/(6.00000024E-01 + 2.00000003E-01*_wid0419);\n" +" _weights2 = (_weights2 + _TMP30)/3.00000000E+00;\n" +" _uv_ratio.y = _uv_ratio.y - 6.66666687E-01*_filter;\n" +" _TMP31 = abs(_uv_ratio.y);\n" +" _TMP54 = pow(_TMP222.x, 4.00000000E+00);\n" +" _TMP55 = pow(_TMP222.y, 4.00000000E+00);\n" +" _TMP56 = pow(_TMP222.z, 4.00000000E+00);\n" +" _TMP57 = pow(_TMP222.w, 4.00000000E+00);\n" +" _TMP59 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _wid0465 = 2.00000000E+00 + 2.00000000E+00*_TMP59;\n" +" _weights0465 = vec4(_TMP31/3.00000012E-01, _TMP31/3.00000012E-01, _TMP31/3.00000012E-01, _TMP31/3.00000012E-01);\n" +" _x0477 = 5.00000000E-01*_wid0465;\n" +" _TMP70 = inversesqrt(_x0477.x);\n" +" _TMP71 = inversesqrt(_x0477.y);\n" +" _TMP72 = inversesqrt(_x0477.z);\n" +" _TMP73 = inversesqrt(_x0477.w);\n" +" _TMP60 = vec4(_TMP70, _TMP71, _TMP72, _TMP73);\n" +" _a0487 = _weights0465*_TMP60;\n" +" _TMP54 = pow(_a0487.x, _wid0465.x);\n" +" _TMP55 = pow(_a0487.y, _wid0465.y);\n" +" _TMP56 = pow(_a0487.z, _wid0465.z);\n" +" _TMP57 = pow(_a0487.w, _wid0465.w);\n" +" _TMP61 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _x0497 = -_TMP61;\n" +" _TMP54 = pow(2.71828198E+00, _x0497.x);\n" +" _TMP55 = pow(2.71828198E+00, _x0497.y);\n" +" _TMP56 = pow(2.71828198E+00, _x0497.z);\n" +" _TMP57 = pow(2.71828198E+00, _x0497.w);\n" +" _TMP496 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _TMP32 = (1.39999998E+00*_TMP496)/(6.00000024E-01 + 2.00000003E-01*_wid0465);\n" +" _weights1 = _weights1 + _TMP32/3.00000000E+00;\n" +" _a0509 = 1.00000000E+00 - _uv_ratio.y;\n" +" _TMP33 = abs(_a0509);\n" +" _TMP54 = pow(_TMP278.x, 4.00000000E+00);\n" +" _TMP55 = pow(_TMP278.y, 4.00000000E+00);\n" +" _TMP56 = pow(_TMP278.z, 4.00000000E+00);\n" +" _TMP57 = pow(_TMP278.w, 4.00000000E+00);\n" +" _TMP59 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _wid0511 = 2.00000000E+00 + 2.00000000E+00*_TMP59;\n" +" _weights0511 = vec4(_TMP33/3.00000012E-01, _TMP33/3.00000012E-01, _TMP33/3.00000012E-01, _TMP33/3.00000012E-01);\n" +" _x0523 = 5.00000000E-01*_wid0511;\n" +" _TMP70 = inversesqrt(_x0523.x);\n" +" _TMP71 = inversesqrt(_x0523.y);\n" +" _TMP72 = inversesqrt(_x0523.z);\n" +" _TMP73 = inversesqrt(_x0523.w);\n" +" _TMP60 = vec4(_TMP70, _TMP71, _TMP72, _TMP73);\n" +" _a0533 = _weights0511*_TMP60;\n" +" _TMP54 = pow(_a0533.x, _wid0511.x);\n" +" _TMP55 = pow(_a0533.y, _wid0511.y);\n" +" _TMP56 = pow(_a0533.z, _wid0511.z);\n" +" _TMP57 = pow(_a0533.w, _wid0511.w);\n" +" _TMP61 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _x0543 = -_TMP61;\n" +" _TMP54 = pow(2.71828198E+00, _x0543.x);\n" +" _TMP55 = pow(2.71828198E+00, _x0543.y);\n" +" _TMP56 = pow(2.71828198E+00, _x0543.z);\n" +" _TMP57 = pow(2.71828198E+00, _x0543.w);\n" +" _TMP542 = vec4(_TMP54, _TMP55, _TMP56, _TMP57);\n" +" _TMP34 = (1.39999998E+00*_TMP542)/(6.00000024E-01 + 2.00000003E-01*_wid0511);\n" +" _weights2 = _weights2 + _TMP34/3.00000000E+00;\n" +" _mul_res = (_TMP222*_weights1 + _TMP278*_weights2).xyz;\n" +" _mul_res = _mul_res*vec3(_TMP126, _TMP126, _TMP126);\n" +" _a0557 = VARmod_factor/2.00000000E+00;\n" +" _TMP46 = abs(_a0557);\n" +" _TMP47 = fract(_TMP46);\n" +" _TMP48 = abs(2.00000000E+00);\n" +" _c0555 = _TMP47*_TMP48;\n" +" if (VARmod_factor < 0.00000000E+00) { \n" +" _TMP49 = -_c0555;\n" +" } else {\n" +" _TMP49 = _c0555;\n" +" } \n" +" _TMP36 = floor(_TMP49);\n" +" _dotMaskWeights = vec3( 1.00000000E+00, 6.99999988E-01, 1.00000000E+00) + _TMP36*vec3( -3.00000012E-01, 3.00000012E-01, -3.00000012E-01);\n" +" _mul_res = _mul_res*_dotMaskWeights;\n" +" _TMP63 = pow(_mul_res.x, 4.54545438E-01);\n" +" _TMP64 = pow(_mul_res.y, 4.54545438E-01);\n" +" _TMP65 = pow(_mul_res.z, 4.54545438E-01);\n" +" _mul_res = vec3(_TMP63, _TMP64, _TMP65);\n" +" _ret_0 = vec4(_mul_res.x, _mul_res.y, _mul_res.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-hyllian.h b/src/video/sdl/shaders/crt/crt-hyllian.h new file mode 100644 index 000000000..4a9e9ddbd --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-hyllian.h @@ -0,0 +1,305 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec2 _texCoord1;\n" +"};\n" +"vec4 _oPosition1;\n" +"out_vertex _ret_0;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0008;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" gl_Position = _r0008;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec2 _texCoord;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP18;\n" +"float _TMP17;\n" +"float _TMP16;\n" +"vec3 _TMP15;\n" +"float _TMP14;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"float _TMP21;\n" +"vec3 _TMP20;\n" +"vec3 _TMP19;\n" +"vec3 _TMP12;\n" +"vec3 _TMP11;\n" +"vec3 _TMP10;\n" +"vec3 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec2 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _c0038;\n" +"vec2 _c0048;\n" +"vec2 _c0058;\n" +"vec2 _c0068;\n" +"vec2 _c0078;\n" +"vec2 _c0098;\n" +"vec2 _c0108;\n" +"vec4 _r0130;\n" +"vec4 _v0130;\n" +"vec3 _r0140;\n" +"vec3 _r0142;\n" +"vec3 _TMP143;\n" +"vec3 _TMP151;\n" +"vec3 _TMP163;\n" +"vec3 _x0164;\n" +"vec3 _TMP169;\n" +"vec3 _x0170;\n" +"vec3 _TMP175;\n" +"vec3 _x0176;\n" +"vec3 _TMP185;\n" +"vec3 _x0186;\n" +"vec3 _TMP195;\n" +"vec3 _x0196;\n" +"float _c0202;\n" +"float _a0204;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _TextureSize;\n" +" vec3 _color;\n" +" vec2 _dx;\n" +" vec2 _dy;\n" +" vec2 _pix_coord;\n" +" vec2 _tc;\n" +" vec2 _fp;\n" +" vec3 _c00;\n" +" vec3 _c01;\n" +" vec3 _c02;\n" +" vec3 _c03;\n" +" vec3 _c10;\n" +" vec3 _c11;\n" +" vec3 _c12;\n" +" vec3 _c13;\n" +" vec3 _min_sample;\n" +" vec3 _max_sample;\n" +" vec3 _color0;\n" +" vec3 _color1;\n" +" float _pos1;\n" +" vec3 _lum0;\n" +" vec3 _lum1;\n" +" float _mod_factor;\n" +" vec3 _dotMaskWeights;\n" +" _TextureSize = vec2(TextureSize.x, TextureSize.y);\n" +" _dx = vec2(1.00000000E+00/_TextureSize.x, 0.00000000E+00);\n" +" _dy = vec2(0.00000000E+00, 1.00000000E+00/_TextureSize.y);\n" +" _pix_coord = TEX0.xy*_TextureSize + vec2( -5.00000000E-01, 5.00000000E-01);\n" +" _TMP0 = floor(_pix_coord);\n" +" _tc = (_TMP0 + vec2( 5.00000000E-01, 5.00000000E-01))/_TextureSize;\n" +" _fp = fract(_pix_coord);\n" +" _c0038 = (_tc - _dx) - _dy;\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0038);\n" +" _TMP16 = pow(_TMP1.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP1.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP1.z, 2.40000010E+00);\n" +" _c00 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _c0048 = _tc - _dy;\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0048);\n" +" _TMP16 = pow(_TMP2.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP2.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP2.z, 2.40000010E+00);\n" +" _c01 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _c0058 = (_tc + _dx) - _dy;\n" +" _TMP3 = COMPAT_TEXTURE(Texture, _c0058);\n" +" _TMP16 = pow(_TMP3.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP3.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP3.z, 2.40000010E+00);\n" +" _c02 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _c0068 = (_tc + 2.00000000E+00*_dx) - _dy;\n" +" _TMP4 = COMPAT_TEXTURE(Texture, _c0068);\n" +" _TMP16 = pow(_TMP4.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP4.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP4.z, 2.40000010E+00);\n" +" _c03 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _c0078 = _tc - _dx;\n" +" _TMP5 = COMPAT_TEXTURE(Texture, _c0078);\n" +" _TMP16 = pow(_TMP5.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP5.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP5.z, 2.40000010E+00);\n" +" _c10 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, _tc);\n" +" _TMP16 = pow(_TMP6.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP6.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP6.z, 2.40000010E+00);\n" +" _c11 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _c0098 = _tc + _dx;\n" +" _TMP7 = COMPAT_TEXTURE(Texture, _c0098);\n" +" _TMP16 = pow(_TMP7.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP7.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP7.z, 2.40000010E+00);\n" +" _c12 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _c0108 = _tc + 2.00000000E+00*_dx;\n" +" _TMP8 = COMPAT_TEXTURE(Texture, _c0108);\n" +" _TMP16 = pow(_TMP8.x, 2.40000010E+00);\n" +" _TMP17 = pow(_TMP8.y, 2.40000010E+00);\n" +" _TMP18 = pow(_TMP8.z, 2.40000010E+00);\n" +" _c13 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _TMP9 = min(_c01, _c11);\n" +" _TMP10 = min(_c02, _c12);\n" +" _min_sample = min(_TMP9, _TMP10);\n" +" _TMP11 = max(_c01, _c11);\n" +" _TMP12 = max(_c02, _c12);\n" +" _max_sample = max(_TMP11, _TMP12);\n" +" _v0130 = vec4(_fp.x*_fp.x*_fp.x, _fp.x*_fp.x, _fp.x, 1.00000000E+00);\n" +" _r0130.x = dot(vec4( -5.00000000E-01, 1.00000000E+00, -5.00000000E-01, 0.00000000E+00), _v0130);\n" +" _r0130.y = dot(vec4( 1.50000000E+00, -2.50000000E+00, 0.00000000E+00, 1.00000000E+00), _v0130);\n" +" _r0130.z = dot(vec4( -1.50000000E+00, 2.00000000E+00, 5.00000000E-01, 0.00000000E+00), _v0130);\n" +" _r0130.w = dot(vec4( 5.00000000E-01, -5.00000000E-01, 0.00000000E+00, 0.00000000E+00), _v0130);\n" +" _r0140 = _r0130.x*_c00;\n" +" _r0140 = _r0140 + _r0130.y*_c01;\n" +" _r0140 = _r0140 + _r0130.z*_c02;\n" +" _r0140 = _r0140 + _r0130.w*_c03;\n" +" _r0142 = _r0130.x*_c10;\n" +" _r0142 = _r0142 + _r0130.y*_c11;\n" +" _r0142 = _r0142 + _r0130.z*_c12;\n" +" _r0142 = _r0142 + _r0130.w*_c13;\n" +" _TMP19 = min(_max_sample, _r0140);\n" +" _TMP143 = max(_min_sample, _TMP19);\n" +" _color0 = _r0140 + 8.00000012E-01*(_TMP143 - _r0140);\n" +" _TMP19 = min(_max_sample, _r0142);\n" +" _TMP151 = max(_min_sample, _TMP19);\n" +" _color1 = _r0142 + 8.00000012E-01*(_TMP151 - _r0142);\n" +" _pos1 = 1.00000000E+00 - _fp.y;\n" +" _lum0 = vec3( 8.60000014E-01, 8.60000014E-01, 8.60000014E-01) + _color0*vec3( 1.39999986E-01, 1.39999986E-01, 1.39999986E-01);\n" +" _lum1 = vec3( 8.60000014E-01, 8.60000014E-01, 8.60000014E-01) + _color1*vec3( 1.39999986E-01, 1.39999986E-01, 1.39999986E-01);\n" +" _x0164 = _fp.y/(_lum0 + 1.00000001E-07);\n" +" _TMP20 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0164);\n" +" _TMP163 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP20);\n" +" _x0170 = _pos1/(_lum1 + 1.00000001E-07);\n" +" _TMP20 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0170);\n" +" _TMP169 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP20);\n" +" _x0176 = (-7.20000029E+00*_TMP163)*_TMP163;\n" +" _TMP16 = pow(2.71828198E+00, _x0176.x);\n" +" _TMP17 = pow(2.71828198E+00, _x0176.y);\n" +" _TMP18 = pow(2.71828198E+00, _x0176.z);\n" +" _TMP175 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _x0186 = (-7.20000029E+00*_TMP169)*_TMP169;\n" +" _TMP16 = pow(2.71828198E+00, _x0186.x);\n" +" _TMP17 = pow(2.71828198E+00, _x0186.y);\n" +" _TMP18 = pow(2.71828198E+00, _x0186.z);\n" +" _TMP185 = vec3(_TMP16, _TMP17, _TMP18);\n" +" _x0196 = _color0*_TMP175 + _color1*_TMP185;\n" +" _TMP20 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0196);\n" +" _TMP195 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP20);\n" +" _color = _TMP195*vec3( 1.50000000E+00, 1.50000000E+00, 1.50000000E+00);\n" +" _mod_factor = (TEX0.x*OutputSize.x*TextureSize.x)/InputSize.x;\n" +" _a0204 = _mod_factor/2.00000000E+00;\n" +" _TMP21 = abs(_a0204);\n" +" _TMP22 = fract(_TMP21);\n" +" _TMP23 = abs(2.00000000E+00);\n" +" _c0202 = _TMP22*_TMP23;\n" +" if (_mod_factor < 0.00000000E+00) { \n" +" _TMP24 = -_c0202;\n" +" } else {\n" +" _TMP24 = _c0202;\n" +" } \n" +" _TMP14 = floor(_TMP24);\n" +" _dotMaskWeights = vec3( 1.00000000E+00, 6.99999988E-01, 1.00000000E+00) + _TMP14*vec3( -3.00000012E-01, 3.00000012E-01, -3.00000012E-01);\n" +" _TMP15 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_dotMaskWeights - vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _color.xyz = _color.xyz*_TMP15;\n" +" _TMP16 = pow(_color.x, 4.54545438E-01);\n" +" _TMP17 = pow(_color.y, 4.54545438E-01);\n" +" _TMP18 = pow(_color.z, 4.54545438E-01);\n" +" _color = vec3(_TMP16, _TMP17, _TMP18);\n" +" _ret_0 = vec4(_color.x, _color.y, _color.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-lottes.h b/src/video/sdl/shaders/crt/crt-lottes.h new file mode 100644 index 000000000..7e6ef1bb7 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-lottes.h @@ -0,0 +1,616 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0007;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0007 = VertexCoord.x*MVPMatrix[0];\n" +" _r0007 = _r0007 + VertexCoord.y*MVPMatrix[1];\n" +" _r0007 = _r0007 + VertexCoord.z*MVPMatrix[2];\n" +" _r0007 = _r0007 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0007;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0007;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP3;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP10;\n" +"float _TMP11;\n" +"vec2 _TMP1;\n" +"vec2 _TMP9;\n" +"vec2 _TMP14;\n" +"vec2 _TMP7;\n" +"vec4 _TMP13;\n" +"float _TMP16;\n" +"float _TMP15;\n" +"float _TMP18;\n" +"vec2 _TMP12;\n" +"vec2 _TMP8;\n" +"vec2 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _pos0025;\n" +"vec3 _a0027;\n" +"vec3 _b0027;\n" +"vec3 _c0027;\n" +"vec3 _TMP30;\n" +"vec2 _pos0031;\n" +"vec2 _x0033;\n" +"float _x0041;\n" +"float _x0045;\n" +"float _x0049;\n" +"vec3 _TMP50;\n" +"vec2 _pos0051;\n" +"vec2 _x0053;\n" +"float _x0061;\n" +"float _x0065;\n" +"float _x0069;\n" +"vec3 _TMP70;\n" +"vec2 _pos0071;\n" +"vec2 _x0073;\n" +"float _x0081;\n" +"float _x0085;\n" +"float _x0089;\n" +"vec2 _pos0091;\n" +"float _TMP94;\n" +"float _pos0095;\n" +"float _x0097;\n" +"float _TMP98;\n" +"float _x0101;\n" +"float _TMP102;\n" +"float _pos0103;\n" +"float _x0105;\n" +"vec3 _TMP108;\n" +"vec2 _pos0109;\n" +"vec2 _x0111;\n" +"float _x0119;\n" +"float _x0123;\n" +"float _x0127;\n" +"vec3 _TMP128;\n" +"vec2 _pos0129;\n" +"vec2 _x0131;\n" +"float _x0139;\n" +"float _x0143;\n" +"float _x0147;\n" +"vec3 _TMP148;\n" +"vec2 _pos0149;\n" +"vec2 _x0151;\n" +"float _x0159;\n" +"float _x0163;\n" +"float _x0167;\n" +"vec3 _TMP168;\n" +"vec2 _pos0169;\n" +"vec2 _x0171;\n" +"float _x0179;\n" +"float _x0183;\n" +"float _x0187;\n" +"vec3 _TMP188;\n" +"vec2 _pos0189;\n" +"vec2 _x0191;\n" +"float _x0199;\n" +"float _x0203;\n" +"float _x0207;\n" +"vec2 _pos0209;\n" +"float _TMP212;\n" +"float _pos0213;\n" +"float _x0215;\n" +"float _TMP216;\n" +"float _pos0217;\n" +"float _x0219;\n" +"float _TMP220;\n" +"float _x0223;\n" +"float _TMP224;\n" +"float _pos0225;\n" +"float _x0227;\n" +"float _TMP228;\n" +"float _pos0229;\n" +"float _x0231;\n" +"vec3 _TMP234;\n" +"vec2 _pos0235;\n" +"vec2 _x0237;\n" +"float _x0245;\n" +"float _x0249;\n" +"float _x0253;\n" +"vec3 _TMP254;\n" +"vec2 _pos0255;\n" +"vec2 _x0257;\n" +"float _x0265;\n" +"float _x0269;\n" +"float _x0273;\n" +"vec3 _TMP274;\n" +"vec2 _pos0275;\n" +"vec2 _x0277;\n" +"float _x0285;\n" +"float _x0289;\n" +"float _x0293;\n" +"vec2 _pos0295;\n" +"float _TMP298;\n" +"float _pos0299;\n" +"float _x0301;\n" +"float _TMP302;\n" +"float _x0305;\n" +"float _TMP306;\n" +"float _pos0307;\n" +"float _x0309;\n" +"vec2 _pos0313;\n" +"float _TMP316;\n" +"float _pos0317;\n" +"float _x0319;\n" +"vec2 _pos0323;\n" +"float _TMP326;\n" +"float _x0329;\n" +"vec2 _pos0333;\n" +"float _TMP336;\n" +"float _pos0337;\n" +"float _x0339;\n" +"vec2 _x0341;\n" +"vec2 _pos0343;\n" +"vec3 _mask0343;\n" +"float _TMP344;\n" +"float _x0345;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _pos9;\n" +" vec3 _outColor;\n" +" _pos0025 = TEX0.xy*(TextureSize.xy/InputSize.xy);\n" +" _pos0025 = _pos0025*2.00000000E+00 - 1.00000000E+00;\n" +" _pos0025 = _pos0025*vec2(1.00000000E+00 + _pos0025.y*_pos0025.y*3.09999995E-02, 1.00000000E+00 + _pos0025.x*_pos0025.x*4.10000011E-02);\n" +" _TMP0 = _pos0025*5.00000000E-01 + 5.00000000E-01;\n" +" _pos9 = _TMP0*(InputSize.xy/TextureSize.xy);\n" +" _x0033 = _pos9*TextureSize.xy + vec2( -1.00000000E+00, -1.00000000E+00);\n" +" _TMP12 = floor(_x0033);\n" +" _pos0031 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0031.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0041 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0041, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0045 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0045, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0049 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0049, 2.40000010E+00);\n" +" } \n" +" _TMP30 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0053 = _pos9*TextureSize.xy + vec2( 0.00000000E+00, -1.00000000E+00);\n" +" _TMP12 = floor(_x0053);\n" +" _pos0051 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0051.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0061 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0061, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0065 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0065, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0069 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0069, 2.40000010E+00);\n" +" } \n" +" _TMP50 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0073 = _pos9*TextureSize.xy + vec2( 1.00000000E+00, -1.00000000E+00);\n" +" _TMP12 = floor(_x0073);\n" +" _pos0071 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0071.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0081 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0081, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0085 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0085, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0089 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0089, 2.40000010E+00);\n" +" } \n" +" _TMP70 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _pos0091 = _pos9*TextureSize.xy;\n" +" _TMP14 = floor(_pos0091);\n" +" _TMP7 = -((_pos0091 - _TMP14) - vec2( 5.00000000E-01, 5.00000000E-01));\n" +" _pos0095 = _TMP7.x - 1.00000000E+00;\n" +" _x0097 = -3.00000000E+00*_pos0095*_pos0095;\n" +" _TMP94 = exp2(_x0097);\n" +" _x0101 = -3.00000000E+00*_TMP7.x*_TMP7.x;\n" +" _TMP98 = exp2(_x0101);\n" +" _pos0103 = _TMP7.x + 1.00000000E+00;\n" +" _x0105 = -3.00000000E+00*_pos0103*_pos0103;\n" +" _TMP102 = exp2(_x0105);\n" +" _a0027 = (_TMP30*_TMP94 + _TMP50*_TMP98 + _TMP70*_TMP102)/(_TMP94 + _TMP98 + _TMP102);\n" +" _x0111 = _pos9*TextureSize.xy + vec2( -2.00000000E+00, 0.00000000E+00);\n" +" _TMP12 = floor(_x0111);\n" +" _pos0109 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0109.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0119 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0119, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0123 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0123, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0127 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0127, 2.40000010E+00);\n" +" } \n" +" _TMP108 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0131 = _pos9*TextureSize.xy + vec2( -1.00000000E+00, 0.00000000E+00);\n" +" _TMP12 = floor(_x0131);\n" +" _pos0129 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0129.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0139 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0139, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0143 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0143, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0147 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0147, 2.40000010E+00);\n" +" } \n" +" _TMP128 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0151 = _pos9*TextureSize.xy;\n" +" _TMP12 = floor(_x0151);\n" +" _pos0149 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0149.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0159 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0159, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0163 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0163, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0167 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0167, 2.40000010E+00);\n" +" } \n" +" _TMP148 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0171 = _pos9*TextureSize.xy + vec2( 1.00000000E+00, 0.00000000E+00);\n" +" _TMP12 = floor(_x0171);\n" +" _pos0169 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0169.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0179 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0179, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0183 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0183, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0187 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0187, 2.40000010E+00);\n" +" } \n" +" _TMP168 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0191 = _pos9*TextureSize.xy + vec2( 2.00000000E+00, 0.00000000E+00);\n" +" _TMP12 = floor(_x0191);\n" +" _pos0189 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0189.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0199 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0199, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0203 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0203, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0207 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0207, 2.40000010E+00);\n" +" } \n" +" _TMP188 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _pos0209 = _pos9*TextureSize.xy;\n" +" _TMP14 = floor(_pos0209);\n" +" _TMP8 = -((_pos0209 - _TMP14) - vec2( 5.00000000E-01, 5.00000000E-01));\n" +" _pos0213 = _TMP8.x - 2.00000000E+00;\n" +" _x0215 = -3.00000000E+00*_pos0213*_pos0213;\n" +" _TMP212 = exp2(_x0215);\n" +" _pos0217 = _TMP8.x - 1.00000000E+00;\n" +" _x0219 = -3.00000000E+00*_pos0217*_pos0217;\n" +" _TMP216 = exp2(_x0219);\n" +" _x0223 = -3.00000000E+00*_TMP8.x*_TMP8.x;\n" +" _TMP220 = exp2(_x0223);\n" +" _pos0225 = _TMP8.x + 1.00000000E+00;\n" +" _x0227 = -3.00000000E+00*_pos0225*_pos0225;\n" +" _TMP224 = exp2(_x0227);\n" +" _pos0229 = _TMP8.x + 2.00000000E+00;\n" +" _x0231 = -3.00000000E+00*_pos0229*_pos0229;\n" +" _TMP228 = exp2(_x0231);\n" +" _b0027 = (_TMP108*_TMP212 + _TMP128*_TMP216 + _TMP148*_TMP220 + _TMP168*_TMP224 + _TMP188*_TMP228)/(_TMP212 + _TMP216 + _TMP220 + _TMP224 + _TMP228);\n" +" _x0237 = _pos9*TextureSize.xy + vec2( -1.00000000E+00, 1.00000000E+00);\n" +" _TMP12 = floor(_x0237);\n" +" _pos0235 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0235.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0245 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0245, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0249 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0249, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0253 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0253, 2.40000010E+00);\n" +" } \n" +" _TMP234 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0257 = _pos9*TextureSize.xy + vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _TMP12 = floor(_x0257);\n" +" _pos0255 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0255.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0265 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0265, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0269 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0269, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0273 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0273, 2.40000010E+00);\n" +" } \n" +" _TMP254 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _x0277 = _pos9*TextureSize.xy + vec2( 1.00000000E+00, 1.00000000E+00);\n" +" _TMP12 = floor(_x0277);\n" +" _pos0275 = (_TMP12 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize.xy;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _pos0275.xy);\n" +" if (_TMP13.x <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.x/1.29200001E+01;\n" +" } else {\n" +" _x0285 = (_TMP13.x + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0285, 2.40000010E+00);\n" +" } \n" +" _TMP15 = _TMP18;\n" +" if (_TMP13.y <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.y/1.29200001E+01;\n" +" } else {\n" +" _x0289 = (_TMP13.y + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0289, 2.40000010E+00);\n" +" } \n" +" _TMP16 = _TMP18;\n" +" if (_TMP13.z <= 4.04499993E-02) { \n" +" _TMP18 = _TMP13.z/1.29200001E+01;\n" +" } else {\n" +" _x0293 = (_TMP13.z + 5.49999997E-02)/1.05499995E+00;\n" +" _TMP18 = pow(_x0293, 2.40000010E+00);\n" +" } \n" +" _TMP274 = vec3(_TMP15, _TMP16, _TMP18);\n" +" _pos0295 = _pos9*TextureSize.xy;\n" +" _TMP14 = floor(_pos0295);\n" +" _TMP7 = -((_pos0295 - _TMP14) - vec2( 5.00000000E-01, 5.00000000E-01));\n" +" _pos0299 = _TMP7.x - 1.00000000E+00;\n" +" _x0301 = -3.00000000E+00*_pos0299*_pos0299;\n" +" _TMP298 = exp2(_x0301);\n" +" _x0305 = -3.00000000E+00*_TMP7.x*_TMP7.x;\n" +" _TMP302 = exp2(_x0305);\n" +" _pos0307 = _TMP7.x + 1.00000000E+00;\n" +" _x0309 = -3.00000000E+00*_pos0307*_pos0307;\n" +" _TMP306 = exp2(_x0309);\n" +" _c0027 = (_TMP234*_TMP298 + _TMP254*_TMP302 + _TMP274*_TMP306)/(_TMP298 + _TMP302 + _TMP306);\n" +" _pos0313 = _pos9*TextureSize.xy;\n" +" _TMP14 = floor(_pos0313);\n" +" _TMP9 = -((_pos0313 - _TMP14) - vec2( 5.00000000E-01, 5.00000000E-01));\n" +" _pos0317 = _TMP9.y + -1.00000000E+00;\n" +" _x0319 = -8.00000000E+00*_pos0317*_pos0317;\n" +" _TMP316 = exp2(_x0319);\n" +" _pos0323 = _pos9*TextureSize.xy;\n" +" _TMP14 = floor(_pos0323);\n" +" _TMP9 = -((_pos0323 - _TMP14) - vec2( 5.00000000E-01, 5.00000000E-01));\n" +" _x0329 = -8.00000000E+00*_TMP9.y*_TMP9.y;\n" +" _TMP326 = exp2(_x0329);\n" +" _pos0333 = _pos9*TextureSize.xy;\n" +" _TMP14 = floor(_pos0333);\n" +" _TMP9 = -((_pos0333 - _TMP14) - vec2( 5.00000000E-01, 5.00000000E-01));\n" +" _pos0337 = _TMP9.y + 1.00000000E+00;\n" +" _x0339 = -8.00000000E+00*_pos0337*_pos0337;\n" +" _TMP336 = exp2(_x0339);\n" +" _outColor = _a0027*_TMP316 + _b0027*_TMP326 + _c0027*_TMP336;\n" +" _x0341 = TEX0.xy*(TextureSize.xy/InputSize.xy)*OutputSize.xy;\n" +" _TMP1 = floor(_x0341);\n" +" _pos0343 = _TMP1 + vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _pos0343.x = _pos0343.x + _pos0343.y*3.00000000E+00;\n" +" _mask0343 = vec3( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01);\n" +" _x0345 = _pos0343.x/6.00000000E+00;\n" +" _TMP344 = fract(_x0345);\n" +" if (_TMP344 < 3.33000004E-01) { \n" +" _mask0343.x = 1.50000000E+00;\n" +" } else {\n" +" if (_TMP344 < 6.66000009E-01) { \n" +" _mask0343.y = 1.50000000E+00;\n" +" } else {\n" +" _mask0343.z = 1.50000000E+00;\n" +" } \n" +" } \n" +" _outColor.xyz = _outColor.xyz*_mask0343;\n" +" if (_outColor.x < 3.13080009E-03) { \n" +" _TMP10 = _outColor.x*1.29200001E+01;\n" +" } else {\n" +" _TMP11 = pow(_outColor.x, 4.16660011E-01);\n" +" _TMP10 = 1.05499995E+00*_TMP11 - 5.49999997E-02;\n" +" } \n" +" _TMP4 = _TMP10;\n" +" if (_outColor.y < 3.13080009E-03) { \n" +" _TMP10 = _outColor.y*1.29200001E+01;\n" +" } else {\n" +" _TMP11 = pow(_outColor.y, 4.16660011E-01);\n" +" _TMP10 = 1.05499995E+00*_TMP11 - 5.49999997E-02;\n" +" } \n" +" _TMP5 = _TMP10;\n" +" if (_outColor.z < 3.13080009E-03) { \n" +" _TMP10 = _outColor.z*1.29200001E+01;\n" +" } else {\n" +" _TMP11 = pow(_outColor.z, 4.16660011E-01);\n" +" _TMP10 = 1.05499995E+00*_TMP11 - 5.49999997E-02;\n" +" } \n" +" _TMP3 = vec3(_TMP4, _TMP5, _TMP10);\n" +" _ret_0 = vec4(_TMP3.x, _TMP3.y, _TMP3.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-reverse-aa.h b/src/video/sdl/shaders/crt/crt-reverse-aa.h new file mode 100644 index 000000000..dee7bd8c4 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-reverse-aa.h @@ -0,0 +1,319 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord2;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord2;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"out_vertex _ret_0;\n" +"input_dummy _IN1;\n" +"vec4 _r0009;\n" +"vec4 _v0009;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" vec2 _ps;\n" +" vec2 _texCoord;\n" +" _v0009 = vec4(float(VertexCoord.x), float(VertexCoord.y), float(VertexCoord.z), float(VertexCoord.w));\n" +" _r0009 = _v0009.x*MVPMatrix[0];\n" +" _r0009 = _r0009 + _v0009.y*MVPMatrix[1];\n" +" _r0009 = _r0009 + _v0009.z*MVPMatrix[2];\n" +" _r0009 = _r0009 + _v0009.w*MVPMatrix[3];\n" +" _OUT._position1 = vec4(float(_r0009.x), float(_r0009.y), float(_r0009.z), float(_r0009.w));\n" +" _ps = vec2(float((1.00000000E+00/TextureSize.x)), float((1.00000000E+00/TextureSize.y)));\n" +" _texCoord = TexCoord.xy + vec2( 1.00000001E-07, 1.00000001E-07);\n" +" _OUT._t1 = _texCoord.xxxy + vec4(float(-_ps.x), 0.00000000E+00, float(_ps.x), float((-2.00000000E+00*_ps.y)));\n" +" _OUT._t2 = _texCoord.xxxy + vec4(float(-_ps.x), 0.00000000E+00, float(_ps.x), float(-_ps.y));\n" +" _OUT._t3 = _texCoord.xxxy + vec4(float(-_ps.x), 0.00000000E+00, float(_ps.x), 0.00000000E+00);\n" +" _OUT._t4 = _texCoord.xxxy + vec4(float(-_ps.x), 0.00000000E+00, float(_ps.x), float(_ps.y));\n" +" _OUT._t5 = _texCoord.xxxy + vec4(float(-_ps.x), 0.00000000E+00, float(_ps.x), float((2.00000000E+00*_ps.y)));\n" +" _OUT._t6 = _texCoord.xyyy + vec4(float((-2.00000000E+00*_ps.x)), float(-_ps.y), 0.00000000E+00, float(_ps.y));\n" +" _OUT._t7 = _texCoord.xyyy + vec4(float((2.00000000E+00*_ps.x)), float(-_ps.y), 0.00000000E+00, float(_ps.y));\n" +" _ret_0._position1 = _OUT._position1;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord2 = _texCoord;\n" +" _ret_0._t1 = _OUT._t1;\n" +" _ret_0._t2 = _OUT._t2;\n" +" _ret_0._t3 = _OUT._t3;\n" +" _ret_0._t4 = _OUT._t4;\n" +" _ret_0._t5 = _OUT._t5;\n" +" _ret_0._t6 = _OUT._t6;\n" +" _ret_0._t7 = _OUT._t7;\n" +" gl_Position = _OUT._position1;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _texCoord;\n" +" TEX1 = _OUT._t1;\n" +" TEX2 = _OUT._t2;\n" +" TEX3 = _OUT._t3;\n" +" TEX4 = _OUT._t4;\n" +" TEX5 = _OUT._t5;\n" +" TEX6 = _OUT._t6;\n" +" TEX7 = _OUT._t7;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord2;\n" +" TEX1 = _ret_0._t1;\n" +" TEX2 = _ret_0._t2;\n" +" TEX3 = _ret_0._t3;\n" +" TEX4 = _ret_0._t4;\n" +" TEX5 = _ret_0._t5;\n" +" TEX6 = _ret_0._t6;\n" +" TEX7 = _ret_0._t7;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color1;\n" +" vec2 _texCoord;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP11;\n" +"vec3 _TMP17;\n" +"float _TMP16;\n" +"float _TMP15;\n" +"float _TMP14;\n" +"vec3 _TMP13;\n" +"vec3 _TMP10;\n" +"vec3 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _x0023;\n" +"vec3 _b0045;\n" +"vec3 _b0049;\n" +"vec3 _TMP50;\n" +"vec3 _a0051;\n" +"vec3 _TMP80;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _fp;\n" +" vec3 _B;\n" +" vec3 _D;\n" +" vec3 _E;\n" +" vec3 _F;\n" +" vec3 _H;\n" +" vec3 _D0;\n" +" vec3 _F4;\n" +" vec3 _n1;\n" +" vec3 _n2;\n" +" vec3 _n3;\n" +" vec3 _n4;\n" +" vec3 _s;\n" +" vec3 _aa;\n" +" vec3 _bb;\n" +" vec3 _cc;\n" +" vec3 _dd;\n" +" vec3 _t;\n" +" vec3 _m;\n" +" vec3 _res;\n" +" vec3 _color;\n" +" float _ddy;\n" +" float _v_weight_00;\n" +" vec3 _coords10;\n" +" vec3 _colorNB;\n" +" float _v_weight_10;\n" +" _x0023 = TEX0.xy*TextureSize;\n" +" _fp = fract(_x0023);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, TEX2.yw);\n" +" _B = vec3(float(_TMP1.x), float(_TMP1.y), float(_TMP1.z));\n" +" _TMP2 = COMPAT_TEXTURE(Texture, TEX3.xw);\n" +" _D = vec3(float(_TMP2.x), float(_TMP2.y), float(_TMP2.z));\n" +" _TMP3 = COMPAT_TEXTURE(Texture, TEX3.yw);\n" +" _E = vec3(float(_TMP3.x), float(_TMP3.y), float(_TMP3.z));\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX3.zw);\n" +" _F = vec3(float(_TMP4.x), float(_TMP4.y), float(_TMP4.z));\n" +" _TMP5 = COMPAT_TEXTURE(Texture, TEX4.yw);\n" +" _H = vec3(float(_TMP5.x), float(_TMP5.y), float(_TMP5.z));\n" +" _TMP7 = COMPAT_TEXTURE(Texture, TEX6.xz);\n" +" _D0 = vec3(float(_TMP7.x), float(_TMP7.y), float(_TMP7.z));\n" +" _TMP8 = COMPAT_TEXTURE(Texture, TEX7.xz);\n" +" _F4 = vec3(float(_TMP8.x), float(_TMP8.y), float(_TMP8.z));\n" +" _n1 = vec3(float(_D0.x), float(_D0.y), float(_D0.z));\n" +" _n2 = vec3(float(_D.x), float(_D.y), float(_D.z));\n" +" _s = vec3(float(_E.x), float(_E.y), float(_E.z));\n" +" _n3 = vec3(float(_F.x), float(_F.y), float(_F.z));\n" +" _n4 = vec3(float(_F4.x), float(_F4.y), float(_F4.z));\n" +" _aa = _n2 - _n1;\n" +" _bb = _s - _n2;\n" +" _cc = _n3 - _s;\n" +" _dd = _n4 - _n3;\n" +" _t = (7.00000000E+00*(_bb + _cc) - 3.00000000E+00*(_aa + _dd))/1.60000000E+01;\n" +" _m = vec3(_s.x < 5.00000000E-01 ? (2.00000000E+00*_s).x : (2.00000000E+00*(1.00000000E+00 - _s)).x, _s.y < 5.00000000E-01 ? (2.00000000E+00*_s).y : (2.00000000E+00*(1.00000000E+00 - _s)).y, _s.z < 5.00000000E-01 ? (2.00000000E+00*_s).z : (2.00000000E+00*(1.00000000E+00 - _s)).z);\n" +" _TMP9 = abs(_bb);\n" +" _b0045 = 2.00000000E+00*_TMP9 + 9.99999978E-03;\n" +" _m = min(_m, _b0045);\n" +" _TMP10 = abs(_cc);\n" +" _b0049 = 2.00000000E+00*_TMP10 + 9.99999978E-03;\n" +" _m = min(_m, _b0049);\n" +" _a0051 = -_m;\n" +" _TMP13 = min(_m, _t);\n" +" _TMP50 = max(_a0051, _TMP13);\n" +" _res = (2.00000000E+00*_fp.x - 1.00000000E+00)*_TMP50 + _s;\n" +" _TMP14 = pow(_res.x, 2.40000010E+00);\n" +" _TMP15 = pow(_res.y, 2.40000010E+00);\n" +" _TMP16 = pow(_res.z, 2.40000010E+00);\n" +" _color = vec3(_TMP14, _TMP15, _TMP16);\n" +" _ddy = _fp.y - 5.00000000E-01;\n" +" _v_weight_00 = _ddy/6.00000024E-01;\n" +" if (_v_weight_00 > 1.00000000E+00) { \n" +" _v_weight_00 = 1.00000000E+00;\n" +" } \n" +" _v_weight_00 = 1.00000000E+00 - _v_weight_00*_v_weight_00;\n" +" _v_weight_00 = _v_weight_00*_v_weight_00;\n" +" _color = _color*vec3(_v_weight_00, _v_weight_00, _v_weight_00);\n" +" if (_ddy > 0.00000000E+00) { \n" +" _coords10 = vec3(float(_H.x), float(_H.y), float(_H.z));\n" +" _ddy = 1.00000000E+00 - _ddy;\n" +" } else {\n" +" _coords10 = vec3(float(_B.x), float(_B.y), float(_B.z));\n" +" _ddy = 1.00000000E+00 + _ddy;\n" +" } \n" +" _TMP14 = pow(_coords10.x, 2.40000010E+00);\n" +" _TMP15 = pow(_coords10.y, 2.40000010E+00);\n" +" _TMP16 = pow(_coords10.z, 2.40000010E+00);\n" +" _colorNB = vec3(_TMP14, _TMP15, _TMP16);\n" +" _v_weight_10 = _ddy/6.00000024E-01;\n" +" if (_v_weight_10 > 1.00000000E+00) { \n" +" _v_weight_10 = 1.00000000E+00;\n" +" } \n" +" _v_weight_10 = 1.00000000E+00 - _v_weight_10*_v_weight_10;\n" +" _v_weight_10 = _v_weight_10*_v_weight_10;\n" +" _color = _color + _colorNB*vec3(_v_weight_10, _v_weight_10, _v_weight_10);\n" +" _color = _color*vec3( 1.39999998E+00, 1.39999998E+00, 1.39999998E+00);\n" +" _TMP14 = pow(_color.x, 4.54545438E-01);\n" +" _TMP15 = pow(_color.y, 4.54545438E-01);\n" +" _TMP16 = pow(_color.z, 4.54545438E-01);\n" +" _TMP11 = vec3(_TMP14, _TMP15, _TMP16);\n" +" _TMP17 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _TMP11);\n" +" _TMP80 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP17);\n" +" _ret_0 = vec4(_TMP80.x, _TMP80.y, _TMP80.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-royale/crt-royale-first-pass-linearize-crt-gamma-bob-fields.h b/src/video/sdl/shaders/crt/crt-royale/crt-royale-first-pass-linearize-crt-gamma-bob-fields.h new file mode 100644 index 000000000..9bc25c6f6 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-royale/crt-royale-first-pass-linearize-crt-gamma-bob-fields.h @@ -0,0 +1,214 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _interlaced;\n" +"COMPAT_VARYING vec2 _uv_step;\n" +"COMPAT_VARYING vec2 _tex_uv1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size1;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec2 _tex_uv1;\n" +" vec2 _uv_step;\n" +" float _interlaced;\n" +"};\n" +"out_vertex _ret_0;\n" +"bool _TMP13;\n" +"input_dummy _IN1;\n" +"vec4 _r0221;\n" +"bool _sd_interlace10223;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" _r0221 = VertexCoord.x*MVPMatrix[0];\n" +" _r0221 = _r0221 + VertexCoord.y*MVPMatrix[1];\n" +" _r0221 = _r0221 + VertexCoord.z*MVPMatrix[2];\n" +" _r0221 = _r0221 + VertexCoord.w*MVPMatrix[3];\n" +" _OUT._uv_step = vec2( 1.00000000E+00, 1.00000000E+00)/TextureSize;\n" +" _sd_interlace10223 = InputSize.y > 2.88500000E+02 && InputSize.y < 5.76500000E+02;\n" +" _TMP13 = _sd_interlace10223 || false;\n" +" _OUT._interlaced = float(_TMP13);\n" +" _ret_0._position1 = _r0221;\n" +" _ret_0._tex_uv1 = TexCoord.xy;\n" +" _ret_0._uv_step = _OUT._uv_step;\n" +" _ret_0._interlaced = _OUT._interlaced;\n" +" gl_Position = _r0221;\n" +" TEX0.xy = TexCoord.xy;\n" +" TEX1.xy = _OUT._uv_step;\n" +" TEX2.x = _OUT._interlaced;\n" +" return;\n" +" TEX0.xy = _ret_0._tex_uv1;\n" +" TEX1.xy = _ret_0._uv_step;\n" +" TEX2.x = _ret_0._interlaced;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _interlaced;\n" +"COMPAT_VARYING vec2 _uv_step;\n" +"COMPAT_VARYING vec2 _tex_uv;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec2 _tex_uv;\n" +" vec2 _uv_step;\n" +" float _interlaced;\n" +"};\n" +"float _TMP21;\n" +"float _TMP20;\n" +"float _TMP19;\n" +"float _TMP18;\n" +"vec4 _TMP17;\n" +"vec3 _TMP23;\n" +"float _TMP26;\n" +"float _TMP25;\n" +"float _TMP24;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec4 _TMP232;\n" +"vec4 _TMP252;\n" +"vec2 _tex_coords0253;\n" +"vec4 _TMP272;\n" +"vec2 _tex_coords0273;\n" +"float _c0293;\n" +"float _a0295;\n" +"float _x0301;\n" +"float _a0303;\n" +"float _c0303;\n" +"float _a0305;\n" +"vec4 _color0313;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"float _crt_gamma;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _v_step1;\n" +" vec3 _interpolated_line1;\n" +" float _modulus1;\n" +" float _curr_line_texel1;\n" +" float _line_num_last1;\n" +" vec3 _color11;\n" +" _crt_gamma = max(0.00000000E+00, 2.50000000E+00);\n" +" _v_step1 = vec2(0.00000000E+00, TEX1.y);\n" +" _TMP17 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP24 = pow(_TMP17.x, _crt_gamma);\n" +" _TMP25 = pow(_TMP17.y, _crt_gamma);\n" +" _TMP26 = pow(_TMP17.z, _crt_gamma);\n" +" _TMP23 = vec3(_TMP24, _TMP25, _TMP26);\n" +" _TMP232 = vec4(_TMP23.x, _TMP23.y, _TMP23.z, _TMP17.w);\n" +" _tex_coords0253 = TEX0.xy - _v_step1;\n" +" _TMP17 = COMPAT_TEXTURE(Texture, _tex_coords0253);\n" +" _TMP24 = pow(_TMP17.x, _crt_gamma);\n" +" _TMP25 = pow(_TMP17.y, _crt_gamma);\n" +" _TMP26 = pow(_TMP17.z, _crt_gamma);\n" +" _TMP23 = vec3(_TMP24, _TMP25, _TMP26);\n" +" _TMP252 = vec4(_TMP23.x, _TMP23.y, _TMP23.z, _TMP17.w);\n" +" _tex_coords0273 = TEX0.xy + _v_step1;\n" +" _TMP17 = COMPAT_TEXTURE(Texture, _tex_coords0273);\n" +" _TMP24 = pow(_TMP17.x, _crt_gamma);\n" +" _TMP25 = pow(_TMP17.y, _crt_gamma);\n" +" _TMP26 = pow(_TMP17.z, _crt_gamma);\n" +" _TMP23 = vec3(_TMP24, _TMP25, _TMP26);\n" +" _TMP272 = vec4(_TMP23.x, _TMP23.y, _TMP23.z, _TMP17.w);\n" +" _interpolated_line1 = 5.00000000E-01*(_TMP252.xyz + _TMP272.xyz);\n" +" _modulus1 = TEX2.x + 1.00000000E+00;\n" +" _a0295 = float(FrameCount)/_modulus1;\n" +" _TMP18 = abs(_a0295);\n" +" _TMP19 = fract(_TMP18);\n" +" _TMP20 = abs(_modulus1);\n" +" _c0293 = _TMP19*_TMP20;\n" +" if (float(FrameCount) < 0.00000000E+00) { \n" +" _TMP21 = -_c0293;\n" +" } else {\n" +" _TMP21 = _c0293;\n" +" } \n" +" _curr_line_texel1 = TEX0.y*TextureSize.y;\n" +" _x0301 = _curr_line_texel1 - 4.99500006E-01;\n" +" _line_num_last1 = floor(_x0301);\n" +" _a0303 = _line_num_last1 + _TMP21;\n" +" _a0305 = _a0303/_modulus1;\n" +" _TMP18 = abs(_a0305);\n" +" _TMP19 = fract(_TMP18);\n" +" _TMP20 = abs(_modulus1);\n" +" _c0303 = _TMP19*_TMP20;\n" +" if (_a0303 < 0.00000000E+00) { \n" +" _TMP21 = -_c0303;\n" +" } else {\n" +" _TMP21 = _c0303;\n" +" } \n" +" _color11 = _TMP232.xyz + _TMP21*(_interpolated_line1 - _TMP232.xyz);\n" +" _color0313 = vec4(_color11.x, _color11.y, _color11.z, 1.00000000E+00);\n" +" FragColor = _color0313;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/crt-royale/crt-royale-scanlines-vertical-interlacing.h b/src/video/sdl/shaders/crt/crt-royale/crt-royale-scanlines-vertical-interlacing.h new file mode 100644 index 000000000..55d05e5f3 --- /dev/null +++ b/src/video/sdl/shaders/crt/crt-royale/crt-royale-scanlines-vertical-interlacing.h @@ -0,0 +1,564 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _pixel_height_in_scanlines;\n" +"COMPAT_VARYING vec2 _il_step_multiple;\n" +"COMPAT_VARYING vec2 _uv_step;\n" +"COMPAT_VARYING vec2 _tex_uv1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct orig {\n" +" vec2 _tex_coord;\n" +" vec2 _video_size2;\n" +" vec2 _texture_size1;\n" +" vec2 _output_dummy_size1;\n" +"float _placeholder32;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size1;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec2 _tex_uv1;\n" +" vec2 _uv_step;\n" +" vec2 _il_step_multiple;\n" +" float _pixel_height_in_scanlines;\n" +"};\n" +"out_vertex _ret_0;\n" +"bool _TMP13;\n" +"input_dummy _IN1;\n" +"vec4 _r0223;\n" +"bool _sd_interlace10225;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" float _y_step;\n" +" float _ph;\n" +" _r0223 = VertexCoord.x*MVPMatrix[0];\n" +" _r0223 = _r0223 + VertexCoord.y*MVPMatrix[1];\n" +" _r0223 = _r0223 + VertexCoord.z*MVPMatrix[2];\n" +" _r0223 = _r0223 + VertexCoord.w*MVPMatrix[3];\n" +" _sd_interlace10225 = InputSize.y > 2.88500000E+02 && InputSize.y < 5.76500000E+02;\n" +" _TMP13 = _sd_interlace10225 || false;\n" +" _y_step = 1.00000000E+00 + float(_TMP13);\n" +" _OUT._il_step_multiple = vec2(1.00000000E+00, _y_step);\n" +" _OUT._uv_step = _OUT._il_step_multiple/TextureSize;\n" +" _ph = (InputSize.y/OutputSize.y)/_OUT._il_step_multiple.y;\n" +" _ret_0._position1 = _r0223;\n" +" _ret_0._tex_uv1 = TexCoord.xy;\n" +" _ret_0._uv_step = _OUT._uv_step;\n" +" _ret_0._il_step_multiple = _OUT._il_step_multiple;\n" +" _ret_0._pixel_height_in_scanlines = _ph;\n" +" gl_Position = _r0223;\n" +" TEX0.xy = TexCoord.xy;\n" +" TEX1.xy = _OUT._uv_step;\n" +" TEX2.xy = _OUT._il_step_multiple;\n" +" TEX3.x = _ph;\n" +" return;\n" +" TEX0.xy = _ret_0._tex_uv1;\n" +" TEX1.xy = _ret_0._uv_step;\n" +" TEX2.xy = _ret_0._il_step_multiple;\n" +" TEX3.x = _ret_0._pixel_height_in_scanlines;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _pixel_height_in_scanlines;\n" +"COMPAT_VARYING vec2 _il_step_multiple2;\n" +"COMPAT_VARYING vec2 _uv_step1;\n" +"COMPAT_VARYING vec2 _tex_uv1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct orig {\n" +" vec2 _tex_coord;\n" +" vec2 _video_size1;\n" +" vec2 _texture_size3;\n" +" vec2 _output_dummy_size1;\n" +"float _placeholder29;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size2;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count2;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec2 _tex_uv1;\n" +" vec2 _uv_step1;\n" +" vec2 _il_step_multiple2;\n" +" float _pixel_height_in_scanlines;\n" +"};\n" +"vec3 _TMP35;\n" +"float _TMP42;\n" +"float _TMP41;\n" +"float _TMP40;\n" +"vec3 _TMP34;\n" +"vec3 _TMP33;\n" +"vec3 _TMP32;\n" +"vec3 _TMP31;\n" +"vec3 _TMP30;\n" +"vec3 _TMP29;\n" +"vec3 _TMP39;\n" +"vec3 _TMP38;\n" +"vec3 _TMP28;\n" +"float _TMP27;\n" +"vec3 _TMP37;\n" +"float _TMP36;\n" +"vec3 _TMP17;\n" +"float _TMP16;\n" +"float _TMP15;\n" +"vec4 _TMP22;\n" +"vec4 _TMP13;\n" +"vec4 _TMP12;\n" +"float _TMP26;\n" +"float _TMP25;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP20;\n" +"float _TMP19;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"input_dummy _IN1;\n" +"uniform sampler2D Texture;\n" +"float _TMP137;\n" +"float _TMP143;\n" +"float _TMP149;\n" +"float _field_offset0248;\n" +"vec2 _curr_texel0248;\n" +"vec2 _prev_texel_num0248;\n" +"vec2 _scanline_texel_num0248;\n" +"vec2 _scanline_texel0248;\n" +"vec2 _scanline_uv0248;\n" +"float _dist0248;\n" +"float _x0250;\n" +"float _c0252;\n" +"float _a0254;\n" +"vec2 _x0260;\n" +"float _a0262;\n" +"float _c0262;\n" +"float _a0264;\n" +"vec2 _tex_coords0276;\n" +"float _TMP281;\n" +"float _x0284;\n" +"vec2 _a0286;\n" +"vec2 _b0286;\n" +"vec2 _tex_coords0288;\n" +"vec3 _TMP299;\n" +"vec3 _alpha0302;\n" +"vec3 _beta0302;\n" +"vec3 _alpha_inv0302;\n" +"vec3 _beta_inv0302;\n" +"vec3 _scale0302;\n" +"vec3 _sample_offset10302;\n" +"vec3 _dist210302;\n" +"vec3 _dist310302;\n" +"vec3 _sph0328;\n" +"vec3 _lanczos_sum0328;\n" +"vec3 _base0328;\n" +"vec3 _a0338;\n" +"vec3 _a0340;\n" +"vec3 _TMP349;\n" +"vec3 _x0350;\n" +"vec3 _a0360;\n" +"vec3 _TMP369;\n" +"vec3 _x0370;\n" +"vec3 _a0380;\n" +"vec3 _TMP389;\n" +"vec3 _x0390;\n" +"vec3 _a0400;\n" +"vec3 _TMP401;\n" +"vec3 _alpha0404;\n" +"vec3 _beta0404;\n" +"vec3 _alpha_inv0404;\n" +"vec3 _beta_inv0404;\n" +"vec3 _scale0404;\n" +"vec3 _sample_offset10404;\n" +"vec3 _dist210404;\n" +"vec3 _dist310404;\n" +"vec3 _sph0430;\n" +"vec3 _lanczos_sum0430;\n" +"vec3 _base0430;\n" +"vec3 _a0440;\n" +"vec3 _a0442;\n" +"vec3 _TMP451;\n" +"vec3 _x0452;\n" +"vec3 _a0462;\n" +"vec3 _TMP471;\n" +"vec3 _x0472;\n" +"vec3 _a0482;\n" +"vec3 _TMP491;\n" +"vec3 _x0492;\n" +"vec3 _a0502;\n" +"vec3 _b0502;\n" +"vec3 _TMP503;\n" +"vec3 _alpha0506;\n" +"vec3 _beta0506;\n" +"vec3 _alpha_inv0506;\n" +"vec3 _beta_inv0506;\n" +"vec3 _scale0506;\n" +"vec3 _sample_offset10506;\n" +"vec3 _dist210506;\n" +"vec3 _dist310506;\n" +"vec3 _sph0532;\n" +"vec3 _lanczos_sum0532;\n" +"vec3 _base0532;\n" +"vec3 _a0542;\n" +"vec3 _a0544;\n" +"vec3 _TMP553;\n" +"vec3 _x0554;\n" +"vec3 _a0564;\n" +"vec3 _TMP573;\n" +"vec3 _x0574;\n" +"vec3 _a0584;\n" +"vec3 _TMP593;\n" +"vec3 _x0594;\n" +"vec4 _color0604;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"float _beam_min_sigma;\n" +"float _beam_max_sigma;\n" +"float _beam_spot_power;\n" +"float _beam_min_shape;\n" +"float _beam_max_shape;\n" +"float _beam_shape_power;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _texture_size_inv1;\n" +" vec2 _v_step;\n" +" vec2 _sample_1or4_uv_off1;\n" +" vec3 _dist22;\n" +" vec3 _convergence_offsets_vert_rgb1;\n" +" float _sigma_range3;\n" +" float _shape_range3;\n" +" vec3 _scanline_intensity;\n" +" vec3 _dist1or41;\n" +" vec3 _TMP46;\n" +" _TMP2 = abs(0.00000000E+00);\n" +" _TMP3 = max(_TMP2, 1.52587891E-05);\n" +" _beam_min_sigma = max(_TMP3, 1.99999996E-02);\n" +" _beam_max_sigma = max(_beam_min_sigma, 3.00000012E-01);\n" +" _beam_spot_power = max(3.33333343E-01, 0.00000000E+00);\n" +" _beam_min_shape = max(2.00000000E+00, 2.00000000E+00);\n" +" _beam_max_shape = max(_beam_min_shape, 4.00000000E+00);\n" +" _beam_shape_power = max(0.00000000E+00, 2.50000000E-01);\n" +" _TMP19 = min(4.00000000E+00, 2.00000003E-01);\n" +" _TMP137 = max(-4.00000000E+00, _TMP19);\n" +" _TMP19 = min(4.00000000E+00, 4.00000006E-01);\n" +" _TMP143 = max(-4.00000000E+00, _TMP19);\n" +" _TMP19 = min(4.00000000E+00, 6.00000024E-01);\n" +" _TMP149 = max(-4.00000000E+00, _TMP19);\n" +" _texture_size_inv1 = 1.00000000E+00/TextureSize;\n" +" _x0250 = TEX2.y*7.50000000E-01;\n" +" _TMP20 = floor(_x0250);\n" +" _a0254 = float(FrameCount)/2.00000000E+00;\n" +" _TMP23 = abs(_a0254);\n" +" _TMP24 = fract(_TMP23);\n" +" _TMP25 = abs(2.00000000E+00);\n" +" _c0252 = _TMP24*_TMP25;\n" +" if (float(FrameCount) < 0.00000000E+00) { \n" +" _TMP26 = -_c0252;\n" +" } else {\n" +" _TMP26 = _c0252;\n" +" } \n" +" _field_offset0248 = _TMP20*_TMP26;\n" +" _curr_texel0248 = TEX0.xy*TextureSize;\n" +" _x0260 = _curr_texel0248 - vec2( 4.99500006E-01, 4.99500006E-01);\n" +" _prev_texel_num0248 = floor(_x0260);\n" +" _a0262 = _prev_texel_num0248.y + _field_offset0248;\n" +" _a0264 = _a0262/TEX2.y;\n" +" _TMP23 = abs(_a0264);\n" +" _TMP24 = fract(_TMP23);\n" +" _TMP25 = abs(TEX2.y);\n" +" _c0262 = _TMP24*_TMP25;\n" +" if (_a0262 < 0.00000000E+00) { \n" +" _TMP26 = -_c0262;\n" +" } else {\n" +" _TMP26 = _c0262;\n" +" } \n" +" _scanline_texel_num0248 = _prev_texel_num0248 - vec2(0.00000000E+00, _TMP26);\n" +" _scanline_texel0248 = _scanline_texel_num0248 + vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _scanline_uv0248 = _scanline_texel0248*_texture_size_inv1;\n" +" _dist0248 = (_curr_texel0248.y - _scanline_texel0248.y)/TEX2.y;\n" +" _v_step = vec2(0.00000000E+00, TEX1.y);\n" +" _TMP22 = COMPAT_TEXTURE(Texture, _scanline_uv0248);\n" +" _TMP12 = _TMP22;\n" +" _tex_coords0276 = _scanline_uv0248 + _v_step;\n" +" _TMP22 = COMPAT_TEXTURE(Texture, _tex_coords0276);\n" +" _TMP13 = _TMP22;\n" +" _x0284 = _dist0248 + 5.00000000E-01;\n" +" _TMP281 = floor(_x0284);\n" +" _a0286 = -_v_step;\n" +" _b0286 = 2.00000000E+00*_v_step;\n" +" _sample_1or4_uv_off1 = _a0286 + _TMP281*(_b0286 - _a0286);\n" +" _tex_coords0288 = _scanline_uv0248 + _sample_1or4_uv_off1;\n" +" _TMP22 = COMPAT_TEXTURE(Texture, _tex_coords0288);\n" +" _convergence_offsets_vert_rgb1 = vec3(_TMP137, _TMP143, _TMP149);\n" +" _dist22 = vec3(_dist0248, _dist0248, _dist0248) - _convergence_offsets_vert_rgb1;\n" +" _TMP15 = max(_beam_max_sigma, _beam_min_sigma);\n" +" _sigma_range3 = _TMP15 - _beam_min_sigma;\n" +" _TMP16 = max(_beam_max_shape, _beam_min_shape);\n" +" _shape_range3 = _TMP16 - _beam_min_shape;\n" +" _TMP36 = inversesqrt(2.00000000E+00);\n" +" _TMP27 = 1.00000000E+00/_TMP36;\n" +" _TMP40 = pow(_TMP12.x, _beam_spot_power);\n" +" _TMP41 = pow(_TMP12.y, _beam_spot_power);\n" +" _TMP42 = pow(_TMP12.z, _beam_spot_power);\n" +" _TMP37 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP28 = vec3(_beam_min_sigma, _beam_min_sigma, _beam_min_sigma) + _sigma_range3*_TMP37;\n" +" _alpha0302 = _TMP27*_TMP28;\n" +" _TMP40 = pow(_TMP12.x, _beam_shape_power);\n" +" _TMP41 = pow(_TMP12.y, _beam_shape_power);\n" +" _TMP42 = pow(_TMP12.z, _beam_shape_power);\n" +" _TMP38 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _beta0302 = _beam_min_shape + _shape_range3*_TMP38;\n" +" _alpha_inv0302 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00)/_alpha0302;\n" +" _beta_inv0302 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00)/_beta0302;\n" +" _sph0328 = _beta_inv0302 + vec3( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01);\n" +" _lanczos_sum0328 = vec3( 8.10911953E-01, 8.10911953E-01, 8.10911953E-01) + vec3( 4.80835468E-01, 4.80835468E-01, 4.80835468E-01)/(_beta_inv0302 + vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _base0328 = (_sph0328 + vec3( 1.12906826E+00, 1.12906826E+00, 1.12906826E+00))/vec3( 2.71828175E+00, 2.71828175E+00, 2.71828175E+00);\n" +" _TMP40 = pow(_base0328.x, _sph0328.x);\n" +" _TMP41 = pow(_base0328.y, _sph0328.y);\n" +" _TMP42 = pow(_base0328.z, _sph0328.z);\n" +" _TMP39 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP29 = _TMP39*_lanczos_sum0328*_beta0302;\n" +" _scale0302 = (((_TMP12.xyz*_beta0302)*5.00000000E-01)*_alpha_inv0302)/_TMP29;\n" +" _sample_offset10302 = vec3(TEX3.x/3.00000000E+00, TEX3.x/3.00000000E+00, TEX3.x/3.00000000E+00);\n" +" _dist210302 = _dist22 + _sample_offset10302;\n" +" _a0338 = _dist22 - _sample_offset10302;\n" +" _dist310302 = abs(_a0338);\n" +" _a0340 = _dist22*_alpha_inv0302;\n" +" _TMP30 = abs(_a0340);\n" +" _TMP40 = pow(_TMP30.x, _beta0302.x);\n" +" _TMP41 = pow(_TMP30.y, _beta0302.y);\n" +" _TMP42 = pow(_TMP30.z, _beta0302.z);\n" +" _TMP31 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0350 = -_TMP31;\n" +" _TMP40 = pow(2.71828198E+00, _x0350.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0350.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0350.z);\n" +" _TMP349 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _a0360 = _dist210302*_alpha_inv0302;\n" +" _TMP32 = abs(_a0360);\n" +" _TMP40 = pow(_TMP32.x, _beta0302.x);\n" +" _TMP41 = pow(_TMP32.y, _beta0302.y);\n" +" _TMP42 = pow(_TMP32.z, _beta0302.z);\n" +" _TMP33 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0370 = -_TMP33;\n" +" _TMP40 = pow(2.71828198E+00, _x0370.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0370.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0370.z);\n" +" _TMP369 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _a0380 = _dist310302*_alpha_inv0302;\n" +" _TMP34 = abs(_a0380);\n" +" _TMP40 = pow(_TMP34.x, _beta0302.x);\n" +" _TMP41 = pow(_TMP34.y, _beta0302.y);\n" +" _TMP42 = pow(_TMP34.z, _beta0302.z);\n" +" _TMP35 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0390 = -_TMP35;\n" +" _TMP40 = pow(2.71828198E+00, _x0390.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0390.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0390.z);\n" +" _TMP389 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP299 = (_scale0302/3.00000000E+00)*(_TMP349 + _TMP369 + _TMP389);\n" +" _a0400 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) - _dist22;\n" +" _TMP17 = abs(_a0400);\n" +" _TMP36 = inversesqrt(2.00000000E+00);\n" +" _TMP27 = 1.00000000E+00/_TMP36;\n" +" _TMP40 = pow(_TMP13.x, _beam_spot_power);\n" +" _TMP41 = pow(_TMP13.y, _beam_spot_power);\n" +" _TMP42 = pow(_TMP13.z, _beam_spot_power);\n" +" _TMP37 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP28 = vec3(_beam_min_sigma, _beam_min_sigma, _beam_min_sigma) + _sigma_range3*_TMP37;\n" +" _alpha0404 = _TMP27*_TMP28;\n" +" _TMP40 = pow(_TMP13.x, _beam_shape_power);\n" +" _TMP41 = pow(_TMP13.y, _beam_shape_power);\n" +" _TMP42 = pow(_TMP13.z, _beam_shape_power);\n" +" _TMP38 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _beta0404 = _beam_min_shape + _shape_range3*_TMP38;\n" +" _alpha_inv0404 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00)/_alpha0404;\n" +" _beta_inv0404 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00)/_beta0404;\n" +" _sph0430 = _beta_inv0404 + vec3( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01);\n" +" _lanczos_sum0430 = vec3( 8.10911953E-01, 8.10911953E-01, 8.10911953E-01) + vec3( 4.80835468E-01, 4.80835468E-01, 4.80835468E-01)/(_beta_inv0404 + vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _base0430 = (_sph0430 + vec3( 1.12906826E+00, 1.12906826E+00, 1.12906826E+00))/vec3( 2.71828175E+00, 2.71828175E+00, 2.71828175E+00);\n" +" _TMP40 = pow(_base0430.x, _sph0430.x);\n" +" _TMP41 = pow(_base0430.y, _sph0430.y);\n" +" _TMP42 = pow(_base0430.z, _sph0430.z);\n" +" _TMP39 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP29 = _TMP39*_lanczos_sum0430*_beta0404;\n" +" _scale0404 = (((_TMP13.xyz*_beta0404)*5.00000000E-01)*_alpha_inv0404)/_TMP29;\n" +" _sample_offset10404 = vec3(TEX3.x/3.00000000E+00, TEX3.x/3.00000000E+00, TEX3.x/3.00000000E+00);\n" +" _dist210404 = _TMP17 + _sample_offset10404;\n" +" _a0440 = _TMP17 - _sample_offset10404;\n" +" _dist310404 = abs(_a0440);\n" +" _a0442 = _TMP17*_alpha_inv0404;\n" +" _TMP30 = abs(_a0442);\n" +" _TMP40 = pow(_TMP30.x, _beta0404.x);\n" +" _TMP41 = pow(_TMP30.y, _beta0404.y);\n" +" _TMP42 = pow(_TMP30.z, _beta0404.z);\n" +" _TMP31 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0452 = -_TMP31;\n" +" _TMP40 = pow(2.71828198E+00, _x0452.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0452.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0452.z);\n" +" _TMP451 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _a0462 = _dist210404*_alpha_inv0404;\n" +" _TMP32 = abs(_a0462);\n" +" _TMP40 = pow(_TMP32.x, _beta0404.x);\n" +" _TMP41 = pow(_TMP32.y, _beta0404.y);\n" +" _TMP42 = pow(_TMP32.z, _beta0404.z);\n" +" _TMP33 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0472 = -_TMP33;\n" +" _TMP40 = pow(2.71828198E+00, _x0472.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0472.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0472.z);\n" +" _TMP471 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _a0482 = _dist310404*_alpha_inv0404;\n" +" _TMP34 = abs(_a0482);\n" +" _TMP40 = pow(_TMP34.x, _beta0404.x);\n" +" _TMP41 = pow(_TMP34.y, _beta0404.y);\n" +" _TMP42 = pow(_TMP34.z, _beta0404.z);\n" +" _TMP35 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0492 = -_TMP35;\n" +" _TMP40 = pow(2.71828198E+00, _x0492.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0492.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0492.z);\n" +" _TMP491 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP401 = (_scale0404/3.00000000E+00)*(_TMP451 + _TMP471 + _TMP491);\n" +" _scanline_intensity = _TMP299 + _TMP401;\n" +" _a0502 = _dist22 + vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00);\n" +" _b0502 = vec3( 2.00000000E+00, 2.00000000E+00, 2.00000000E+00) - _dist22;\n" +" _dist1or41 = _a0502 + _TMP281*(_b0502 - _a0502);\n" +" _TMP36 = inversesqrt(2.00000000E+00);\n" +" _TMP27 = 1.00000000E+00/_TMP36;\n" +" _TMP40 = pow(_TMP22.x, _beam_spot_power);\n" +" _TMP41 = pow(_TMP22.y, _beam_spot_power);\n" +" _TMP42 = pow(_TMP22.z, _beam_spot_power);\n" +" _TMP37 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP28 = vec3(_beam_min_sigma, _beam_min_sigma, _beam_min_sigma) + _sigma_range3*_TMP37;\n" +" _alpha0506 = _TMP27*_TMP28;\n" +" _TMP40 = pow(_TMP22.x, _beam_shape_power);\n" +" _TMP41 = pow(_TMP22.y, _beam_shape_power);\n" +" _TMP42 = pow(_TMP22.z, _beam_shape_power);\n" +" _TMP38 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _beta0506 = _beam_min_shape + _shape_range3*_TMP38;\n" +" _alpha_inv0506 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00)/_alpha0506;\n" +" _beta_inv0506 = vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00)/_beta0506;\n" +" _sph0532 = _beta_inv0506 + vec3( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01);\n" +" _lanczos_sum0532 = vec3( 8.10911953E-01, 8.10911953E-01, 8.10911953E-01) + vec3( 4.80835468E-01, 4.80835468E-01, 4.80835468E-01)/(_beta_inv0506 + vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _base0532 = (_sph0532 + vec3( 1.12906826E+00, 1.12906826E+00, 1.12906826E+00))/vec3( 2.71828175E+00, 2.71828175E+00, 2.71828175E+00);\n" +" _TMP40 = pow(_base0532.x, _sph0532.x);\n" +" _TMP41 = pow(_base0532.y, _sph0532.y);\n" +" _TMP42 = pow(_base0532.z, _sph0532.z);\n" +" _TMP39 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP29 = _TMP39*_lanczos_sum0532*_beta0506;\n" +" _scale0506 = (((_TMP22.xyz*_beta0506)*5.00000000E-01)*_alpha_inv0506)/_TMP29;\n" +" _sample_offset10506 = vec3(TEX3.x/3.00000000E+00, TEX3.x/3.00000000E+00, TEX3.x/3.00000000E+00);\n" +" _dist210506 = _dist1or41 + _sample_offset10506;\n" +" _a0542 = _dist1or41 - _sample_offset10506;\n" +" _dist310506 = abs(_a0542);\n" +" _a0544 = _dist1or41*_alpha_inv0506;\n" +" _TMP30 = abs(_a0544);\n" +" _TMP40 = pow(_TMP30.x, _beta0506.x);\n" +" _TMP41 = pow(_TMP30.y, _beta0506.y);\n" +" _TMP42 = pow(_TMP30.z, _beta0506.z);\n" +" _TMP31 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0554 = -_TMP31;\n" +" _TMP40 = pow(2.71828198E+00, _x0554.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0554.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0554.z);\n" +" _TMP553 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _a0564 = _dist210506*_alpha_inv0506;\n" +" _TMP32 = abs(_a0564);\n" +" _TMP40 = pow(_TMP32.x, _beta0506.x);\n" +" _TMP41 = pow(_TMP32.y, _beta0506.y);\n" +" _TMP42 = pow(_TMP32.z, _beta0506.z);\n" +" _TMP33 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0574 = -_TMP33;\n" +" _TMP40 = pow(2.71828198E+00, _x0574.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0574.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0574.z);\n" +" _TMP573 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _a0584 = _dist310506*_alpha_inv0506;\n" +" _TMP34 = abs(_a0584);\n" +" _TMP40 = pow(_TMP34.x, _beta0506.x);\n" +" _TMP41 = pow(_TMP34.y, _beta0506.y);\n" +" _TMP42 = pow(_TMP34.z, _beta0506.z);\n" +" _TMP35 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _x0594 = -_TMP35;\n" +" _TMP40 = pow(2.71828198E+00, _x0594.x);\n" +" _TMP41 = pow(2.71828198E+00, _x0594.y);\n" +" _TMP42 = pow(2.71828198E+00, _x0594.z);\n" +" _TMP593 = vec3(_TMP40, _TMP41, _TMP42);\n" +" _TMP503 = (_scale0506/3.00000000E+00)*(_TMP553 + _TMP573 + _TMP593);\n" +" _scanline_intensity = _scanline_intensity + _TMP503;\n" +" _TMP46 = _scanline_intensity*5.00000000E-01;\n" +" _color0604 = vec4(_TMP46.x, _TMP46.y, _TMP46.z, 1.00000000E+00);\n" +" FragColor = _color0604;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/dotmask.h b/src/video/sdl/shaders/crt/dotmask.h new file mode 100644 index 000000000..93f58a902 --- /dev/null +++ b/src/video/sdl/shaders/crt/dotmask.h @@ -0,0 +1,134 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"float _placeholder26;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTexCoord;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _oTexCoord = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"float _placeholder27;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP2;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"vec4 _TMP0;\n" +"input_dummy _IN1;\n" +"float _a0012;\n" +"float _c0012;\n" +"float _a0014;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform sampler2D Texture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _res;\n" +" vec3 _dotMaskWeights;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _a0012 = (TEX0.x*TextureSize.x*OutputSize.x)/InputSize.x;\n" +" _a0014 = _a0012/2.00000000E+00;\n" +" _TMP3 = abs(_a0014);\n" +" _TMP4 = fract(_TMP3);\n" +" _TMP5 = abs(2.00000000E+00);\n" +" _c0012 = _TMP4*_TMP5;\n" +" if (_a0012 < 0.00000000E+00) { \n" +" _TMP6 = -_c0012;\n" +" } else {\n" +" _TMP6 = _c0012;\n" +" } \n" +" _TMP2 = floor(_TMP6);\n" +" _dotMaskWeights = vec3( 1.00000000E+00, 6.99999988E-01, 1.00000000E+00) + _TMP2*vec3( -3.00000012E-01, 3.00000012E-01, -3.00000012E-01);\n" +" _res = _TMP0.xyz*_dotMaskWeights;\n" +" _ret_0 = vec4(_res.x, _res.y, _res.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/blur_horiz.h b/src/video/sdl/shaders/crt/glow/blur_horiz.h new file mode 100644 index 000000000..86a86c0c9 --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/blur_horiz.h @@ -0,0 +1,123 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP1;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP5;\n" +"float _x0006;\n" +"vec2 _c0010;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _col;\n" +" float _dx;\n" +" float _k_total;\n" +" int _i1;\n" +" vec3 _TMP4;\n" +" _col = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _dx = 4.00000000E+00/TextureSize.x;\n" +" _k_total = 0.00000000E+00;\n" +" _i1 = -4;\n" +" for (; _i1 <= 4; _i1 = _i1 + 1) { \n" +" _x0006 = float((-3.49999994E-01*float(_i1)*float(_i1)));\n" +" _TMP5 = pow(2.71828198E+00, _x0006);\n" +" _k_total = _k_total + _TMP5;\n" +" _c0010 = TEX0.xy + vec2(float(_i1)*_dx, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0010);\n" +" _col = _col + _TMP5*_TMP1.xyz;\n" +" } \n" +" _TMP4 = _col/_k_total;\n" +" _ret_0 = vec4(_TMP4.x, _TMP4.y, _TMP4.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/blur_vert.h b/src/video/sdl/shaders/crt/glow/blur_vert.h new file mode 100644 index 000000000..69ed8a0bd --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/blur_vert.h @@ -0,0 +1,123 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP1;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP5;\n" +"float _x0006;\n" +"vec2 _c0010;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _col;\n" +" float _dy;\n" +" float _k_total;\n" +" int _i1;\n" +" vec3 _TMP4;\n" +" _col = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _dy = 1.00000000E+00/TextureSize.y;\n" +" _k_total = 0.00000000E+00;\n" +" _i1 = -4;\n" +" for (; _i1 <= 4; _i1 = _i1 + 1) { \n" +" _x0006 = float((-3.49999994E-01*float(_i1)*float(_i1)));\n" +" _TMP5 = pow(2.71828198E+00, _x0006);\n" +" _k_total = _k_total + _TMP5;\n" +" _c0010 = TEX0.xy + vec2(0.00000000E+00, float(_i1)*_dy);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0010);\n" +" _col = _col + _TMP5*_TMP1.xyz;\n" +" } \n" +" _TMP4 = _col/_k_total;\n" +" _ret_0 = vec4(_TMP4.x, _TMP4.y, _TMP4.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/gauss_horiz.h b/src/video/sdl/shaders/crt/glow/gauss_horiz.h new file mode 100644 index 000000000..08782809f --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/gauss_horiz.h @@ -0,0 +1,158 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float VARone;\n" +"COMPAT_VARYING float VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" float VARpix_no;\n" +" float VARone;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" VARtex = TexCoord.xy;\n" +" VARpix_no = TexCoord.x*TextureSize.x;\n" +" VARone = 1.00000000E+00/TextureSize.x;\n" +" gl_Position = _r0006;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float VARone;\n" +"COMPAT_VARYING float VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" float VARpix_no;\n" +" float VARone;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP2;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"float _TMP9;\n" +"float _x0010;\n" +"vec2 _c0014;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" float _texel;\n" +" float _phase;\n" +" float _base_phase;\n" +" vec2 _tex;\n" +" vec3 _col;\n" +" float _phase1;\n" +" float _g1;\n" +" _texel = floor(VARpix_no);\n" +" _phase = VARpix_no - _texel;\n" +" _base_phase = _phase - 5.00000000E-01;\n" +" _tex = vec2((_texel + 5.00000000E-01)/TextureSize.x, VARtex.y);\n" +" _phase1 = _base_phase - -2.00000000E+00;\n" +" _x0010 = (-5.00000000E-01*_phase1*_phase1)/2.50000000E-01;\n" +" _TMP9 = pow(2.71828198E+00, _x0010);\n" +" _g1 = (3.79999995E-01*_TMP9)/5.00000000E-01;\n" +" _c0014 = _tex + vec2(-2.00000000E+00*VARone, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0014);\n" +" _col = _TMP2.xyz*_g1;\n" +" _phase1 = _base_phase - -1.00000000E+00;\n" +" _x0010 = (-5.00000000E-01*_phase1*_phase1)/2.50000000E-01;\n" +" _TMP9 = pow(2.71828198E+00, _x0010);\n" +" _g1 = (3.79999995E-01*_TMP9)/5.00000000E-01;\n" +" _c0014 = _tex + vec2(-VARone, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0014);\n" +" _col = _col + _TMP2.xyz*_g1;\n" +" _x0010 = (-5.00000000E-01*_base_phase*_base_phase)/2.50000000E-01;\n" +" _TMP9 = pow(2.71828198E+00, _x0010);\n" +" _g1 = (3.79999995E-01*_TMP9)/5.00000000E-01;\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _tex);\n" +" _col = _col + _TMP2.xyz*_g1;\n" +" _phase1 = _base_phase - 1.00000000E+00;\n" +" _x0010 = (-5.00000000E-01*_phase1*_phase1)/2.50000000E-01;\n" +" _TMP9 = pow(2.71828198E+00, _x0010);\n" +" _g1 = (3.79999995E-01*_TMP9)/5.00000000E-01;\n" +" _c0014 = _tex + vec2(VARone, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0014);\n" +" _col = _col + _TMP2.xyz*_g1;\n" +" _phase1 = _base_phase - 2.00000000E+00;\n" +" _x0010 = (-5.00000000E-01*_phase1*_phase1)/2.50000000E-01;\n" +" _TMP9 = pow(2.71828198E+00, _x0010);\n" +" _g1 = (3.79999995E-01*_TMP9)/5.00000000E-01;\n" +" _c0014 = _tex + vec2(2.00000000E+00*VARone, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0014);\n" +" _col = _col + _TMP2.xyz*_g1;\n" +" _ret_0 = vec4(_col.x, _col.y, _col.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/gauss_vert.h b/src/video/sdl/shaders/crt/glow/gauss_vert.h new file mode 100644 index 000000000..a26b7fa84 --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/gauss_vert.h @@ -0,0 +1,193 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float VARone;\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"struct data {\n" +" vec2 VARpix_no;\n" +" float VARone;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" VARpix_no = TexCoord.xy*TextureSize - vec2( 0.00000000E+00, 5.00000000E-01);\n" +" VARone = 1.00000000E+00/TextureSize.y;\n" +" gl_Position = _r0006;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float VARone;\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"struct data {\n" +" vec2 VARpix_no;\n" +" float VARone;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP3;\n" +"vec3 _TMP7;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"float _TMP9;\n" +"vec3 _TMP6;\n" +"float _TMP14;\n" +"float _TMP13;\n" +"float _TMP12;\n" +"float _TMP5;\n" +"vec3 _TMP4;\n" +"vec3 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0024;\n" +"vec3 _wid0026;\n" +"vec3 _weights0026;\n" +"vec3 _x0038;\n" +"vec3 _a0046;\n" +"vec3 _TMP53;\n" +"vec3 _x0054;\n" +"vec3 _wid0064;\n" +"vec3 _weights0064;\n" +"vec3 _x0076;\n" +"vec3 _a0084;\n" +"vec3 _TMP91;\n" +"vec3 _x0092;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _texel;\n" +" float _phase;\n" +" vec2 _tex;\n" +" float _dist1;\n" +" vec3 _scanline;\n" +" vec3 _TMP18;\n" +" _texel = floor(VARpix_no);\n" +" _phase = VARpix_no.y - _texel.y;\n" +" _tex = (_texel + 5.00000000E-01)/TextureSize;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _tex);\n" +" _c0024 = _tex + vec2(0.00000000E+00, VARone);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0024);\n" +" _dist1 = 1.00000000E+00 - _phase;\n" +" _TMP9 = pow(_TMP0.x, 4.00000000E+00);\n" +" _TMP10 = pow(_TMP0.y, 4.00000000E+00);\n" +" _TMP11 = pow(_TMP0.z, 4.00000000E+00);\n" +" _TMP4 = vec3(_TMP9, _TMP10, _TMP11);\n" +" _wid0026 = 2.00000000E+00 + 2.00000000E+00*_TMP4;\n" +" _TMP5 = abs(_phase);\n" +" _weights0026 = vec3(_TMP5/3.00000012E-01, _TMP5/3.00000012E-01, _TMP5/3.00000012E-01);\n" +" _x0038 = 5.00000000E-01*_wid0026;\n" +" _TMP12 = inversesqrt(_x0038.x);\n" +" _TMP13 = inversesqrt(_x0038.y);\n" +" _TMP14 = inversesqrt(_x0038.z);\n" +" _TMP6 = vec3(_TMP12, _TMP13, _TMP14);\n" +" _a0046 = _weights0026*_TMP6;\n" +" _TMP9 = pow(_a0046.x, _wid0026.x);\n" +" _TMP10 = pow(_a0046.y, _wid0026.y);\n" +" _TMP11 = pow(_a0046.z, _wid0026.z);\n" +" _TMP7 = vec3(_TMP9, _TMP10, _TMP11);\n" +" _x0054 = -_TMP7;\n" +" _TMP9 = pow(2.71828198E+00, _x0054.x);\n" +" _TMP10 = pow(2.71828198E+00, _x0054.y);\n" +" _TMP11 = pow(2.71828198E+00, _x0054.z);\n" +" _TMP53 = vec3(_TMP9, _TMP10, _TMP11);\n" +" _TMP2 = ((2.00000000E+00*_TMP0.xyz)*_TMP53)/(6.00000024E-01 + 2.00000003E-01*_wid0026);\n" +" _TMP9 = pow(_TMP1.x, 4.00000000E+00);\n" +" _TMP10 = pow(_TMP1.y, 4.00000000E+00);\n" +" _TMP11 = pow(_TMP1.z, 4.00000000E+00);\n" +" _TMP4 = vec3(_TMP9, _TMP10, _TMP11);\n" +" _wid0064 = 2.00000000E+00 + 2.00000000E+00*_TMP4;\n" +" _TMP5 = abs(_dist1);\n" +" _weights0064 = vec3(_TMP5/3.00000012E-01, _TMP5/3.00000012E-01, _TMP5/3.00000012E-01);\n" +" _x0076 = 5.00000000E-01*_wid0064;\n" +" _TMP12 = inversesqrt(_x0076.x);\n" +" _TMP13 = inversesqrt(_x0076.y);\n" +" _TMP14 = inversesqrt(_x0076.z);\n" +" _TMP6 = vec3(_TMP12, _TMP13, _TMP14);\n" +" _a0084 = _weights0064*_TMP6;\n" +" _TMP9 = pow(_a0084.x, _wid0064.x);\n" +" _TMP10 = pow(_a0084.y, _wid0064.y);\n" +" _TMP11 = pow(_a0084.z, _wid0064.z);\n" +" _TMP7 = vec3(_TMP9, _TMP10, _TMP11);\n" +" _x0092 = -_TMP7;\n" +" _TMP9 = pow(2.71828198E+00, _x0092.x);\n" +" _TMP10 = pow(2.71828198E+00, _x0092.y);\n" +" _TMP11 = pow(2.71828198E+00, _x0092.z);\n" +" _TMP91 = vec3(_TMP9, _TMP10, _TMP11);\n" +" _TMP3 = ((2.00000000E+00*_TMP1.xyz)*_TMP91)/(6.00000024E-01 + 2.00000003E-01*_wid0064);\n" +" _scanline = _TMP2 + _TMP3;\n" +" _TMP18 = _scanline/1.14999998E+00;\n" +" _ret_0 = vec4(_TMP18.x, _TMP18.y, _TMP18.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/linearize.h b/src/video/sdl/shaders/crt/glow/linearize.h new file mode 100644 index 000000000..ea7e076a7 --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/linearize.h @@ -0,0 +1,110 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP1;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP2 = pow(_TMP0.x, 2.40000010E+00);\n" +" _TMP3 = pow(_TMP0.y, 2.40000010E+00);\n" +" _TMP4 = pow(_TMP0.z, 2.40000010E+00);\n" +" _TMP1 = vec3(_TMP2, _TMP3, _TMP4);\n" +" _ret_0 = vec4(_TMP1.x, _TMP1.y, _TMP1.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/resolve.h b/src/video/sdl/shaders/crt/glow/resolve.h new file mode 100644 index 000000000..9f379e03f --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/resolve.h @@ -0,0 +1,138 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARprev;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"COMPAT_VARYING vec2 VARtex_coord;\n" +"struct prev {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +"float _placeholder29;\n" +" vec2 VARtex_coord;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size1;\n" +" vec2 VARtexture_size1;\n" +"};\n" +"struct VertexData {\n" +" vec2 VARtex;\n" +" vec2 VARprev;\n" +"};\n" +"vec4 _oPosition1;\n" +"VertexData _vert1;\n" +"prev _PASSPREV41;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"COMPAT_ATTRIBUTE vec2 PassPrev4TexCoord;\n" +"void main()\n" +"{\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" VARtex = TexCoord.xy;\n" +" VARprev = PassPrev4TexCoord;\n" +" gl_Position = _r0006;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARprev;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"COMPAT_VARYING vec2 VARtex_coord;\n" +"struct prev {\n" +" vec2 _video_size1;\n" +" vec2 VARtexture_size1;\n" +"float _placeholder28;\n" +" vec2 VARtex_coord;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +"};\n" +"struct VertexData {\n" +" vec2 VARtex;\n" +" vec2 VARprev;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP3;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"vec3 _TMP7;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"VertexData _vert1;\n" +"uniform sampler2D Texture;\n" +"prev _PASSPREV41;\n" +"vec3 _TMP19;\n" +" \n" +"uniform sampler2D PassPrev4Texture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _source;\n" +" _TMP0 = COMPAT_TEXTURE(PassPrev4Texture, VARprev);\n" +" _source = 1.14999998E+00*_TMP0.xyz;\n" +" _TMP1 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _source = _source + 4.49999988E-01*_TMP1.xyz;\n" +" _TMP7 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _source);\n" +" _TMP19 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP7);\n" +" _TMP4 = pow(_TMP19.x, 4.54545438E-01);\n" +" _TMP5 = pow(_TMP19.y, 4.54545438E-01);\n" +" _TMP6 = pow(_TMP19.z, 4.54545438E-01);\n" +" _TMP3 = vec3(_TMP4, _TMP5, _TMP6);\n" +" _ret_0 = vec4(_TMP3.x, _TMP3.y, _TMP3.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/glow/threshold.h b/src/video/sdl/shaders/crt/glow/threshold.h new file mode 100644 index 000000000..d4309b9f8 --- /dev/null +++ b/src/video/sdl/shaders/crt/glow/threshold.h @@ -0,0 +1,110 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP1;\n" +"vec3 _TMP5;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"vec3 _TMP13;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _color;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _color = 1.14999998E+00*_TMP0.xyz;\n" +" _TMP5 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _color);\n" +" _TMP13 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP5);\n" +" _TMP1 = _TMP13*_TMP13*_TMP13;\n" +" _ret_0 = vec4(_TMP1.x, _TMP1.y, _TMP1.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/gtu-v050/pass1.h b/src/video/sdl/shaders/crt/gtu-v050/pass1.h new file mode 100644 index 000000000..f7fe27062 --- /dev/null +++ b/src/video/sdl/shaders/crt/gtu-v050/pass1.h @@ -0,0 +1,82 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"uniform sampler2D Texture;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _c;\n" +" _c = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" FragColor = _c;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/gtu-v050/pass2.h b/src/video/sdl/shaders/crt/gtu-v050/pass2.h new file mode 100644 index 000000000..696fea093 --- /dev/null +++ b/src/video/sdl/shaders/crt/gtu-v050/pass2.h @@ -0,0 +1,178 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP15;\n" +"float _TMP13;\n" +"float _TMP9;\n" +"float _TMP6;\n" +"float _TMP3;\n" +"float _TMP12;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"float _TMP8;\n" +"float _TMP7;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP2;\n" +"vec4 _TMP1;\n" +"float _TMP14;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP19;\n" +"float _x0020;\n" +"float _v0024;\n" +"float _x0026;\n" +"vec2 _c0028;\n" +"float _a0032;\n" +"float _b0032;\n" +"float _a0036;\n" +"float _b0036;\n" +"float _a0038;\n" +"float _a0042;\n" +"float _b0042;\n" +"float _b0044;\n" +"float _a0048;\n" +"float _b0048;\n" +"float _b0050;\n" +"float _a0052;\n" +"vec3 _TMP53;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _tempColor;\n" +" float _X;\n" +" float _range;\n" +" float _i;\n" +" _x0020 = TEX0.x*TextureSize.x - 5.00000000E-01;\n" +" _TMP19 = fract(_x0020);\n" +" _tempColor = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _v0024 = 5.00000000E-01 + InputSize.x/2.56000000E+02;\n" +" _x0026 = -_v0024;\n" +" _TMP14 = floor(_x0026);\n" +" _range = -_TMP14;\n" +" _i = -_range;\n" +" for (; _i < _range + 2.00000000E+00; _i = _i + 1.00000000E+00) { \n" +" _X = _TMP19 - _i;\n" +" _c0028 = vec2(TEX0.x - _X/TextureSize.x, TEX0.y);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0028);\n" +" _TMP2 = abs(_X);\n" +" _a0032 = _TMP2 + 5.00000000E-01;\n" +" _b0032 = 1.00000000E+00/(2.56000000E+02/InputSize.x);\n" +" _TMP3 = min(_a0032, _b0032);\n" +" _TMP4 = abs(_X);\n" +" _a0036 = _TMP4 + 5.00000000E-01;\n" +" _b0036 = 1.00000000E+00/(2.56000000E+02/InputSize.x);\n" +" _TMP5 = min(_a0036, _b0036);\n" +" _a0038 = 3.14159274E+00*(2.56000000E+02/InputSize.x)*_TMP5;\n" +" _TMP6 = sin(_a0038);\n" +" _TMP7 = abs(_X);\n" +" _a0042 = _TMP7 - 5.00000000E-01;\n" +" _b0042 = -1.00000000E+00/(2.56000000E+02/InputSize.x);\n" +" _TMP8 = max(_a0042, _b0042);\n" +" _b0044 = 1.00000000E+00/(2.56000000E+02/InputSize.x);\n" +" _TMP9 = min(_TMP8, _b0044);\n" +" _TMP10 = abs(_X);\n" +" _a0048 = _TMP10 - 5.00000000E-01;\n" +" _b0048 = -1.00000000E+00/(2.56000000E+02/InputSize.x);\n" +" _TMP11 = max(_a0048, _b0048);\n" +" _b0050 = 1.00000000E+00/(2.56000000E+02/InputSize.x);\n" +" _TMP12 = min(_TMP11, _b0050);\n" +" _a0052 = 3.14159274E+00*(2.56000000E+02/InputSize.x)*_TMP12;\n" +" _TMP13 = sin(_a0052);\n" +" _tempColor = _tempColor + _TMP1.xyz*((((3.14159274E+00*(2.56000000E+02/InputSize.x)*_TMP3 + _TMP6) - 3.14159274E+00*(2.56000000E+02/InputSize.x)*_TMP9) - _TMP13)/6.28318548E+00);\n" +" } \n" +" _TMP15 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _tempColor);\n" +" _TMP53 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP15);\n" +" _ret_0 = vec4(_TMP53.x, _TMP53.y, _TMP53.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/gtu-v050/pass3.h b/src/video/sdl/shaders/crt/gtu-v050/pass3.h new file mode 100644 index 000000000..bd6e747fd --- /dev/null +++ b/src/video/sdl/shaders/crt/gtu-v050/pass3.h @@ -0,0 +1,232 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP1;\n" +"float _TMP10;\n" +"float _TMP9;\n" +"float _TMP15;\n" +"float _TMP14;\n" +"float _TMP11;\n" +"float _TMP12;\n" +"float _TMP8;\n" +"float _TMP7;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN2;\n" +"vec2 _TMP19;\n" +"vec2 _x0020;\n" +"float _v0024;\n" +"float _x0026;\n" +"vec2 _c0028;\n" +"float _temp0030;\n" +"float _rrr0030;\n" +"float _x10030;\n" +"float _x0030;\n" +"float _x20030;\n" +"vec3 _c0030;\n" +"float _t0036;\n" +"float _TMP39;\n" +"float _x0040;\n" +"float _val0048;\n" +"float _t0050;\n" +"float _TMP53;\n" +"float _x0054;\n" +"float _val0062;\n" +"float _t0064;\n" +"float _TMP67;\n" +"float _x0068;\n" +"float _val0076;\n" +"float _t0078;\n" +"float _TMP81;\n" +"float _x0082;\n" +"float _val0090;\n" +"float _t0092;\n" +"float _TMP95;\n" +"float _x0096;\n" +"float _val0104;\n" +"float _t0106;\n" +"float _TMP109;\n" +"float _x0110;\n" +"float _val0118;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _tempColor;\n" +" float _range;\n" +" float _i;\n" +" _x0020 = TEX0.xy*TextureSize.xy - 5.00000000E-01;\n" +" _TMP19 = fract(_x0020);\n" +" _tempColor = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _v0024 = 5.00000000E-01 + InputSize.y/2.50000000E+02;\n" +" _x0026 = -_v0024;\n" +" _TMP3 = floor(_x0026);\n" +" _range = -_TMP3;\n" +" _i = -_range;\n" +" for (; _i < _range + 2.00000000E+00; _i = _i + 1.00000000E+00) { \n" +" _c0028 = vec2(TEX0.x, TEX0.y - (_TMP19.y - _i)/TextureSize.y);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0028);\n" +" _x0030 = _TMP19.y - _i;\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP4 = 1.00000000E+00/_TMP11;\n" +" _temp0030 = _TMP4*(2.50000000E+02/InputSize.y);\n" +" _rrr0030 = 5.00000000E-01*(InputSize.y/OutputSize.y);\n" +" _x10030 = (_x0030 + _rrr0030)*_temp0030;\n" +" _x20030 = (_x0030 - _rrr0030)*_temp0030;\n" +" _TMP12 = abs(_x10030);\n" +" _t0036 = 1.00000000E+00/(1.00000000E+00 + 3.32670003E-01*_TMP12);\n" +" _x0040 = -_x10030*_x10030*5.00000000E-01;\n" +" _TMP39 = pow(2.71828198E+00, _x0040);\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP14 = 1.00000000E+00/_TMP11;\n" +" _val0048 = float((_x10030 > 0.00000000E+00));\n" +" _TMP15 = _val0048 - float((_x10030 < 0.00000000E+00));\n" +" _TMP5 = (5.00000000E-01 - (_TMP39/_TMP14)*_t0036*(4.36183602E-01 + _t0036*(-1.20167598E-01 + 9.37298000E-01*_t0036)))*_TMP15;\n" +" _TMP12 = abs(_x20030);\n" +" _t0050 = 1.00000000E+00/(1.00000000E+00 + 3.32670003E-01*_TMP12);\n" +" _x0054 = -_x20030*_x20030*5.00000000E-01;\n" +" _TMP53 = pow(2.71828198E+00, _x0054);\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP14 = 1.00000000E+00/_TMP11;\n" +" _val0062 = float((_x20030 > 0.00000000E+00));\n" +" _TMP15 = _val0062 - float((_x20030 < 0.00000000E+00));\n" +" _TMP6 = (5.00000000E-01 - (_TMP53/_TMP14)*_t0050*(4.36183602E-01 + _t0050*(-1.20167598E-01 + 9.37298000E-01*_t0050)))*_TMP15;\n" +" _c0030.x = _TMP1.x*(_TMP5 - _TMP6);\n" +" _TMP12 = abs(_x10030);\n" +" _t0064 = 1.00000000E+00/(1.00000000E+00 + 3.32670003E-01*_TMP12);\n" +" _x0068 = -_x10030*_x10030*5.00000000E-01;\n" +" _TMP67 = pow(2.71828198E+00, _x0068);\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP14 = 1.00000000E+00/_TMP11;\n" +" _val0076 = float((_x10030 > 0.00000000E+00));\n" +" _TMP15 = _val0076 - float((_x10030 < 0.00000000E+00));\n" +" _TMP7 = (5.00000000E-01 - (_TMP67/_TMP14)*_t0064*(4.36183602E-01 + _t0064*(-1.20167598E-01 + 9.37298000E-01*_t0064)))*_TMP15;\n" +" _TMP12 = abs(_x20030);\n" +" _t0078 = 1.00000000E+00/(1.00000000E+00 + 3.32670003E-01*_TMP12);\n" +" _x0082 = -_x20030*_x20030*5.00000000E-01;\n" +" _TMP81 = pow(2.71828198E+00, _x0082);\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP14 = 1.00000000E+00/_TMP11;\n" +" _val0090 = float((_x20030 > 0.00000000E+00));\n" +" _TMP15 = _val0090 - float((_x20030 < 0.00000000E+00));\n" +" _TMP8 = (5.00000000E-01 - (_TMP81/_TMP14)*_t0078*(4.36183602E-01 + _t0078*(-1.20167598E-01 + 9.37298000E-01*_t0078)))*_TMP15;\n" +" _c0030.y = _TMP1.y*(_TMP7 - _TMP8);\n" +" _TMP12 = abs(_x10030);\n" +" _t0092 = 1.00000000E+00/(1.00000000E+00 + 3.32670003E-01*_TMP12);\n" +" _x0096 = -_x10030*_x10030*5.00000000E-01;\n" +" _TMP95 = pow(2.71828198E+00, _x0096);\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP14 = 1.00000000E+00/_TMP11;\n" +" _val0104 = float((_x10030 > 0.00000000E+00));\n" +" _TMP15 = _val0104 - float((_x10030 < 0.00000000E+00));\n" +" _TMP9 = (5.00000000E-01 - (_TMP95/_TMP14)*_t0092*(4.36183602E-01 + _t0092*(-1.20167598E-01 + 9.37298000E-01*_t0092)))*_TMP15;\n" +" _TMP12 = abs(_x20030);\n" +" _t0106 = 1.00000000E+00/(1.00000000E+00 + 3.32670003E-01*_TMP12);\n" +" _x0110 = -_x20030*_x20030*5.00000000E-01;\n" +" _TMP109 = pow(2.71828198E+00, _x0110);\n" +" _TMP11 = inversesqrt(6.28318548E+00);\n" +" _TMP14 = 1.00000000E+00/_TMP11;\n" +" _val0118 = float((_x20030 > 0.00000000E+00));\n" +" _TMP15 = _val0118 - float((_x20030 < 0.00000000E+00));\n" +" _TMP10 = (5.00000000E-01 - (_TMP109/_TMP14)*_t0106*(4.36183602E-01 + _t0106*(-1.20167598E-01 + 9.37298000E-01*_t0106)))*_TMP15;\n" +" _c0030.z = _TMP1.z*(_TMP9 - _TMP10);\n" +" _c0030 = _c0030*(OutputSize.y/InputSize.y);\n" +" _tempColor = _tempColor + _c0030;\n" +" } \n" +" _tempColor = _tempColor - vec3( 8.74999985E-02, 8.74999985E-02, 8.74999985E-02);\n" +" _tempColor = _tempColor*vec3( 1.09589040E+00, 1.09589040E+00, 1.09589040E+00);\n" +" _ret_0 = vec4(_tempColor.x, _tempColor.y, _tempColor.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/crt/tvout-tweaks.h b/src/video/sdl/shaders/crt/tvout-tweaks.h new file mode 100644 index 000000000..70eb2ebde --- /dev/null +++ b/src/video/sdl/shaders/crt/tvout-tweaks.h @@ -0,0 +1,320 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"vec4 _outPosition1;\n" +"vec4 _r0010;\n" +"vec4 _v0010;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _outTexCoord;\n" +" _v0010 = vec4(float(VertexCoord.x), float(VertexCoord.y), float(VertexCoord.z), float(VertexCoord.w));\n" +" _r0010 = _v0010.x*MVPMatrix[0];\n" +" _r0010 = _r0010 + _v0010.y*MVPMatrix[1];\n" +" _r0010 = _r0010 + _v0010.z*MVPMatrix[2];\n" +" _r0010 = _r0010 + _v0010.w*MVPMatrix[3];\n" +" _outPosition1 = vec4(float(_r0010.x), float(_r0010.y), float(_r0010.z), float(_r0010.w));\n" +" _outTexCoord = TexCoord.xy;\n" +" gl_Position = _outPosition1;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP51;\n" +"float _TMP47;\n" +"float _TMP44;\n" +"float _TMP41;\n" +"float _TMP50;\n" +"float _TMP49;\n" +"float _TMP48;\n" +"float _TMP46;\n" +"float _TMP45;\n" +"float _TMP43;\n" +"float _TMP42;\n" +"float _TMP40;\n" +"vec4 _TMP39;\n" +"float _TMP38;\n" +"float _TMP34;\n" +"float _TMP31;\n" +"float _TMP28;\n" +"float _TMP37;\n" +"float _TMP36;\n" +"float _TMP35;\n" +"float _TMP33;\n" +"float _TMP32;\n" +"float _TMP30;\n" +"float _TMP29;\n" +"float _TMP27;\n" +"vec4 _TMP26;\n" +"float _TMP25;\n" +"float _TMP21;\n" +"float _TMP18;\n" +"float _TMP15;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"float _TMP20;\n" +"float _TMP19;\n" +"float _TMP17;\n" +"float _TMP16;\n" +"float _TMP14;\n" +"vec4 _TMP13;\n" +"float _TMP12;\n" +"float _TMP8;\n" +"float _TMP5;\n" +"float _TMP2;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"float _TMP9;\n" +"float _TMP7;\n" +"float _TMP6;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP57;\n" +"float _x0058;\n" +"vec2 _c0062;\n" +"float _a0068;\n" +"float _b0068;\n" +"float _a0072;\n" +"float _b0072;\n" +"float _a0074;\n" +"float _a0078;\n" +"float _b0078;\n" +"float _b0080;\n" +"float _a0084;\n" +"float _b0084;\n" +"float _b0086;\n" +"float _a0088;\n" +"vec2 _c0090;\n" +"float _a0096;\n" +"float _b0096;\n" +"float _a0100;\n" +"float _b0100;\n" +"float _a0102;\n" +"float _a0106;\n" +"float _b0106;\n" +"float _b0108;\n" +"float _a0112;\n" +"float _b0112;\n" +"float _b0114;\n" +"float _a0116;\n" +"vec2 _c0118;\n" +"float _a0124;\n" +"float _b0124;\n" +"float _a0128;\n" +"float _b0128;\n" +"float _a0130;\n" +"float _a0134;\n" +"float _b0134;\n" +"float _b0136;\n" +"float _a0140;\n" +"float _b0140;\n" +"float _b0142;\n" +"float _a0144;\n" +"vec2 _c0146;\n" +"float _a0152;\n" +"float _b0152;\n" +"float _a0156;\n" +"float _b0156;\n" +"float _a0158;\n" +"float _a0162;\n" +"float _b0162;\n" +"float _b0164;\n" +"float _a0168;\n" +"float _b0168;\n" +"float _b0170;\n" +"float _a0172;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _tempColor;\n" +" float _oneT;\n" +" float _oneI;\n" +" float _X;\n" +" _x0058 = TEX0.x*TextureSize.x - 5.00000000E-01;\n" +" _TMP57 = fract(_x0058);\n" +" _oneT = 1.00000000E+00/TextureSize.x;\n" +" _oneI = float((1.00000000E+00/InputSize.x));\n" +" _X = _TMP57 - -1.00000000E+00;\n" +" _c0062 = vec2(TEX0.x - _X*_oneT, TEX0.y);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _c0062);\n" +" _TMP1 = abs(_X);\n" +" _a0068 = _TMP1 + 5.00000000E-01;\n" +" _b0068 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP2 = min(_a0068, _b0068);\n" +" _TMP3 = abs(_X);\n" +" _a0072 = _TMP3 + 5.00000000E-01;\n" +" _b0072 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP4 = min(_a0072, _b0072);\n" +" _a0074 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP4;\n" +" _TMP5 = sin(_a0074);\n" +" _TMP6 = abs(_X);\n" +" _a0078 = _TMP6 - 5.00000000E-01;\n" +" _b0078 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP7 = max(_a0078, _b0078);\n" +" _b0080 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP8 = min(_TMP7, _b0080);\n" +" _TMP9 = abs(_X);\n" +" _a0084 = _TMP9 - 5.00000000E-01;\n" +" _b0084 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP10 = max(_a0084, _b0084);\n" +" _b0086 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP11 = min(_TMP10, _b0086);\n" +" _a0088 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP11;\n" +" _TMP12 = sin(_a0088);\n" +" _tempColor = _TMP0.xyz*((((3.14159274E+00*2.56000000E+02*_oneI*_TMP2 + _TMP5) - 3.14159274E+00*2.56000000E+02*_oneI*_TMP8) - _TMP12)/6.28318548E+00);\n" +" _c0090 = vec2(TEX0.x - _TMP57*_oneT, TEX0.y);\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _c0090);\n" +" _TMP14 = abs(_TMP57);\n" +" _a0096 = _TMP14 + 5.00000000E-01;\n" +" _b0096 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP15 = min(_a0096, _b0096);\n" +" _TMP16 = abs(_TMP57);\n" +" _a0100 = _TMP16 + 5.00000000E-01;\n" +" _b0100 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP17 = min(_a0100, _b0100);\n" +" _a0102 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP17;\n" +" _TMP18 = sin(_a0102);\n" +" _TMP19 = abs(_TMP57);\n" +" _a0106 = _TMP19 - 5.00000000E-01;\n" +" _b0106 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP20 = max(_a0106, _b0106);\n" +" _b0108 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP21 = min(_TMP20, _b0108);\n" +" _TMP22 = abs(_TMP57);\n" +" _a0112 = _TMP22 - 5.00000000E-01;\n" +" _b0112 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP23 = max(_a0112, _b0112);\n" +" _b0114 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP24 = min(_TMP23, _b0114);\n" +" _a0116 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP24;\n" +" _TMP25 = sin(_a0116);\n" +" _tempColor = _tempColor + _TMP13.xyz*((((3.14159274E+00*2.56000000E+02*_oneI*_TMP15 + _TMP18) - 3.14159274E+00*2.56000000E+02*_oneI*_TMP21) - _TMP25)/6.28318548E+00);\n" +" _X = _TMP57 - 1.00000000E+00;\n" +" _c0118 = vec2(TEX0.x - _X*_oneT, TEX0.y);\n" +" _TMP26 = COMPAT_TEXTURE(Texture, _c0118);\n" +" _TMP27 = abs(_X);\n" +" _a0124 = _TMP27 + 5.00000000E-01;\n" +" _b0124 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP28 = min(_a0124, _b0124);\n" +" _TMP29 = abs(_X);\n" +" _a0128 = _TMP29 + 5.00000000E-01;\n" +" _b0128 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP30 = min(_a0128, _b0128);\n" +" _a0130 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP30;\n" +" _TMP31 = sin(_a0130);\n" +" _TMP32 = abs(_X);\n" +" _a0134 = _TMP32 - 5.00000000E-01;\n" +" _b0134 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP33 = max(_a0134, _b0134);\n" +" _b0136 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP34 = min(_TMP33, _b0136);\n" +" _TMP35 = abs(_X);\n" +" _a0140 = _TMP35 - 5.00000000E-01;\n" +" _b0140 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP36 = max(_a0140, _b0140);\n" +" _b0142 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP37 = min(_TMP36, _b0142);\n" +" _a0144 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP37;\n" +" _TMP38 = sin(_a0144);\n" +" _tempColor = _tempColor + _TMP26.xyz*((((3.14159274E+00*2.56000000E+02*_oneI*_TMP28 + _TMP31) - 3.14159274E+00*2.56000000E+02*_oneI*_TMP34) - _TMP38)/6.28318548E+00);\n" +" _X = _TMP57 - 2.00000000E+00;\n" +" _c0146 = vec2(TEX0.x - _X*_oneT, TEX0.y);\n" +" _TMP39 = COMPAT_TEXTURE(Texture, _c0146);\n" +" _TMP40 = abs(_X);\n" +" _a0152 = _TMP40 + 5.00000000E-01;\n" +" _b0152 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP41 = min(_a0152, _b0152);\n" +" _TMP42 = abs(_X);\n" +" _a0156 = _TMP42 + 5.00000000E-01;\n" +" _b0156 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP43 = min(_a0156, _b0156);\n" +" _a0158 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP43;\n" +" _TMP44 = sin(_a0158);\n" +" _TMP45 = abs(_X);\n" +" _a0162 = _TMP45 - 5.00000000E-01;\n" +" _b0162 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP46 = max(_a0162, _b0162);\n" +" _b0164 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP47 = min(_TMP46, _b0164);\n" +" _TMP48 = abs(_X);\n" +" _a0168 = _TMP48 - 5.00000000E-01;\n" +" _b0168 = -1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP49 = max(_a0168, _b0168);\n" +" _b0170 = 1.00000000E+00/(2.56000000E+02*_oneI);\n" +" _TMP50 = min(_TMP49, _b0170);\n" +" _a0172 = 3.14159274E+00*2.56000000E+02*_oneI*_TMP50;\n" +" _TMP51 = sin(_a0172);\n" +" _tempColor = _tempColor + _TMP39.xyz*((((3.14159274E+00*2.56000000E+02*_oneI*_TMP41 + _TMP44) - 3.14159274E+00*2.56000000E+02*_oneI*_TMP47) - _TMP51)/6.28318548E+00);\n" +" _ret_0 = vec4(_tempColor.x, _tempColor.y, _tempColor.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/dbl.h b/src/video/sdl/shaders/dbl.h deleted file mode 100644 index 69a916d61..000000000 --- a/src/video/sdl/shaders/dbl.h +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/*****************************************************************************************/ -/* don't BLOOM */ -/*****************************************************************************************/ -{ - // vertex shader - "varying vec4 v_texCoord;\n" - - "void main() {\n" - " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" - " gl_FrontColor = gl_Color;\n" - " v_texCoord = gl_MultiTexCoord0;\n" - "}", - // fragment shader - "uniform vec2 size_texture;\n" - "uniform vec2 size_screen_emu;\n" - "uniform vec2 size_video_mode;\n" - "uniform float pixel_aspect_ratio;\n" - "uniform float param;\n" - "uniform float full_interpolation;\n" - - "uniform sampler2D texture_scr;\n" - - "varying vec4 v_texCoord;\n" - - "vec2 c00;\n" - "vec2 c10;\n" - "vec2 c20;\n" - "vec2 c01;\n" - "vec2 c11;\n" - "vec2 c21;\n" - "vec2 c02;\n" - "vec2 c12;\n" - "vec2 c22;\n" - "vec2 pixel_no;\n" - - "float gamma;\n" - "float shine;\n" - "float blend;\n" - "float factor_delta;\n" - "float dx;\n" - "float dy;\n" - - "float dist(vec2 coord, vec2 source) {\n" - " vec2 delta = coord - source;\n" - " return sqrt(dot(delta, delta));\n" - "}\n" - - "float color_bloom(vec3 color) {\n" - " const vec3 gray_coeff = vec3(0.30, 0.59, 0.11);\n" - " float bright = dot(color, gray_coeff);\n" - " return mix(1.0 + shine, 1.0 - shine, bright);\n" - "}\n" - - "vec3 lookup(float offset_x, float offset_y, vec2 coord) {\n" - " vec2 offset = vec2(offset_x, offset_y);\n" - " vec3 color = texture2D(texture_scr, coord).rgb;\n" - " float delta = dist(fract(pixel_no), offset + vec2(factor_delta));\n" - " return color * exp(-gamma * delta * color_bloom(color));\n" - "}\n" - - "void main() {\n" - " if (param == 0.0) {\n" - " dx = (1.0 / (size_video_mode.x / pixel_aspect_ratio));\n" - " dy = (1.0 / (size_video_mode.y));\n" - //" pixel_no = v_texCoord.xy * ((256.0 * vec2(pixel_aspect_ratio, 1.0)) - 0.1);\n" - " pixel_no = v_texCoord.xy * (256.0 - 0.1);\n" - " gamma = 2.4;\n" - " shine = 0.05;\n" - " blend = 0.65;\n" - " factor_delta = 0.5;\n" - " } else if (param == 1.0) {\n" - " dx = dy = 1.0 / 256.0;\n" - " pixel_no = v_texCoord.xy;\n" - " gamma = 1.4;\n" - " shine = 0.25;\n" - " blend = 0.10;\n" - " factor_delta = 0.10;\n" - " } else if (param == 2.0) {\n" - " dx = dy = 1.0 / 256.0;\n" - " pixel_no = v_texCoord.xy * (256.0 / vec2(0.0, 1.0));\n" - " gamma = 1.0;\n" - " shine = 0.25;\n" - " blend = 0.10;\n" - " factor_delta = 0.5;\n" - " } else {\n" - " dx = dy = 1.0 / 256.0;\n" - " pixel_no = v_texCoord.xy * (256.0 / vec2(1.0, 0.0));\n" - " gamma = 1.0;\n" - " shine = 0.25;\n" - " blend = 0.10;\n" - " factor_delta = 0.5;\n" - " }\n" - -#include "interpolation.h" - - " c00 = pnt + vec2(-dx, -dy);\n" - " c10 = pnt + vec2( 0, -dy);\n" - " c20 = pnt + vec2( dx, -dy);\n" - " c01 = pnt + vec2(-dx, 0);\n" - " c11 = pnt + vec2( 0, 0);\n" - " c21 = pnt + vec2( dx, 0);\n" - " c02 = pnt + vec2(-dx, dy);\n" - " c12 = pnt + vec2( 0, dy);\n" - " c22 = pnt + vec2( dx, dy);\n" - - " vec3 mid_color = lookup(0.0, 0.0, c11);\n" - " vec3 color = vec3(0.0);\n" - " color += lookup(-1.0, -1.0, c00);\n" - " color += lookup( 0.0, -1.0, c10);\n" - " color += lookup( 1.0, -1.0, c20);\n" - " color += lookup(-1.0, 0.0, c01);\n" - " color += mid_color;\n" - " color += lookup( 1.0, 0.0, c21);\n" - " color += lookup(-1.0, 1.0, c02);\n" - " color += lookup( 0.0, 1.0, c12);\n" - " color += lookup( 1.0, 1.0, c22);\n" - " vec3 out_color = mix(1.2 * mid_color, color, blend);\n" - - " vec4 scr = vec4(out_color, 1.0);\n" - - " gl_FragColor = scr * gl_Color;\n" - "}" -}, diff --git a/src/video/sdl/shaders/eagle/super-eagle.h b/src/video/sdl/shaders/eagle/super-eagle.h new file mode 100644 index 000000000..d8b00ab8f --- /dev/null +++ b/src/video/sdl/shaders/eagle/super-eagle.h @@ -0,0 +1,430 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec2 _texCoord1;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"out_vertex _ret_0;\n" +"input_dummy _IN1;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" vec2 _ps;\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _ps = vec2(1.00000000E+00/TextureSize.x, 1.00000000E+00/TextureSize.y);\n" +" _OUT._t1.xy = TexCoord.xy + vec2(-_ps.x, -_ps.y);\n" +" _OUT._t1.zw = TexCoord.xy + vec2(-_ps.x, 0.00000000E+00);\n" +" _OUT._t2.xy = TexCoord.xy + vec2(+_ps.x, -_ps.y);\n" +" _OUT._t2.zw = TexCoord.xy + vec2(+_ps.x + _ps.x, -_ps.y);\n" +" _OUT._t3.xy = TexCoord.xy + vec2(-_ps.x, 0.00000000E+00);\n" +" _OUT._t3.zw = TexCoord.xy + vec2(+_ps.x, 0.00000000E+00);\n" +" _OUT._t4.xy = TexCoord.xy + vec2(+_ps.x + _ps.x, 0.00000000E+00);\n" +" _OUT._t4.zw = TexCoord.xy + vec2(-_ps.x, +_ps.y);\n" +" _OUT._t5.xy = TexCoord.xy + vec2(0.00000000E+00, +_ps.y);\n" +" _OUT._t5.zw = TexCoord.xy + vec2(+_ps.x, +_ps.y);\n" +" _OUT._t6.xy = TexCoord.xy + vec2(+_ps.x + _ps.x, +_ps.y);\n" +" _OUT._t6.zw = TexCoord.xy + vec2(-_ps.x, +_ps.y + _ps.y);\n" +" _OUT._t7.xy = TexCoord.xy + vec2(0.00000000E+00, +_ps.y + _ps.y);\n" +" _OUT._t7.zw = TexCoord.xy + vec2(+_ps.x, +_ps.y + _ps.y);\n" +" _ret_0._position1 = _r0008;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" _ret_0._t1 = _OUT._t1;\n" +" _ret_0._t2 = _OUT._t2;\n" +" _ret_0._t3 = _OUT._t3;\n" +" _ret_0._t4 = _OUT._t4;\n" +" _ret_0._t5 = _OUT._t5;\n" +" _ret_0._t6 = _OUT._t6;\n" +" _ret_0._t7 = _OUT._t7;\n" +" gl_Position = _r0008;\n" +" TEX0.xy = TexCoord.xy;\n" +" TEX1 = _OUT._t1;\n" +" TEX2 = _OUT._t2;\n" +" TEX3 = _OUT._t3;\n" +" TEX4 = _OUT._t4;\n" +" TEX5 = _OUT._t5;\n" +" TEX6 = _OUT._t6;\n" +" TEX7 = _OUT._t7;\n" +" return;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +" TEX1 = _ret_0._t1;\n" +" TEX2 = _ret_0._t2;\n" +" TEX3 = _ret_0._t3;\n" +" TEX4 = _ret_0._t4;\n" +" TEX5 = _ret_0._t5;\n" +" TEX6 = _ret_0._t6;\n" +" TEX7 = _ret_0._t7;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec2 _texCoord;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP28;\n" +"vec3 _TMP30;\n" +"vec3 _TMP29;\n" +"vec4 _TMP14;\n" +"vec4 _TMP13;\n" +"vec4 _TMP11;\n" +"vec4 _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _x0037;\n" +"float _TMP74;\n" +"float _TMP78;\n" +"float _TMP82;\n" +"float _TMP86;\n" +"float _TMP90;\n" +"float _TMP94;\n" +"float _TMP98;\n" +"float _TMP102;\n" +"float _TMP110;\n" +"float _TMP114;\n" +"float _TMP122;\n" +"float _TMP126;\n" +"int _x0135;\n" +"int _y0135;\n" +"int _r0135;\n" +"int _x0137;\n" +"int _y0137;\n" +"int _r0137;\n" +"int _x0139;\n" +"int _y0139;\n" +"int _r0139;\n" +"int _x0141;\n" +"int _y0141;\n" +"int _r0141;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _fp;\n" +" vec3 _p00;\n" +" vec3 _p10;\n" +" vec3 _p01;\n" +" vec3 _p11;\n" +" int _r1;\n" +" _x0037 = TEX0.xy*TextureSize;\n" +" _fp = fract(_x0037);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, TEX1.zw);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, TEX2.xy);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX3.xy);\n" +" _TMP5 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, TEX3.zw);\n" +" _TMP7 = COMPAT_TEXTURE(Texture, TEX4.xy);\n" +" _TMP8 = COMPAT_TEXTURE(Texture, TEX4.zw);\n" +" _TMP9 = COMPAT_TEXTURE(Texture, TEX5.xy);\n" +" _TMP10 = COMPAT_TEXTURE(Texture, TEX5.zw);\n" +" _TMP11 = COMPAT_TEXTURE(Texture, TEX6.xy);\n" +" _TMP13 = COMPAT_TEXTURE(Texture, TEX7.xy);\n" +" _TMP14 = COMPAT_TEXTURE(Texture, TEX7.zw);\n" +" _TMP74 = dot(_TMP1.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP78 = dot(_TMP2.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP82 = dot(_TMP4.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP86 = dot(_TMP5.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP90 = dot(_TMP6.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP94 = dot(_TMP8.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP98 = dot(_TMP9.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP102 = dot(_TMP10.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP110 = dot(_TMP13.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP114 = dot(_TMP14.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP122 = dot(_TMP7.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" _TMP126 = dot(_TMP11.xyz, vec3( 6.55360000E+04, 2.55000000E+02, 1.00000000E+00));\n" +" if (_TMP86 != _TMP102) { \n" +" if (_TMP98 == _TMP90) { \n" +" _p10 = _TMP9.xyz;\n" +" _p01 = _TMP9.xyz;\n" +" if (_TMP94 == _TMP98 || _TMP90 == _TMP78) { \n" +" _p00 = 2.50000000E-01*(3.00000000E+00*_TMP9.xyz + _TMP5.xyz);\n" +" } else {\n" +" _p00 = 5.00000000E-01*(_TMP5.xyz + _TMP6.xyz);\n" +" } \n" +" if (_TMP90 == _TMP122 || _TMP98 == _TMP110) { \n" +" _p11 = 2.50000000E-01*(3.00000000E+00*_TMP9.xyz + _TMP10.xyz);\n" +" } else {\n" +" _p11 = 5.00000000E-01*(_TMP9.xyz + _TMP10.xyz);\n" +" } \n" +" } else {\n" +" _p11 = 1.25000000E-01*(6.00000000E+00*_TMP10.xyz + _TMP9.xyz + _TMP6.xyz);\n" +" _p00 = 1.25000000E-01*(6.00000000E+00*_TMP5.xyz + _TMP9.xyz + _TMP6.xyz);\n" +" _p10 = 1.25000000E-01*(6.00000000E+00*_TMP9.xyz + _TMP5.xyz + _TMP10.xyz);\n" +" _p01 = 1.25000000E-01*(6.00000000E+00*_TMP6.xyz + _TMP5.xyz + _TMP10.xyz);\n" +" } \n" +" } else {\n" +" if (_TMP98 != _TMP90) { \n" +" _p00 = _TMP5.xyz;\n" +" _p11 = _TMP5.xyz;\n" +" if (_TMP74 == _TMP86 || _TMP102 == _TMP126) { \n" +" _p01 = 2.50000000E-01*(3.00000000E+00*_TMP5.xyz + _TMP6.xyz);\n" +" } else {\n" +" _p01 = 5.00000000E-01*(_TMP5.xyz + _TMP6.xyz);\n" +" } \n" +" if (_TMP102 == _TMP114 || _TMP82 == _TMP86) { \n" +" _p10 = 2.50000000E-01*(3.00000000E+00*_TMP5.xyz + _TMP9.xyz);\n" +" } else {\n" +" _p10 = 5.00000000E-01*(_TMP9.xyz + _TMP10.xyz);\n" +" } \n" +" } else {\n" +" _x0135 = 0;\n" +" _y0135 = 0;\n" +" _r0135 = 0;\n" +" if (_TMP90 == _TMP94) { \n" +" _x0135 = 1;\n" +" } else {\n" +" if (_TMP86 == _TMP94) { \n" +" _y0135 = 1;\n" +" } \n" +" } \n" +" if (_TMP90 == _TMP110) { \n" +" _x0135 = _x0135 + 1;\n" +" } else {\n" +" if (_TMP86 == _TMP110) { \n" +" _y0135 = _y0135 + 1;\n" +" } \n" +" } \n" +" if (_x0135 <= 1) { \n" +" _r0135 = 1;\n" +" } \n" +" if (_y0135 <= 1) { \n" +" _r0135 = _r0135 - 1;\n" +" } \n" +" _x0137 = 0;\n" +" _y0137 = 0;\n" +" _r0137 = 0;\n" +" if (_TMP90 == _TMP82) { \n" +" _x0137 = 1;\n" +" } else {\n" +" if (_TMP86 == _TMP82) { \n" +" _y0137 = 1;\n" +" } \n" +" } \n" +" if (_TMP90 == _TMP74) { \n" +" _x0137 = _x0137 + 1;\n" +" } else {\n" +" if (_TMP86 == _TMP74) { \n" +" _y0137 = _y0137 + 1;\n" +" } \n" +" } \n" +" if (_x0137 <= 1) { \n" +" _r0137 = 1;\n" +" } \n" +" if (_y0137 <= 1) { \n" +" _r0137 = _r0137 - 1;\n" +" } \n" +" _r1 = _r0135 + _r0137;\n" +" _x0139 = 0;\n" +" _y0139 = 0;\n" +" _r0139 = 0;\n" +" if (_TMP90 == _TMP114) { \n" +" _x0139 = 1;\n" +" } else {\n" +" if (_TMP86 == _TMP114) { \n" +" _y0139 = 1;\n" +" } \n" +" } \n" +" if (_TMP90 == _TMP126) { \n" +" _x0139 = _x0139 + 1;\n" +" } else {\n" +" if (_TMP86 == _TMP126) { \n" +" _y0139 = _y0139 + 1;\n" +" } \n" +" } \n" +" if (_x0139 <= 1) { \n" +" _r0139 = 1;\n" +" } \n" +" if (_y0139 <= 1) { \n" +" _r0139 = _r0139 - 1;\n" +" } \n" +" _r1 = _r1 + _r0139;\n" +" _x0141 = 0;\n" +" _y0141 = 0;\n" +" _r0141 = 0;\n" +" if (_TMP90 == _TMP78) { \n" +" _x0141 = 1;\n" +" } else {\n" +" if (_TMP86 == _TMP78) { \n" +" _y0141 = 1;\n" +" } \n" +" } \n" +" if (_TMP90 == _TMP122) { \n" +" _x0141 = _x0141 + 1;\n" +" } else {\n" +" if (_TMP86 == _TMP122) { \n" +" _y0141 = _y0141 + 1;\n" +" } \n" +" } \n" +" if (_x0141 <= 1) { \n" +" _r0141 = 1;\n" +" } \n" +" if (_y0141 <= 1) { \n" +" _r0141 = _r0141 - 1;\n" +" } \n" +" _r1 = _r1 + _r0141;\n" +" if (_r1 > 0) { \n" +" _p10 = _TMP9.xyz;\n" +" _p01 = _TMP9.xyz;\n" +" _p11 = 5.00000000E-01*(_TMP5.xyz + _TMP6.xyz);\n" +" _p00 = _p11;\n" +" } else {\n" +" if (_r1 < 0) { \n" +" _p00 = _TMP5.xyz;\n" +" _p11 = _TMP5.xyz;\n" +" _p10 = 5.00000000E-01*(_TMP5.xyz + _TMP6.xyz);\n" +" _p01 = _p10;\n" +" } else {\n" +" _p00 = _TMP5.xyz;\n" +" _p11 = _TMP5.xyz;\n" +" _p10 = _TMP9.xyz;\n" +" _p01 = _TMP9.xyz;\n" +" } \n" +" } \n" +" } \n" +" } \n" +" if (_fp.x < 5.00000000E-01) { \n" +" if (_fp.y < 5.00000000E-01) { \n" +" _TMP29 = _p00;\n" +" } else {\n" +" _TMP29 = _p10;\n" +" } \n" +" _TMP28 = _TMP29;\n" +" } else {\n" +" if (_fp.y < 5.00000000E-01) { \n" +" _TMP30 = _p01;\n" +" } else {\n" +" _TMP30 = _p11;\n" +" } \n" +" _TMP28 = _TMP30;\n" +" } \n" +" _ret_0 = vec4(_TMP28.x, _TMP28.y, _TMP28.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/handheld/lcd_cgwg/lcd-grid.h b/src/video/sdl/shaders/hunterk/handheld/lcd_cgwg/lcd-grid.h new file mode 100644 index 000000000..da987a35d --- /dev/null +++ b/src/video/sdl/shaders/hunterk/handheld/lcd_cgwg/lcd-grid.h @@ -0,0 +1,421 @@ +{ +"#pragma parameter GRID_STRENGTH \"LCD Grid Strength\" 0.05 0.00 1.00 0.01\n" +"#ifdef PARAMETER_UNIFORM\n" +"uniform float GRID_STRENGTH;\n" +"#else\n" +"#define GRID_STRENGTH 0.05\n" +"#endif\n" +"\n" +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _col;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _texCoord_size;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texCoord_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +" vec2 _texture_size;\n" +"float _placeholder24;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _col;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _otexCoord;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _otexCoord = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _col;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _texCoord_size;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texCoord_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +" vec2 _texture_size;\n" +"float _placeholder30;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _col;\n" +"};\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"float _TMP21;\n" +"vec2 _TMP25;\n" +"vec4 _TMP17;\n" +"vec4 _TMP16;\n" +"vec2 _TMP15;\n" +"vec4 _TMP14;\n" +"vec4 _TMP13;\n" +"vec2 _TMP12;\n" +"vec4 _TMP11;\n" +"vec4 _TMP10;\n" +"vec2 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec2 _TMP6;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP20;\n" +"float _TMP19;\n" +"float _TMP26;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"float _TMP0;\n" +"float _TMP18;\n" +"input_dummy _IN1;\n" +"float _x0030;\n" +"float _x0032;\n" +"float _x0034;\n" +"float _TMP35;\n" +"float _x0036;\n" +"float _TMP41;\n" +"float _x0042;\n" +"float _z20048;\n" +"float _z40048;\n" +"float _z80048;\n" +"float _z20050;\n" +"float _z40050;\n" +"float _z80050;\n" +"float _TMP53;\n" +"float _x0054;\n" +"float _TMP59;\n" +"float _x0060;\n" +"float _z20066;\n" +"float _z40066;\n" +"float _z80066;\n" +"float _z20068;\n" +"float _z40068;\n" +"float _z80068;\n" +"float _x0070;\n" +"float _TMP71;\n" +"float _x0072;\n" +"float _TMP77;\n" +"float _x0078;\n" +"float _z20084;\n" +"float _z40084;\n" +"float _z80084;\n" +"float _z20086;\n" +"float _z40086;\n" +"float _z80086;\n" +"float _x0088;\n" +"float _TMP89;\n" +"float _x0090;\n" +"float _TMP95;\n" +"float _x0096;\n" +"float _z20102;\n" +"float _z40102;\n" +"float _z80102;\n" +"float _z20104;\n" +"float _z40104;\n" +"float _z80104;\n" +"float _x0106;\n" +"float _TMP107;\n" +"float _x0108;\n" +"float _TMP113;\n" +"float _x0114;\n" +"float _z20120;\n" +"float _z40120;\n" +"float _z80120;\n" +"float _z20122;\n" +"float _z40122;\n" +"float _z80122;\n" +"float _x0124;\n" +"float _TMP125;\n" +"float _x0126;\n" +"float _TMP131;\n" +"float _x0132;\n" +"float _z20138;\n" +"float _z40138;\n" +"float _z80138;\n" +"float _z20140;\n" +"float _z40140;\n" +"float _z80140;\n" +"vec2 _x0142;\n" +"vec2 _c0144;\n" +"vec2 _x0156;\n" +"vec2 _c0158;\n" +"vec2 _x0170;\n" +"vec2 _c0172;\n" +"vec2 _x0184;\n" +"vec2 _c0186;\n" +"vec2 _x0198;\n" +"vec2 _TMP199;\n" +"vec2 _b0200;\n" +"vec2 _x0200;\n" +"vec2 _a0200;\n" +"vec2 _TMP205;\n" +"vec2 _b0206;\n" +"vec2 _x0206;\n" +"vec2 _a0206;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform sampler2D Texture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _texelSize;\n" +" vec2 _subtexelSize;\n" +" vec2 _range;\n" +" float _left;\n" +" float _top;\n" +" float _right;\n" +" float _bottom;\n" +" vec4 _lcol;\n" +" vec4 _rcol;\n" +" float _subpix;\n" +" float _rsubpix;\n" +" vec4 _topLeftColor;\n" +" vec4 _bottomRightColor;\n" +" vec4 _bottomLeftColor;\n" +" vec4 _topRightColor;\n" +" vec2 _border;\n" +" float _totalArea;\n" +" vec4 _averageColor;\n" +" output_dummy _OUT;\n" +" _texelSize = 1.00000000E+00/TextureSize;\n" +" _subtexelSize = _texelSize/vec2( 3.00000000E+00, 1.00000000E+00);\n" +" _range = InputSize/(OutputSize*TextureSize);\n" +" _left = TEX0.x - _texelSize.x*5.00000000E-01;\n" +" _top = TEX0.y + _range.y;\n" +" _right = TEX0.x + _texelSize.x*5.00000000E-01;\n" +" _bottom = TEX0.y - _range.y;\n" +" _x0030 = TEX0.x/_subtexelSize.x + 1.50000000E+00;\n" +" _x0032 = _x0030/3.00000000E+00;\n" +" _TMP18 = floor(_x0032);\n" +" _subpix = _x0030 - 3.00000000E+00*_TMP18;\n" +" _rsubpix = _range.x/_subtexelSize.x;\n" +" _x0034 = _subpix + 1.00000000E+00;\n" +" _x0036 = (_x0034 - _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0036);\n" +" _TMP35 = max(-1.00000000E+00, _TMP26);\n" +" _x0042 = (_x0034 + _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0042);\n" +" _TMP41 = max(-1.00000000E+00, _TMP26);\n" +" _z20048 = _TMP41*_TMP41;\n" +" _z40048 = _z20048*_z20048;\n" +" _z80048 = _z40048*_z40048;\n" +" _TMP19 = (((((_TMP41 - 6.66666687E-01*_TMP41*_z20048) - 2.00000003E-01*_TMP41*_z40048) + 5.71428597E-01*_TMP41*_z20048*_z40048) - 1.11111112E-01*_TMP41*_z80048) - 1.81818187E-01*_TMP41*_z20048*_z80048) + 7.69230798E-02*_TMP41*_z40048*_z80048;\n" +" _z20050 = _TMP35*_TMP35;\n" +" _z40050 = _z20050*_z20050;\n" +" _z80050 = _z40050*_z40050;\n" +" _TMP20 = (((((_TMP35 - 6.66666687E-01*_TMP35*_z20050) - 2.00000003E-01*_TMP35*_z40050) + 5.71428597E-01*_TMP35*_z20050*_z40050) - 1.11111112E-01*_TMP35*_z80050) - 1.81818187E-01*_TMP35*_z20050*_z80050) + 7.69230798E-02*_TMP35*_z40050*_z80050;\n" +" _TMP0 = (1.50000000E+00*(_TMP19 - _TMP20))/(2.00000000E+00*_rsubpix);\n" +" _x0054 = (_subpix - _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0054);\n" +" _TMP53 = max(-1.00000000E+00, _TMP26);\n" +" _x0060 = (_subpix + _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0060);\n" +" _TMP59 = max(-1.00000000E+00, _TMP26);\n" +" _z20066 = _TMP59*_TMP59;\n" +" _z40066 = _z20066*_z20066;\n" +" _z80066 = _z40066*_z40066;\n" +" _TMP19 = (((((_TMP59 - 6.66666687E-01*_TMP59*_z20066) - 2.00000003E-01*_TMP59*_z40066) + 5.71428597E-01*_TMP59*_z20066*_z40066) - 1.11111112E-01*_TMP59*_z80066) - 1.81818187E-01*_TMP59*_z20066*_z80066) + 7.69230798E-02*_TMP59*_z40066*_z80066;\n" +" _z20068 = _TMP53*_TMP53;\n" +" _z40068 = _z20068*_z20068;\n" +" _z80068 = _z40068*_z40068;\n" +" _TMP20 = (((((_TMP53 - 6.66666687E-01*_TMP53*_z20068) - 2.00000003E-01*_TMP53*_z40068) + 5.71428597E-01*_TMP53*_z20068*_z40068) - 1.11111112E-01*_TMP53*_z80068) - 1.81818187E-01*_TMP53*_z20068*_z80068) + 7.69230798E-02*_TMP53*_z40068*_z80068;\n" +" _TMP1 = (1.50000000E+00*(_TMP19 - _TMP20))/(2.00000000E+00*_rsubpix);\n" +" _x0070 = _subpix - 1.00000000E+00;\n" +" _x0072 = (_x0070 - _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0072);\n" +" _TMP71 = max(-1.00000000E+00, _TMP26);\n" +" _x0078 = (_x0070 + _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0078);\n" +" _TMP77 = max(-1.00000000E+00, _TMP26);\n" +" _z20084 = _TMP77*_TMP77;\n" +" _z40084 = _z20084*_z20084;\n" +" _z80084 = _z40084*_z40084;\n" +" _TMP19 = (((((_TMP77 - 6.66666687E-01*_TMP77*_z20084) - 2.00000003E-01*_TMP77*_z40084) + 5.71428597E-01*_TMP77*_z20084*_z40084) - 1.11111112E-01*_TMP77*_z80084) - 1.81818187E-01*_TMP77*_z20084*_z80084) + 7.69230798E-02*_TMP77*_z40084*_z80084;\n" +" _z20086 = _TMP71*_TMP71;\n" +" _z40086 = _z20086*_z20086;\n" +" _z80086 = _z40086*_z40086;\n" +" _TMP20 = (((((_TMP71 - 6.66666687E-01*_TMP71*_z20086) - 2.00000003E-01*_TMP71*_z40086) + 5.71428597E-01*_TMP71*_z20086*_z40086) - 1.11111112E-01*_TMP71*_z80086) - 1.81818187E-01*_TMP71*_z20086*_z80086) + 7.69230798E-02*_TMP71*_z40086*_z80086;\n" +" _TMP2 = (1.50000000E+00*(_TMP19 - _TMP20))/(2.00000000E+00*_rsubpix);\n" +" _lcol = vec4(_TMP0, _TMP1, _TMP2, 0.00000000E+00);\n" +" _x0088 = _subpix - 2.00000000E+00;\n" +" _x0090 = (_x0088 - _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0090);\n" +" _TMP89 = max(-1.00000000E+00, _TMP26);\n" +" _x0096 = (_x0088 + _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0096);\n" +" _TMP95 = max(-1.00000000E+00, _TMP26);\n" +" _z20102 = _TMP95*_TMP95;\n" +" _z40102 = _z20102*_z20102;\n" +" _z80102 = _z40102*_z40102;\n" +" _TMP19 = (((((_TMP95 - 6.66666687E-01*_TMP95*_z20102) - 2.00000003E-01*_TMP95*_z40102) + 5.71428597E-01*_TMP95*_z20102*_z40102) - 1.11111112E-01*_TMP95*_z80102) - 1.81818187E-01*_TMP95*_z20102*_z80102) + 7.69230798E-02*_TMP95*_z40102*_z80102;\n" +" _z20104 = _TMP89*_TMP89;\n" +" _z40104 = _z20104*_z20104;\n" +" _z80104 = _z40104*_z40104;\n" +" _TMP20 = (((((_TMP89 - 6.66666687E-01*_TMP89*_z20104) - 2.00000003E-01*_TMP89*_z40104) + 5.71428597E-01*_TMP89*_z20104*_z40104) - 1.11111112E-01*_TMP89*_z80104) - 1.81818187E-01*_TMP89*_z20104*_z80104) + 7.69230798E-02*_TMP89*_z40104*_z80104;\n" +" _TMP3 = (1.50000000E+00*(_TMP19 - _TMP20))/(2.00000000E+00*_rsubpix);\n" +" _x0106 = _subpix - 3.00000000E+00;\n" +" _x0108 = (_x0106 - _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0108);\n" +" _TMP107 = max(-1.00000000E+00, _TMP26);\n" +" _x0114 = (_x0106 + _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0114);\n" +" _TMP113 = max(-1.00000000E+00, _TMP26);\n" +" _z20120 = _TMP113*_TMP113;\n" +" _z40120 = _z20120*_z20120;\n" +" _z80120 = _z40120*_z40120;\n" +" _TMP19 = (((((_TMP113 - 6.66666687E-01*_TMP113*_z20120) - 2.00000003E-01*_TMP113*_z40120) + 5.71428597E-01*_TMP113*_z20120*_z40120) - 1.11111112E-01*_TMP113*_z80120) - 1.81818187E-01*_TMP113*_z20120*_z80120) + 7.69230798E-02*_TMP113*_z40120*_z80120;\n" +" _z20122 = _TMP107*_TMP107;\n" +" _z40122 = _z20122*_z20122;\n" +" _z80122 = _z40122*_z40122;\n" +" _TMP20 = (((((_TMP107 - 6.66666687E-01*_TMP107*_z20122) - 2.00000003E-01*_TMP107*_z40122) + 5.71428597E-01*_TMP107*_z20122*_z40122) - 1.11111112E-01*_TMP107*_z80122) - 1.81818187E-01*_TMP107*_z20122*_z80122) + 7.69230798E-02*_TMP107*_z40122*_z80122;\n" +" _TMP4 = (1.50000000E+00*(_TMP19 - _TMP20))/(2.00000000E+00*_rsubpix);\n" +" _x0124 = _subpix - 4.00000000E+00;\n" +" _x0126 = (_x0124 - _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0126);\n" +" _TMP125 = max(-1.00000000E+00, _TMP26);\n" +" _x0132 = (_x0124 + _rsubpix)/1.50000000E+00;\n" +" _TMP26 = min(1.00000000E+00, _x0132);\n" +" _TMP131 = max(-1.00000000E+00, _TMP26);\n" +" _z20138 = _TMP131*_TMP131;\n" +" _z40138 = _z20138*_z20138;\n" +" _z80138 = _z40138*_z40138;\n" +" _TMP19 = (((((_TMP131 - 6.66666687E-01*_TMP131*_z20138) - 2.00000003E-01*_TMP131*_z40138) + 5.71428597E-01*_TMP131*_z20138*_z40138) - 1.11111112E-01*_TMP131*_z80138) - 1.81818187E-01*_TMP131*_z20138*_z80138) + 7.69230798E-02*_TMP131*_z40138*_z80138;\n" +" _z20140 = _TMP125*_TMP125;\n" +" _z40140 = _z20140*_z20140;\n" +" _z80140 = _z40140*_z40140;\n" +" _TMP20 = (((((_TMP125 - 6.66666687E-01*_TMP125*_z20140) - 2.00000003E-01*_TMP125*_z40140) + 5.71428597E-01*_TMP125*_z20140*_z40140) - 1.11111112E-01*_TMP125*_z80140) - 1.81818187E-01*_TMP125*_z20140*_z80140) + 7.69230798E-02*_TMP125*_z40140*_z80140;\n" +" _TMP5 = (1.50000000E+00*(_TMP19 - _TMP20))/(2.00000000E+00*_rsubpix);\n" +" _rcol = vec4(_TMP3, _TMP4, _TMP5, 0.00000000E+00);\n" +" _x0142 = vec2(_left, _top)/_texelSize;\n" +" _TMP6 = floor(_x0142);\n" +" _c0144 = (_TMP6 + 5.00000000E-01)*_texelSize;\n" +" _TMP7 = COMPAT_TEXTURE(Texture, _c0144);\n" +" _TMP21 = pow(_TMP7.x, 2.20000005E+00);\n" +" _TMP22 = pow(_TMP7.y, 2.20000005E+00);\n" +" _TMP23 = pow(_TMP7.z, 2.20000005E+00);\n" +" _TMP24 = pow(_TMP7.w, 2.20000005E+00);\n" +" _TMP8 = vec4(_TMP21, _TMP22, _TMP23, _TMP24);\n" +" _topLeftColor = _TMP8*_lcol;\n" +" _x0156 = vec2(_right, _bottom)/_texelSize;\n" +" _TMP9 = floor(_x0156);\n" +" _c0158 = (_TMP9 + 5.00000000E-01)*_texelSize;\n" +" _TMP10 = COMPAT_TEXTURE(Texture, _c0158);\n" +" _TMP21 = pow(_TMP10.x, 2.20000005E+00);\n" +" _TMP22 = pow(_TMP10.y, 2.20000005E+00);\n" +" _TMP23 = pow(_TMP10.z, 2.20000005E+00);\n" +" _TMP24 = pow(_TMP10.w, 2.20000005E+00);\n" +" _TMP11 = vec4(_TMP21, _TMP22, _TMP23, _TMP24);\n" +" _bottomRightColor = _TMP11*_rcol;\n" +" _x0170 = vec2(_left, _bottom)/_texelSize;\n" +" _TMP12 = floor(_x0170);\n" +" _c0172 = (_TMP12 + 5.00000000E-01)*_texelSize;\n" +" _TMP13 = COMPAT_TEXTURE(Texture, _c0172);\n" +" _TMP21 = pow(_TMP13.x, 2.20000005E+00);\n" +" _TMP22 = pow(_TMP13.y, 2.20000005E+00);\n" +" _TMP23 = pow(_TMP13.z, 2.20000005E+00);\n" +" _TMP24 = pow(_TMP13.w, 2.20000005E+00);\n" +" _TMP14 = vec4(_TMP21, _TMP22, _TMP23, _TMP24);\n" +" _bottomLeftColor = _TMP14*_lcol;\n" +" _x0184 = vec2(_right, _top)/_texelSize;\n" +" _TMP15 = floor(_x0184);\n" +" _c0186 = (_TMP15 + 5.00000000E-01)*_texelSize;\n" +" _TMP16 = COMPAT_TEXTURE(Texture, _c0186);\n" +" _TMP21 = pow(_TMP16.x, 2.20000005E+00);\n" +" _TMP22 = pow(_TMP16.y, 2.20000005E+00);\n" +" _TMP23 = pow(_TMP16.z, 2.20000005E+00);\n" +" _TMP24 = pow(_TMP16.w, 2.20000005E+00);\n" +" _TMP17 = vec4(_TMP21, _TMP22, _TMP23, _TMP24);\n" +" _topRightColor = _TMP17*_rcol;\n" +" _x0198 = TEX0.xy/_subtexelSize + 5.00000000E-01;\n" +" _border = floor(_x0198);\n" +" _x0200 = (_border + vec2( 0.00000000E+00, GRID_STRENGTH))*_subtexelSize;\n" +" _a0200 = vec2(_left, _bottom);\n" +" _b0200 = vec2(_right, _top);\n" +" _TMP25 = min(_b0200, _x0200);\n" +" _TMP199 = max(_a0200, _TMP25);\n" +" _x0206 = (_border + vec2( 0.00000000E+00, -GRID_STRENGTH))*_subtexelSize;\n" +" _a0206 = vec2(_left, _bottom);\n" +" _b0206 = vec2(_right, _top);\n" +" _TMP25 = min(_b0206, _x0206);\n" +" _TMP205 = max(_a0206, _TMP25);\n" +" _totalArea = 2.00000000E+00*_range.y;\n" +" _averageColor = ((_top - _TMP199.y)/_totalArea)*_topLeftColor;\n" +" _averageColor = _averageColor + ((_TMP205.y - _bottom)/_totalArea)*_bottomRightColor;\n" +" _averageColor = _averageColor + ((_TMP205.y - _bottom)/_totalArea)*_bottomLeftColor;\n" +" _averageColor = _averageColor + ((_top - _TMP199.y)/_totalArea)*_topRightColor;\n" +" _TMP21 = pow(_averageColor.x, 4.54545438E-01);\n" +" _TMP22 = pow(_averageColor.y, 4.54545438E-01);\n" +" _TMP23 = pow(_averageColor.z, 4.54545438E-01);\n" +" _TMP24 = pow(_averageColor.w, 4.54545438E-01);\n" +" _OUT._col = vec4(_TMP21, _TMP22, _TMP23, _TMP24);\n" +" FragColor = _OUT._col;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/hqx/hq3x.h b/src/video/sdl/shaders/hunterk/hqx/hq3x.h new file mode 100644 index 000000000..1b183fe14 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/hqx/hq3x.h @@ -0,0 +1,199 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct orig {\n" +" vec2 _tex_coord;\n" +" vec2 _texture_size1;\n" +"float _placeholder22;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord1;\n" +"};\n" +"out_vertex _ret_0;\n" +"vec4 _r0009;\n" +"vec4 _v0009;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" _v0009 = vec4(float(VertexCoord.x), float(VertexCoord.y), float(VertexCoord.z), float(VertexCoord.w));\n" +" _r0009 = _v0009.x*MVPMatrix[0];\n" +" _r0009 = _r0009 + _v0009.y*MVPMatrix[1];\n" +" _r0009 = _r0009 + _v0009.z*MVPMatrix[2];\n" +" _r0009 = _r0009 + _v0009.w*MVPMatrix[3];\n" +" _OUT._position1 = vec4(float(_r0009.x), float(_r0009.y), float(_r0009.z), float(_r0009.w));\n" +" _ret_0._position1 = _OUT._position1;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" gl_Position = _OUT._position1;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct orig {\n" +" vec2 _tex_coord;\n" +" vec2 _texture_size;\n" +"float _placeholder31;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size1;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color;\n" +" vec2 _texCoord;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP10;\n" +"vec4 _TMP8;\n" +"float _TMP7;\n" +"vec2 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec2 _TMP0;\n" +"uniform sampler2D Texture;\n" +"orig _ORIG1;\n" +"input_dummy _IN1;\n" +"uniform sampler2D LUT;\n" +"vec2 _x0019;\n" +"vec2 _val0021;\n" +"vec2 _a0021;\n" +"vec2 _c0025;\n" +"vec2 _c0027;\n" +"vec2 _c0029;\n" +"vec2 _x0033;\n" +"vec2 _c0037;\n" +"vec3 _r0043;\n" +"vec4 _v0043;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform COMPAT_PRECISION vec2 OrigTextureSize;\n" +"uniform sampler2D OrigTexture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _fp;\n" +" vec2 _quad;\n" +" vec2 _ps;\n" +" vec3 _pixels[4];\n" +" vec2 _index;\n" +" vec4 _weights;\n" +" float _sum;\n" +" vec3 _TMP17[4];\n" +" _x0019 = TEX0.xy*TextureSize;\n" +" _fp = fract(_x0019);\n" +" _a0021 = -5.00000000E-01 + _fp;\n" +" _val0021 = vec2(float((_a0021.x > 0.00000000E+00)), float((_a0021.y > 0.00000000E+00)));\n" +" _TMP0 = _val0021 - vec2(float((_a0021.x < 0.00000000E+00)), float((_a0021.y < 0.00000000E+00)));\n" +" _quad = vec2(float(_TMP0.x), float(_TMP0.y));\n" +" _ps = 1.00000000E+00/OrigTextureSize;\n" +" _TMP1 = COMPAT_TEXTURE(OrigTexture, TEX0.xy);\n" +" _c0025 = TEX0.xy + vec2(_ps.x, _ps.y)*vec2(float(_quad.x), float(_quad.y));\n" +" _TMP2 = COMPAT_TEXTURE(OrigTexture, _c0025);\n" +" _c0027 = TEX0.xy + vec2(_ps.x, 0.00000000E+00)*vec2(float(_quad.x), float(_quad.y));\n" +" _TMP3 = COMPAT_TEXTURE(OrigTexture, _c0027);\n" +" _c0029 = TEX0.xy + vec2(0.00000000E+00, _ps.y)*vec2(float(_quad.x), float(_quad.y));\n" +" _TMP4 = COMPAT_TEXTURE(OrigTexture, _c0029);\n" +" _TMP17[0] = vec3(float(_TMP1.x), float(_TMP1.y), float(_TMP1.z));\n" +" _TMP17[1] = vec3(float(_TMP2.x), float(_TMP2.y), float(_TMP2.z));\n" +" _TMP17[2] = vec3(float(_TMP3.x), float(_TMP3.y), float(_TMP3.z));\n" +" _TMP17[3] = vec3(float(_TMP4.x), float(_TMP4.y), float(_TMP4.z));\n" +" _pixels[0] = vec3(float(_TMP17[0].x), float(_TMP17[0].y), float(_TMP17[0].z));\n" +" _pixels[1] = vec3(float(_TMP17[1].x), float(_TMP17[1].y), float(_TMP17[1].z));\n" +" _pixels[2] = vec3(float(_TMP17[2].x), float(_TMP17[2].y), float(_TMP17[2].z));\n" +" _pixels[3] = vec3(float(_TMP17[3].x), float(_TMP17[3].y), float(_TMP17[3].z));\n" +" _TMP5 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _index = vec2(float((_TMP5.xy*vec2( 2.55000000E+02, 1.35000000E+02)).x), float((_TMP5.xy*vec2( 2.55000000E+02, 1.35000000E+02)).y));\n" +" _x0033 = _fp*3.00000000E+00;\n" +" _TMP6 = floor(_x0033);\n" +" _TMP7 = dot(_TMP6, vec2( 1.00000000E+00, 3.00000000E+00));\n" +" _index.y = float((float(_index.y) + _TMP7));\n" +" _c0037 = vec2(float((_index*vec2( 3.90625000E-03, 6.94274902E-03) + vec2( 1.95312500E-03, 3.47137451E-03)).x), float((_index*vec2( 3.90625000E-03, 6.94274902E-03) + vec2( 1.95312500E-03, 3.47137451E-03)).y));\n" +" _TMP8 = COMPAT_TEXTURE(LUT, _c0037);\n" +" _weights = vec4(float(_TMP8.x), float(_TMP8.y), float(_TMP8.z), float(_TMP8.w));\n" +" _TMP10 = dot(vec4(float(_weights.x), float(_weights.y), float(_weights.z), float(_weights.w)), vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _sum = float(_TMP10);\n" +" _v0043 = vec4(float((_weights/_sum).x), float((_weights/_sum).y), float((_weights/_sum).z), float((_weights/_sum).w));\n" +" _r0043 = _v0043.x*_pixels[0];\n" +" _r0043 = _r0043 + _v0043.y*_pixels[1];\n" +" _r0043 = _r0043 + _v0043.z*_pixels[2];\n" +" _r0043 = _r0043 + _v0043.w*_pixels[3];\n" +" _ret_0 = vec4(_r0043.x, _r0043.y, _r0043.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/hqx/pass1.h b/src/video/sdl/shaders/hunterk/hqx/pass1.h new file mode 100644 index 000000000..cab7769e4 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/hqx/pass1.h @@ -0,0 +1,381 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord1;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +"};\n" +"out_vertex _ret_0;\n" +"input_dummy _IN1;\n" +"vec4 _r0010;\n" +"vec4 _v0010;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" vec2 _ps;\n" +" _v0010 = vec4(float(VertexCoord.x), float(VertexCoord.y), float(VertexCoord.z), float(VertexCoord.w));\n" +" _r0010 = _v0010.x*MVPMatrix[0];\n" +" _r0010 = _r0010 + _v0010.y*MVPMatrix[1];\n" +" _r0010 = _r0010 + _v0010.z*MVPMatrix[2];\n" +" _r0010 = _r0010 + _v0010.w*MVPMatrix[3];\n" +" _OUT._position1 = vec4(float(_r0010.x), float(_r0010.y), float(_r0010.z), float(_r0010.w));\n" +" _ps = 1.00000000E+00/TextureSize;\n" +" _OUT._t1 = TexCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), float(float(-_ps.y)));\n" +" _OUT._t2 = TexCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), 0.00000000E+00);\n" +" _OUT._t3 = TexCoord.xxxy + vec4(float(float(-_ps.x)), 0.00000000E+00, float(float(_ps.x)), float(float(_ps.y)));\n" +" _ret_0._position1 = _OUT._position1;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" _ret_0._t1 = _OUT._t1;\n" +" _ret_0._t2 = _OUT._t2;\n" +" _ret_0._t3 = _OUT._t3;\n" +" gl_Position = _OUT._position1;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +" TEX1 = _OUT._t1;\n" +" TEX2 = _OUT._t2;\n" +" TEX3 = _OUT._t3;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +" TEX1 = _ret_0._t1;\n" +" TEX2 = _ret_0._t2;\n" +" TEX3 = _ret_0._t3;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color;\n" +" vec2 _texCoord;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP35;\n" +"float _TMP32;\n" +"float _TMP31;\n" +"float _TMP30;\n" +"float _TMP34;\n" +"bool _TMP29;\n" +"bool _TMP28;\n" +"bool _TMP27;\n" +"bool _TMP26;\n" +"vec3 _TMP33;\n" +"bool _TMP25;\n" +"bool _TMP24;\n" +"bool _TMP23;\n" +"bool _TMP22;\n" +"bool _TMP21;\n" +"bool _TMP20;\n" +"bool _TMP19;\n" +"bool _TMP18;\n" +"vec4 _TMP16;\n" +"vec4 _TMP14;\n" +"vec4 _TMP12;\n" +"vec4 _TMP10;\n" +"vec4 _TMP8;\n" +"vec4 _TMP6;\n" +"vec4 _TMP4;\n" +"vec4 _TMP2;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"vec3 _r0055;\n" +"vec3 _v0055;\n" +"vec3 _r0065;\n" +"vec3 _v0065;\n" +"vec3 _r0075;\n" +"vec3 _v0075;\n" +"vec3 _r0085;\n" +"vec3 _v0085;\n" +"vec3 _r0095;\n" +"vec3 _v0095;\n" +"vec3 _r0105;\n" +"vec3 _v0105;\n" +"vec3 _r0115;\n" +"vec3 _v0115;\n" +"vec3 _r0125;\n" +"vec3 _v0125;\n" +"vec3 _r0135;\n" +"vec3 _v0135;\n" +"bvec3 _res0143;\n" +"vec3 _a0145;\n" +"bvec3 _res0147;\n" +"vec3 _a0149;\n" +"bvec3 _res0151;\n" +"vec3 _a0153;\n" +"bvec3 _res0155;\n" +"vec3 _a0157;\n" +"bvec3 _res0159;\n" +"vec3 _a0161;\n" +"bvec3 _res0163;\n" +"vec3 _a0165;\n" +"bvec3 _res0167;\n" +"vec3 _a0169;\n" +"bvec3 _res0171;\n" +"vec3 _a0173;\n" +"bvec3 _res0175;\n" +"vec3 _a0177;\n" +"bvec3 _res0179;\n" +"vec3 _a0181;\n" +"bvec3 _res0183;\n" +"vec3 _a0185;\n" +"bvec3 _res0187;\n" +"vec3 _a0189;\n" +"vec3 _a0191;\n" +"vec3 _a0193;\n" +"vec3 _a0195;\n" +"vec4 _a0197;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _w1;\n" +" vec3 _w2;\n" +" vec3 _w3;\n" +" vec3 _w4;\n" +" vec3 _w5;\n" +" vec3 _w6;\n" +" vec3 _w7;\n" +" vec3 _w8;\n" +" vec3 _w9;\n" +" bvec4 _cross;\n" +" vec2 _index;\n" +" vec2 _TMP40;\n" +" bvec3 _TMP41[3];\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX1.xw);\n" +" _v0055 = vec3(float(_TMP0.x), float(_TMP0.y), float(_TMP0.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0055.x), float(_v0055.y), float(_v0055.z)));\n" +" _r0055.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0055.x), float(_v0055.y), float(_v0055.z)));\n" +" _r0055.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0055.x), float(_v0055.y), float(_v0055.z)));\n" +" _r0055.z = float(_TMP34);\n" +" _w1 = vec3(float(_r0055.x), float(_r0055.y), float(_r0055.z));\n" +" _TMP2 = COMPAT_TEXTURE(Texture, TEX1.yw);\n" +" _v0065 = vec3(float(_TMP2.x), float(_TMP2.y), float(_TMP2.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0065.x), float(_v0065.y), float(_v0065.z)));\n" +" _r0065.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0065.x), float(_v0065.y), float(_v0065.z)));\n" +" _r0065.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0065.x), float(_v0065.y), float(_v0065.z)));\n" +" _r0065.z = float(_TMP34);\n" +" _w2 = vec3(float(_r0065.x), float(_r0065.y), float(_r0065.z));\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX1.zw);\n" +" _v0075 = vec3(float(_TMP4.x), float(_TMP4.y), float(_TMP4.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0075.x), float(_v0075.y), float(_v0075.z)));\n" +" _r0075.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0075.x), float(_v0075.y), float(_v0075.z)));\n" +" _r0075.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0075.x), float(_v0075.y), float(_v0075.z)));\n" +" _r0075.z = float(_TMP34);\n" +" _w3 = vec3(float(_r0075.x), float(_r0075.y), float(_r0075.z));\n" +" _TMP6 = COMPAT_TEXTURE(Texture, TEX2.xw);\n" +" _v0085 = vec3(float(_TMP6.x), float(_TMP6.y), float(_TMP6.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0085.x), float(_v0085.y), float(_v0085.z)));\n" +" _r0085.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0085.x), float(_v0085.y), float(_v0085.z)));\n" +" _r0085.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0085.x), float(_v0085.y), float(_v0085.z)));\n" +" _r0085.z = float(_TMP34);\n" +" _w4 = vec3(float(_r0085.x), float(_r0085.y), float(_r0085.z));\n" +" _TMP8 = COMPAT_TEXTURE(Texture, TEX2.yw);\n" +" _v0095 = vec3(float(_TMP8.x), float(_TMP8.y), float(_TMP8.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0095.x), float(_v0095.y), float(_v0095.z)));\n" +" _r0095.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0095.x), float(_v0095.y), float(_v0095.z)));\n" +" _r0095.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0095.x), float(_v0095.y), float(_v0095.z)));\n" +" _r0095.z = float(_TMP34);\n" +" _w5 = vec3(float(_r0095.x), float(_r0095.y), float(_r0095.z));\n" +" _TMP10 = COMPAT_TEXTURE(Texture, TEX2.zw);\n" +" _v0105 = vec3(float(_TMP10.x), float(_TMP10.y), float(_TMP10.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0105.x), float(_v0105.y), float(_v0105.z)));\n" +" _r0105.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0105.x), float(_v0105.y), float(_v0105.z)));\n" +" _r0105.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0105.x), float(_v0105.y), float(_v0105.z)));\n" +" _r0105.z = float(_TMP34);\n" +" _w6 = vec3(float(_r0105.x), float(_r0105.y), float(_r0105.z));\n" +" _TMP12 = COMPAT_TEXTURE(Texture, TEX3.xw);\n" +" _v0115 = vec3(float(_TMP12.x), float(_TMP12.y), float(_TMP12.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0115.x), float(_v0115.y), float(_v0115.z)));\n" +" _r0115.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0115.x), float(_v0115.y), float(_v0115.z)));\n" +" _r0115.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0115.x), float(_v0115.y), float(_v0115.z)));\n" +" _r0115.z = float(_TMP34);\n" +" _w7 = vec3(float(_r0115.x), float(_r0115.y), float(_r0115.z));\n" +" _TMP14 = COMPAT_TEXTURE(Texture, TEX3.yw);\n" +" _v0125 = vec3(float(_TMP14.x), float(_TMP14.y), float(_TMP14.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0125.x), float(_v0125.y), float(_v0125.z)));\n" +" _r0125.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0125.x), float(_v0125.y), float(_v0125.z)));\n" +" _r0125.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0125.x), float(_v0125.y), float(_v0125.z)));\n" +" _r0125.z = float(_TMP34);\n" +" _w8 = vec3(float(_r0125.x), float(_r0125.y), float(_r0125.z));\n" +" _TMP16 = COMPAT_TEXTURE(Texture, TEX3.zw);\n" +" _v0135 = vec3(float(_TMP16.x), float(_TMP16.y), float(_TMP16.z));\n" +" _TMP34 = dot(vec3( 2.99072266E-01, 5.86914062E-01, 1.14013672E-01), vec3(float(_v0135.x), float(_v0135.y), float(_v0135.z)));\n" +" _r0135.x = float(_TMP34);\n" +" _TMP34 = dot(vec3( -1.68945312E-01, -3.31054688E-01, 5.00000000E-01), vec3(float(_v0135.x), float(_v0135.y), float(_v0135.z)));\n" +" _r0135.y = float(_TMP34);\n" +" _TMP34 = dot(vec3( 5.00000000E-01, -4.18945312E-01, -8.09936523E-02), vec3(float(_v0135.x), float(_v0135.y), float(_v0135.z)));\n" +" _r0135.z = float(_TMP34);\n" +" _w9 = vec3(float(_r0135.x), float(_r0135.y), float(_r0135.z));\n" +" _a0145 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w1 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0145);\n" +" _res0143 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP18 = _res0143.x || _res0143.y || _res0143.z;\n" +" _a0149 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w2 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0149);\n" +" _res0147 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP19 = _res0147.x || _res0147.y || _res0147.z;\n" +" _a0153 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w3 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0153);\n" +" _res0151 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP20 = _res0151.x || _res0151.y || _res0151.z;\n" +" _a0157 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w4 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0157);\n" +" _res0155 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP21 = _res0155.x || _res0155.y || _res0155.z;\n" +" _a0161 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w6 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0161);\n" +" _res0159 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP22 = _res0159.x || _res0159.y || _res0159.z;\n" +" _a0165 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w7 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0165);\n" +" _res0163 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP23 = _res0163.x || _res0163.y || _res0163.z;\n" +" _a0169 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w8 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0169);\n" +" _res0167 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP24 = _res0167.x || _res0167.y || _res0167.z;\n" +" _a0173 = (_w5 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w9 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0173);\n" +" _res0171 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP25 = _res0171.x || _res0171.y || _res0171.z;\n" +" _TMP41[0] = bvec3(_TMP18, _TMP19, _TMP20);\n" +" _TMP41[1] = bvec3(_TMP21, false, _TMP22);\n" +" _TMP41[2] = bvec3(_TMP23, _TMP24, _TMP25);\n" +" _a0177 = (_w4 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w2 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0177);\n" +" _res0175 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP26 = _res0175.x || _res0175.y || _res0175.z;\n" +" _a0181 = (_w2 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w6 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0181);\n" +" _res0179 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP27 = _res0179.x || _res0179.y || _res0179.z;\n" +" _a0185 = (_w8 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w4 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0185);\n" +" _res0183 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP28 = _res0183.x || _res0183.y || _res0183.z;\n" +" _a0189 = (_w6 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01)) - (_w8 + vec3( 0.00000000E+00, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP33 = abs(_a0189);\n" +" _res0187 = bvec3(_TMP33.x > 1.88232422E-01, _TMP33.y > 2.74505615E-02, _TMP33.z > 2.35290527E-02);\n" +" _TMP29 = _res0187.x || _res0187.y || _res0187.z;\n" +" _cross = bvec4(_TMP26, _TMP27, _TMP28, _TMP29);\n" +" _a0191 = vec3(float(_TMP41[0].x), float(_TMP41[0].y), float(_TMP41[0].z));\n" +" _TMP34 = dot(vec3(float(_a0191.x), float(_a0191.y), float(_a0191.z)), vec3( 1.00000000E+00, 2.00000000E+00, 4.00000000E+00));\n" +" _TMP30 = float(_TMP34);\n" +" _a0193 = vec3(float(_TMP41[1].x), float(_TMP41[1].y), float(_TMP41[1].z));\n" +" _TMP34 = dot(vec3(float(_a0193.x), float(_a0193.y), float(_a0193.z)), vec3( 8.00000000E+00, 0.00000000E+00, 1.60000000E+01));\n" +" _TMP31 = float(_TMP34);\n" +" _a0195 = vec3(float(_TMP41[2].x), float(_TMP41[2].y), float(_TMP41[2].z));\n" +" _TMP34 = dot(vec3(float(_a0195.x), float(_a0195.y), float(_a0195.z)), vec3( 3.20000000E+01, 6.40000000E+01, 1.28000000E+02));\n" +" _TMP32 = float(_TMP34);\n" +" _index.x = _TMP30 + _TMP31 + _TMP32;\n" +" _a0197 = vec4(float(_cross.x), float(_cross.y), float(_cross.z), float(_cross.w));\n" +" _TMP35 = dot(vec4(float(_a0197.x), float(_a0197.y), float(_a0197.z), float(_a0197.w)), vec4( 1.00000000E+00, 2.00000000E+00, 4.00000000E+00, 8.00000000E+00));\n" +" _index.y = float(_TMP35);\n" +" _TMP40 = _index/vec2( 2.55000000E+02, 1.50000000E+01);\n" +" _ret_0 = vec4(float(_TMP40.x), float(_TMP40.y), 0.00000000E+00, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/hqx/resources/hq3x.png b/src/video/sdl/shaders/hunterk/hqx/resources/hq3x.png new file mode 100644 index 0000000000000000000000000000000000000000..6f5eb59c3f919354e5c8c421934f2b215eeb8f4b GIT binary patch literal 4665 zcmb_g2{=^!zt~ged%X9)_kZtm|Mz+R&wcK5p0oXazvrCq^ZkB5%Q;Ep{f@HI zYSLn2VzPUkhzG>PRw0*S=@?1mIDWh=135|hIXe=?;FXP8U2p>#S$*E=&>v!AG72mE zDzQ8F)+2*bp?h5&q<%;$Dw<)`B(6hZV%WyL#N8g3duDz5zUFGJaXCwmhMW2x7(}je zb8#TYfKP7RHPn>dljwQ1n`-U11?OiGzvhOv_st~P3~h^FQ?vcBNN11Dw_-QPui2?4 zjjup0Gpu?i;FS%_+pW}Ks}kVWTXoZ4UY$U z@H*Q7>6&waZJKZbzGmw%OBH^=!)L=2{CPh~0x`tvSl7T%+EAy_PaEQiwrTUvLQ%=N z6BC{EUorS9!Q{{3sUVpj8t0{IIuxv{^lJDY7V>y`Md4us53*gktllnO>scnc<|FKz zZ7m0A4U49JnQ$Zu6(q>>0A2o z{JR6_2hEj}9^%{UqSq!13}3*prkmJe2ZX%UN2DH|qC$L9pqREWB7vOWzdBh+;*?hDJ@vX%2)7$G z_t;w&F`ajr+f`d|t3#?MNusNG%CDI2>bfrx8{!3BOZ2f`cBKIQ1a#c0Ee*c>!yy2zVmPlJ8*3)J3wXNxy9#239YRKFV7g96c-Y%kU7kgoLbD^4-EU$zfySAd&J*)>OIxA!g8rc%n=7fVB`VzX?a z9|~52QlI-dBep==5PPA@c8?pWlQS0*Z~o?p(DZeY>iRFjer(k8hVQb4xiw3t^MA09 zE*uZv9%6t^%x?2fw90q5Z3}P5eJmwa3{n*E4M1|@@n#oMR+#e={x|eG*aIYkMM624 zH4RV9+`sx;P*@ZG<&T8?NzYW%qgqiZY+h~WgvbtSywCKRiRb#5BEg7HvcZO7_m zCH^6SOQ*x4eHTq|6t3W~#QBKgTvW9XP)+$6Ni z%R1w%?sMM8?N4Dfuyv!`}dUTmmvNxSSjv4D%PyPZ&*S|jAG*&|&u zaPjPsr(eR(;p|M?r_1V3@8^~G-xcD8?|;RtpZSwp%KqqbLI|slL5tNXjP0zW#Nq5% z_O`>1l^LU)b8l;!f)|%~r7WOsXEtz2Y5j2^%`n7ES(+uvVMUA$4rj@X;8lT5`5!Od zy`6Gcyu5BaY$Vm7msAlWP?>iWuywGevUT_13)%CW7Em=iKEr>*3|}Pd!oJW*7{B4a zo<86VkBiwc&Rqnz)eP)~zS(EGqYaAuUwUElEn-{-3oK$};c979)&rnO*~1sqEE*~v zrMO_7*ptc~6rA@bdC^)$9Ik=8XCaRpeWz%_)RlL*iDe0UCFAokrJ2AUn@+|?ydsr} z>A=B`!wER~M1t}9XV-08u_kHV#ls1S1m~%e$MFp7wasuik$HVN0Y|QfCsYXN*p;;^ zNF{y-X`!eXVz@{Os}~4LW2rm5ui(=08bx_dpY5@Q`8c+b0qPnz2ZM%(Xap1B#w7m1 z1mhvbLmk+b$i`bh+~RTgrvC4iTa(lAc{gS79;9>L-5DYLqYW9A>?y?(iWa0(6FW#+IyN6P>30!XZ?h4;nM4i zm8iFPY|9iI2dx7%n~vYHdTE@kD6As2#Q;^IAEIIq=y3hCZ%dTNU)8`mm6tCG^OTMq z80r$WzGw0MJMWWW=W)CQrQCds4v?|_+iULqyCkT%qu;grE?KF$jKgV;aY6bhpP&9E zl?JFx_tN)E_?M|=qbw=-IgM~w6r6+cxQmg%$*&1JUf1qhA-*$ce8As$gKT_mZHtic z3}fcwf6C!l*;U5-d+#zLbZsVp1W?lr{p6g)JnJ_!O%R8NU$NI~_X|&%q z4<{hm{H}4yCu8J4sN&fOb_?J|D&jV|MBTUoyN#wLHW6UwrecwElV+W+`n1<=^#+y- zWuwTv306pg2LJRO)v9PanIkopJpiw{>JxV>y5In^D&B6cbs+}SdzzrlBn zyJwa~s&8udU7$<0YU46@s%^`{NH{Q?RZaxu)XOe%7n$@@@dNm*X-qOCxv{w-6BWSY9vRTQMh2`Sj}r)bgx;8*xS7>*;*zAZC3Mr79U0np!A4>e03S*_nwdH~(?j+Kie>p_U9 z_B#I2>4mn6M<{C_O|Pf_gn+IqD9}T7HfqWY&C^ry;Pf*7r1aMhEx6Cd%lPkP+Y0^5 zjxB?cN{)#;p1Qy7;pYer@N@XygA5Hk7f?W0h>WmLuFN$uI=0qV#Y~=hMGjOSMj|I_ z>7jzw|BoV0thY-fgrZ@R0V?3yokO?tQ*oaxpbHMnGN{}GEl?}2hYIQ$_kn`9Izv`( zzVE~8Ng%3#+oFfc^gxHWj~IG+YR*G4_XO#`j#&CWna3 zpG?Nm{;(-U?*3(p7rLeQx1V}n_OEb`7D^koM9lL(AE%vaGXvt>U`^Su1+Oa)X#_{b zi{69%Zdknr);*k@zQe{d&oH5D5C~){x-A+^bu_Xf;Xygr94>IFeRJs0i5GurtHcx@ zRd##x>0x6PO^0~9Q{Ok}KcUV})8w;~5F{f-XoObCaOJ&!!3SQ0)jNV@It@R!;ybif rCjR>7s=tQDeX5nxLcY0%V5uPSH=vYzggf$+M{KXde&Ta`-`IZxzg{uP literal 0 HcmV?d00001 diff --git a/src/video/sdl/shaders/hunterk/misc/color-mangler.h b/src/video/sdl/shaders/hunterk/misc/color-mangler.h new file mode 100644 index 000000000..88cae2bae --- /dev/null +++ b/src/video/sdl/shaders/hunterk/misc/color-mangler.h @@ -0,0 +1,167 @@ +{ +"#pragma parameter display_gamma \"Display Gamma\" 2.2 0.0 10.0 0.1\n" +"#pragma parameter target_gamma \"Target Gamma\" 2.2 0.0 10.0 0.1\n" +"#pragma parameter sat \"Saturation\" 1.0 0.0 3.0 0.01\n" +"#pragma parameter lum \"Luminance\" 1.0 0.0 5.0 0.01\n" +"#pragma parameter cntrst \"Contrast\" 1.0 0.0 2.0 0.01\n" +"#pragma parameter r \"Red\" 1.0 0.0 2.0 0.01\n" +"#pragma parameter g \"Green\" 1.0 0.0 2.0 0.01\n" +"#pragma parameter b \"Blue\" 1.0 0.0 2.0 0.01\n" +"#pragma parameter rg \"Red-Green Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter rb \"Red-Blue Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter gr \"Green-Red Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter gb \"Green-Blue Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter br \"Blue-Red Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter bg \"Blue-Green Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter blr \"Black-Red Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter blg \"Black-Green Tint\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter blb \"Black-Blue Tint\" 0.0 0.0 1.0 0.005\n" +"#ifdef PARAMETER_UNIFORM\n" +"uniform float display_gamma;\n" +"uniform float target_gamma;\n" +"uniform float sat;\n" +"uniform float lum;\n" +"uniform float cntrst;\n" +"uniform float blr;\n" +"uniform float blg;\n" +"uniform float blb;\n" +"uniform float r;\n" +"uniform float g;\n" +"uniform float b;\n" +"uniform float rg;\n" +"uniform float rb;\n" +"uniform float gr;\n" +"uniform float gb;\n" +"uniform float br;\n" +"uniform float bg;\n" +"#else\n" +"#define display_gamma 2.2\n" +"#define target_gamma 2.2\n" +"#define sat 1.0\n" +"#define lum 1.0\n" +"#define cntrst 1.0\n" +"#define blr 0.0\n" +"#define blg 0.0\n" +"#define blb 0.0\n" +"#define r 1.0\n" +"#define g 1.0\n" +"#define b 1.0\n" +"#define rg 0.0\n" +"#define rb 0.0\n" +"#define gr 0.0\n" +"#define gb 0.0\n" +"#define br 0.0\n" +"#define bg 0.0\n" +"#endif\n" +"\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"\n" +"vec4 _oPosition1; \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _otexCoord;\n" +" gl_Position = VertexCoord.x * MVPMatrix[0] + VertexCoord.y * MVPMatrix[1] + VertexCoord.z * MVPMatrix[2] + VertexCoord.w * MVPMatrix[3];\n" +" _oPosition1 = gl_Position;\n" +" _oColor = COLOR;\n" +" _otexCoord = TexCoord.xy;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"}\n" +"\n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"uniform sampler2D Texture;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"//standard texture sample looks like this: COMPAT_TEXTURE(Texture, TEX0.xy);\n" +"\n" +"void main()\n" +"{\n" +" output_dummy _OUT;\n" +"\n" +"vec4 screen = pow(COMPAT_TEXTURE(Texture, TEX0.xy), vec4(target_gamma)).rgba; //sample image in linear colorspace\n" +"vec4 avglum = vec4(0.5);\n" +"screen = mix(screen, avglum, (1.0 - cntrst));\n" +"\n" +"mat4 color = mat4(\n" +"r, gr, br, blr,\n" +"rg, g, bg, blg,\n" +"rb, gb, b, blb,\n" +"0.0, 0.0, 0.0, 1.0);\n" +" \n" +"mat4 adjust = mat4(\n" +"(1.0 - sat) * 0.3086 + sat, (1.0 - sat) * 0.6094, (1.0 - sat) * 0.0820, 0.0,\n" +"(1.0 - sat) * 0.3086, (1.0 - sat) * 0.6094 + sat, (1.0 - sat) * 0.0820, 0.0,\n" +"(1.0 - sat) * 0.3086, (1.0 - sat) * 0.6094, (1.0 - sat) * 0.0820 + sat, 0.0,\n" +"1.0, 1.0, 1.0, 1.0);\n" +"\n" +"color *= adjust;\n" +"screen = clamp(screen * lum, 0.0, 1.0);\n" +"screen = screen * color;\n" +"screen = pow(screen, vec4(1.0 / display_gamma));\n" +"\n" +" _OUT._color = screen;\n" +" FragColor = _OUT._color;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/misc/image-adjustment.h b/src/video/sdl/shaders/hunterk/misc/image-adjustment.h new file mode 100644 index 000000000..be95c9fdf --- /dev/null +++ b/src/video/sdl/shaders/hunterk/misc/image-adjustment.h @@ -0,0 +1,212 @@ +{ +"#pragma parameter target_gamma \"Target Gamma\" 2.4 0.1 5.0 0.1\n" +"#pragma parameter monitor_gamma \"Monitor Gamma\" 2.2 0.1 5.0 0.1\n" +"#pragma parameter overscan_percent_x \"Horizontal Overscan %\" 0.0 -25.0 25.0 1.0\n" +"#pragma parameter overscan_percent_y \"Vertical Overscan %\" 0.0 -25.0 25.0 1.0\n" +"#pragma parameter saturation \"Saturation\" 1.0 0.0 5.0 0.1\n" +"#pragma parameter contrast \"Contrast\" 1.0 0.0 7.5 0.1\n" +"#pragma parameter luminance \"Luminance\" 1.0 0.0 2.0 0.1\n" +"#pragma parameter bright_boost \"Brightness Boost\" 0.0 -1.0 1.0 0.1\n" +"#pragma parameter R \"Red Channel\" 1.0 0.0 2.0 0.05\n" +"#pragma parameter G \"Green Channel\" 1.0 0.0 2.0 0.05\n" +"#pragma parameter B \"Blue Channel\" 1.0 0.0 2.0 0.05\n" +"#pragma parameter ZOOM \"Zoom Factor\" 1.0 0.0 4.0 0.01\n" +"#pragma parameter XPOS \"X Modifier\" 0.0 -2.0 2.0 0.005\n" +"#pragma parameter YPOS \"Y Modifier\" 0.0 -2.0 2.0 0.005\n" +"#pragma parameter V_OSMASK \"Overscan Mask Y\" 0.0 0.0 1.0 0.005\n" +"#pragma parameter H_OSMASK \"Overscan Mask X\" 0.0 0.0 1.0 0.005\n" +"#ifdef PARAMETER_UNIFORM\n" +"uniform float target_gamma;\n" +"uniform float monitor_gamma;\n" +"uniform float overscan_percent_x;\n" +"uniform float overscan_percent_y;\n" +"uniform float saturation;\n" +"uniform float contrast;\n" +"uniform float luminance;\n" +"uniform float bright_boost;\n" +"uniform float R;\n" +"uniform float G;\n" +"uniform float B;\n" +"uniform float ZOOM;\n" +"uniform float XPOS;\n" +"uniform float YPOS;\n" +"uniform float V_OSMASK;\n" +"uniform float H_OSMASK;\n" +"#else\n" +"#define overscan_percent_x 0.0 // crop width of image by X%; default is 0.0\n" +"#define overscan_percent_y 0.0 // crop height of image by X%; default is 0.0\n" +"#define saturation 1.0 // color saturation; default 1.0\n" +"#define monitor_gamma 2.2 // gamma setting of your current display; LCD monitors typically have a gamma of 2.2\n" +"#define target_gamma 2.4 // the gamma you want the image to have; CRT TVs typically have a gamma of 2.4\n" +"#define contrast 1.0 // image contrast; default 1.0\n" +"#define luminance 1.0 // image luminance; default 1.0\n" +"#define bright_boost 0.0 // adds to the total brightness. Negative values decrease it; Use values between 1.0 (totally white) and -1.0 (totally black); default is 0.0\n" +"#define R 1.0\n" +"#define G 1.0\n" +"#define B 1.0\n" +"#define ZOOM 1.0\n" +"#define XPOS 0.0\n" +"#define YPOS 0.0\n" +"#define V_OSMASK 0.0\n" +"#define H_OSMASK 0.0\n" +"#endif\n" +"\n" +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color1;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _otexCoord;\n" +" vec2 _shift;\n" +" vec2 _overscan_coord;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _shift = (5.00000000E-01*InputSize)/TextureSize;\n" +" _overscan_coord = ((TexCoord.xy - _shift) / ZOOM) * (1.0 - vec2(overscan_percent_x / 100.0, overscan_percent_y / 100.0)) + _shift;\n" +" _otexCoord = _overscan_coord;\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _overscan_coord + vec2(XPOS, YPOS);\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec3 _TMP29;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"\n" +"vec3 grayscale(vec3 col)\n" +"{\n" +" // ATSC grayscale standard\n" +" return vec3(dot(col, vec3(0.2126, 0.7152, 0.0722)));\n" +"}\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 fragcoord;\n" +" vec3 res;\n" +" vec3 gamma;\n" +" vec3 AvgLumin;\n" +" vec3 intensity;\n" +" vec3 satColor;\n" +" vec3 conColor;\n" +"\n" +" fragcoord = TEX0.xy*(TextureSize.xy/InputSize.xy);\n" +" res = COMPAT_TEXTURE(Texture, TEX0.xy).rgb;\n" +" gamma = vec3(monitor_gamma / target_gamma); // setup ratio of display's gamma vs desired gamma\n" +" AvgLumin = vec3(0.5);\n" +" intensity = grayscale(res); // find luminance\n" +" satColor = mix(intensity, res, saturation); // apply saturation\n" +" conColor = mix(AvgLumin, satColor, contrast); // apply contrast\n" +" conColor = pow(conColor, 1.0 / vec3(gamma)); // Apply gamma correction\n" +" conColor = clamp(conColor * luminance, 0.0, 1.0); // apply luminance\n" +" conColor += vec3(bright_boost); // apply brightboost\n" +" conColor *= vec3(R, G, B); // apply color channel adjustment\n" +"\n" +" if (fragcoord.y > V_OSMASK && fragcoord.y < (1.00000000E+00 - V_OSMASK)) { \n" +" } else {\n" +" conColor = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" } \n" +" if (fragcoord.x > H_OSMASK && fragcoord.x < (1.00000000E+00 - H_OSMASK)) { \n" +" } else {\n" +" conColor = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" } \n" +" _ret_0 = vec4(conColor.x, conColor.y, conColor.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/motionblur/braid-rewind.h b/src/video/sdl/shaders/hunterk/motionblur/braid-rewind.h new file mode 100644 index 000000000..a4f0734fb --- /dev/null +++ b/src/video/sdl/shaders/hunterk/motionblur/braid-rewind.h @@ -0,0 +1,162 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _col;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct previous {\n" +"float _placeholder20;\n" +" vec2 _tex_coord;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _col;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTexCoord;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _oTexCoord = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _col;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct previous {\n" +"float _placeholder57;\n" +" vec2 _tex_coord;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _col;\n" +"};\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"previous _PREV7;\n" +"previous _PREV11;\n" +"previous _PREV21;\n" +"previous _PREV31;\n" +"previous _PREV41;\n" +"previous _PREV51;\n" +"previous _PREV61;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform sampler2D Prev6Texture;\n" +"uniform sampler2D Prev5Texture;\n" +"uniform sampler2D Prev4Texture;\n" +"uniform sampler2D Prev3Texture;\n" +"uniform sampler2D Prev2Texture;\n" +"uniform sampler2D Prev1Texture;\n" +"uniform sampler2D PrevTexture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _current;\n" +" vec4 _color;\n" +" _current = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _color = COMPAT_TEXTURE(Prev6Texture, TEX0.xy);\n" +" _TMP0 = COMPAT_TEXTURE(Prev5Texture, TEX0.xy);\n" +" _color = _color + _TMP0;\n" +" _TMP1 = COMPAT_TEXTURE(Prev4Texture, TEX0.xy);\n" +" _color = _color + _TMP1;\n" +" _TMP2 = COMPAT_TEXTURE(Prev3Texture, TEX0.xy);\n" +" _color = _color + _TMP2;\n" +" _TMP3 = COMPAT_TEXTURE(Prev2Texture, TEX0.xy);\n" +" _color = _color + _TMP3;\n" +" _TMP4 = COMPAT_TEXTURE(Prev1Texture, TEX0.xy);\n" +" _color = _color + _TMP4;\n" +" _TMP5 = COMPAT_TEXTURE(PrevTexture, TEX0.xy);\n" +" _color = _color + _TMP5;\n" +" _color = _color + _current;\n" +//" if (float(FrameDirection) < 0.00000000E+00) { \n" +" _current = ((_current + _color/7.00000000E+00)/2.00000000E+00)*vec4( 1.00000000E+00, 8.00000012E-01, 6.00000024E-01, 1.00000000E+00);\n" +//" } \n" +" FragColor = _current;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/motionblur/motionblur-simple.h b/src/video/sdl/shaders/hunterk/motionblur/motionblur-simple.h new file mode 100644 index 000000000..76b61cf5f --- /dev/null +++ b/src/video/sdl/shaders/hunterk/motionblur/motionblur-simple.h @@ -0,0 +1,211 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _col;\n" +"COMPAT_VARYING vec2 VARprev6;\n" +"COMPAT_VARYING vec2 VARprev5;\n" +"COMPAT_VARYING vec2 VARprev4;\n" +"COMPAT_VARYING vec2 VARprev3;\n" +"COMPAT_VARYING vec2 VARprev2;\n" +"COMPAT_VARYING vec2 VARprev1;\n" +"COMPAT_VARYING vec2 VARprev;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 _tex_coord;\n" +"struct previous {\n" +"float _placeholder59;\n" +" vec2 _tex_coord;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"float _placeholder70;\n" +"};\n" +"struct tex_coords {\n" +" vec2 VARtex;\n" +" vec2 VARprev;\n" +" vec2 VARprev1;\n" +" vec2 VARprev2;\n" +" vec2 VARprev3;\n" +" vec2 VARprev4;\n" +" vec2 VARprev5;\n" +" vec2 VARprev6;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _col;\n" +"};\n" +"vec4 _oPosition1;\n" +"tex_coords _coords1;\n" +"previous _PREV7;\n" +"previous _PREV11;\n" +"previous _PREV21;\n" +"previous _PREV31;\n" +"previous _PREV41;\n" +"previous _PREV51;\n" +"previous _PREV61;\n" +"vec4 _r0013;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"COMPAT_ATTRIBUTE vec2 Prev6TexCoord;\n" +"COMPAT_ATTRIBUTE vec2 Prev5TexCoord;\n" +"COMPAT_ATTRIBUTE vec2 Prev4TexCoord;\n" +"COMPAT_ATTRIBUTE vec2 Prev3TexCoord;\n" +"COMPAT_ATTRIBUTE vec2 Prev2TexCoord;\n" +"COMPAT_ATTRIBUTE vec2 Prev1TexCoord;\n" +"COMPAT_ATTRIBUTE vec2 PrevTexCoord;\n" +"void main()\n" +"{\n" +" _r0013 = VertexCoord.x*MVPMatrix[0];\n" +" _r0013 = _r0013 + VertexCoord.y*MVPMatrix[1];\n" +" _r0013 = _r0013 + VertexCoord.z*MVPMatrix[2];\n" +" _r0013 = _r0013 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0013;\n" +" VARtex = TexCoord.xy;\n" +" VARprev = PrevTexCoord;\n" +" VARprev1 = Prev1TexCoord;\n" +" VARprev2 = Prev2TexCoord;\n" +" VARprev3 = Prev3TexCoord;\n" +" VARprev4 = Prev4TexCoord;\n" +" VARprev5 = Prev5TexCoord;\n" +" VARprev6 = Prev6TexCoord;\n" +" gl_Position = _r0013;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _col;\n" +"COMPAT_VARYING vec2 VARprev6;\n" +"COMPAT_VARYING vec2 VARprev5;\n" +"COMPAT_VARYING vec2 VARprev4;\n" +"COMPAT_VARYING vec2 VARprev3;\n" +"COMPAT_VARYING vec2 VARprev2;\n" +"COMPAT_VARYING vec2 VARprev1;\n" +"COMPAT_VARYING vec2 VARprev;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec2 VARtex_coord;\n" +"struct previous {\n" +"float _placeholder63;\n" +" vec2 VARtex_coord;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"float _placeholder74;\n" +"};\n" +"struct tex_coords {\n" +" vec2 VARtex;\n" +" vec2 VARprev;\n" +" vec2 VARprev1;\n" +" vec2 VARprev2;\n" +" vec2 VARprev3;\n" +" vec2 VARprev4;\n" +" vec2 VARprev5;\n" +" vec2 VARprev6;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _col;\n" +"};\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"tex_coords _coords1;\n" +"input_dummy _IN1;\n" +"previous _PREV7;\n" +"previous _PREV11;\n" +"previous _PREV21;\n" +"previous _PREV31;\n" +"previous _PREV41;\n" +"previous _PREV51;\n" +"previous _PREV61;\n" +" \n" +"uniform sampler2D Texture;\n" +"uniform sampler2D Prev6Texture;\n" +"uniform sampler2D Prev5Texture;\n" +"uniform sampler2D Prev4Texture;\n" +"uniform sampler2D Prev3Texture;\n" +"uniform sampler2D Prev2Texture;\n" +"uniform sampler2D Prev1Texture;\n" +"uniform sampler2D PrevTexture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _color;\n" +" _color = COMPAT_TEXTURE(Prev6Texture, VARprev6);\n" +" _TMP0 = COMPAT_TEXTURE(Prev5Texture, VARprev5);\n" +" _color = (_color + _TMP0)/2.00000000E+00;\n" +" _TMP1 = COMPAT_TEXTURE(Prev4Texture, VARprev4);\n" +" _color = (_color + _TMP1)/2.00000000E+00;\n" +" _TMP2 = COMPAT_TEXTURE(Prev3Texture, VARprev3);\n" +" _color = (_color + _TMP2)/2.00000000E+00;\n" +" _TMP3 = COMPAT_TEXTURE(Prev2Texture, VARprev2);\n" +" _color = (_color + _TMP3)/2.00000000E+00;\n" +" _TMP4 = COMPAT_TEXTURE(Prev1Texture, VARprev1);\n" +" _color = (_color + _TMP4)/2.00000000E+00;\n" +" _TMP5 = COMPAT_TEXTURE(PrevTexture, VARprev);\n" +" _color = (_color + _TMP5)/2.00000000E+00;\n" +" _TMP6 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _color = (_color + _TMP6)/2.00000000E+00;\n" +" FragColor = _color;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/bigblur-1080p.h b/src/video/sdl/shaders/hunterk/resources/bigblur-1080p.h new file mode 100644 index 000000000..4e172e6f9 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/bigblur-1080p.h @@ -0,0 +1,145 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct passprev {\n" +"float _placeholder39;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord2;\n" +"COMPAT_VARYING vec4 TEX2;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _oTex2;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _oTex2 = TexCoord2.xy/3.00000000E+00 + vec2( 1.50000006E-01, 1.50000006E-01);\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +" TEX2.xy = _oTex2;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count1;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct passprev {\n" +"float _placeholder37;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP0;\n" +"passprev _PASSPREV31;\n" +"uniform sampler2D bg;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _c0007;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform sampler2D PassPrev3Texture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _big;\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" _c0007 = TEX0.xy/3.00000000E+00 + (3.00000012E-01*InputSize)/TextureSize;\n" +" _big = COMPAT_TEXTURE(Texture, _c0007);\n" +" _frame = COMPAT_TEXTURE(PassPrev3Texture, TEX0.xy);\n" +" _TMP0 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _background = vec4(_TMP0.x, _TMP0.y, _TMP0.z, _TMP0.w);\n" +" _ret_0 = _frame + _background.w*(_big - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/bigblur-horiz.h b/src/video/sdl/shaders/hunterk/resources/bigblur-horiz.h new file mode 100644 index 000000000..9fc9da427 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/bigblur-horiz.h @@ -0,0 +1,203 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"float _TMP19;\n" +"float _TMP18;\n" +"float _TMP17;\n" +"float _TMP16;\n" +"vec4 _TMP15;\n" +"vec4 _TMP14;\n" +"vec4 _TMP13;\n" +"vec4 _TMP12;\n" +"vec4 _TMP11;\n" +"vec4 _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0025;\n" +"vec2 _c0037;\n" +"vec2 _c0049;\n" +"vec2 _c0061;\n" +"vec2 _c0073;\n" +"vec2 _c0085;\n" +"vec2 _c0097;\n" +"vec2 _c0109;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _big;\n" +" _big = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _c0025 = vec2(TEX0.x + 9.99999931E-04, TEX0.y);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _c0025);\n" +" _TMP16 = pow(_TMP0.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP0.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP0.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP0.w, 2.20000005E+00);\n" +" _TMP1 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP1;\n" +" _c0037 = vec2(TEX0.x - 9.99999931E-04, TEX0.y);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0037);\n" +" _TMP16 = pow(_TMP2.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP2.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP2.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP2.w, 2.20000005E+00);\n" +" _TMP3 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP3;\n" +" _c0049 = vec2(TEX0.x + 1.99999986E-03, TEX0.y);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, _c0049);\n" +" _TMP16 = pow(_TMP4.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP4.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP4.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP4.w, 2.20000005E+00);\n" +" _TMP5 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP5;\n" +" _c0061 = vec2(TEX0.x - 1.99999986E-03, TEX0.y);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, _c0061);\n" +" _TMP16 = pow(_TMP6.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP6.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP6.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP6.w, 2.20000005E+00);\n" +" _TMP7 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP7;\n" +" _c0073 = vec2(TEX0.x + 3.99999972E-03, TEX0.y);\n" +" _TMP8 = COMPAT_TEXTURE(Texture, _c0073);\n" +" _TMP16 = pow(_TMP8.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP8.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP8.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP8.w, 2.20000005E+00);\n" +" _TMP9 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP9;\n" +" _c0085 = vec2(TEX0.x - 3.99999972E-03, TEX0.y);\n" +" _TMP10 = COMPAT_TEXTURE(Texture, _c0085);\n" +" _TMP16 = pow(_TMP10.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP10.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP10.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP10.w, 2.20000005E+00);\n" +" _TMP11 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP11;\n" +" _c0097 = vec2(TEX0.x + 7.99999945E-03, TEX0.y);\n" +" _TMP12 = COMPAT_TEXTURE(Texture, _c0097);\n" +" _TMP16 = pow(_TMP12.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP12.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP12.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP12.w, 2.20000005E+00);\n" +" _TMP13 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP13;\n" +" _c0109 = vec2(TEX0.x - 7.99999945E-03, TEX0.y);\n" +" _TMP14 = COMPAT_TEXTURE(Texture, _c0109);\n" +" _TMP16 = pow(_TMP14.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP14.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP14.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP14.w, 2.20000005E+00);\n" +" _TMP15 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP15;\n" +" _big = _big/vec4( 9.00000000E+00, 9.00000000E+00, 9.00000000E+00, 9.00000000E+00);\n" +" _TMP16 = pow(_big.x, 4.54545438E-01);\n" +" _TMP17 = pow(_big.y, 4.54545438E-01);\n" +" _TMP18 = pow(_big.z, 4.54545438E-01);\n" +" _TMP19 = pow(_big.w, 4.54545438E-01);\n" +" _big = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" FragColor = _big;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/bigblur-vert.h b/src/video/sdl/shaders/hunterk/resources/bigblur-vert.h new file mode 100644 index 000000000..4f88f720c --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/bigblur-vert.h @@ -0,0 +1,203 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"float _TMP19;\n" +"float _TMP18;\n" +"float _TMP17;\n" +"float _TMP16;\n" +"vec4 _TMP15;\n" +"vec4 _TMP14;\n" +"vec4 _TMP13;\n" +"vec4 _TMP12;\n" +"vec4 _TMP11;\n" +"vec4 _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0025;\n" +"vec2 _c0037;\n" +"vec2 _c0049;\n" +"vec2 _c0061;\n" +"vec2 _c0073;\n" +"vec2 _c0085;\n" +"vec2 _c0097;\n" +"vec2 _c0109;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _big;\n" +" _big = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _c0025 = vec2(TEX0.x, TEX0.y + 9.99999931E-04);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _c0025);\n" +" _TMP16 = pow(_TMP0.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP0.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP0.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP0.w, 2.20000005E+00);\n" +" _TMP1 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP1;\n" +" _c0037 = vec2(TEX0.x, TEX0.y - 9.99999931E-04);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0037);\n" +" _TMP16 = pow(_TMP2.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP2.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP2.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP2.w, 2.20000005E+00);\n" +" _TMP3 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP3;\n" +" _c0049 = vec2(TEX0.x, TEX0.y + 1.99999986E-03);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, _c0049);\n" +" _TMP16 = pow(_TMP4.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP4.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP4.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP4.w, 2.20000005E+00);\n" +" _TMP5 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP5;\n" +" _c0061 = vec2(TEX0.x, TEX0.y - 1.99999986E-03);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, _c0061);\n" +" _TMP16 = pow(_TMP6.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP6.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP6.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP6.w, 2.20000005E+00);\n" +" _TMP7 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP7;\n" +" _c0073 = vec2(TEX0.x, TEX0.y + 3.99999972E-03);\n" +" _TMP8 = COMPAT_TEXTURE(Texture, _c0073);\n" +" _TMP16 = pow(_TMP8.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP8.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP8.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP8.w, 2.20000005E+00);\n" +" _TMP9 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP9;\n" +" _c0085 = vec2(TEX0.x, TEX0.y - 3.99999972E-03);\n" +" _TMP10 = COMPAT_TEXTURE(Texture, _c0085);\n" +" _TMP16 = pow(_TMP10.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP10.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP10.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP10.w, 2.20000005E+00);\n" +" _TMP11 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP11;\n" +" _c0097 = vec2(TEX0.x, TEX0.y + 7.99999945E-03);\n" +" _TMP12 = COMPAT_TEXTURE(Texture, _c0097);\n" +" _TMP16 = pow(_TMP12.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP12.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP12.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP12.w, 2.20000005E+00);\n" +" _TMP13 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP13;\n" +" _c0109 = vec2(TEX0.x, TEX0.y - 7.99999945E-03);\n" +" _TMP14 = COMPAT_TEXTURE(Texture, _c0109);\n" +" _TMP16 = pow(_TMP14.x, 2.20000005E+00);\n" +" _TMP17 = pow(_TMP14.y, 2.20000005E+00);\n" +" _TMP18 = pow(_TMP14.z, 2.20000005E+00);\n" +" _TMP19 = pow(_TMP14.w, 2.20000005E+00);\n" +" _TMP15 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" _big = _big + _TMP15;\n" +" _big = _big/vec4( 9.00000000E+00, 9.00000000E+00, 9.00000000E+00, 9.00000000E+00);\n" +" _TMP16 = pow(_big.x, 4.54545438E-01);\n" +" _TMP17 = pow(_big.y, 4.54545438E-01);\n" +" _TMP18 = pow(_big.z, 4.54545438E-01);\n" +" _TMP19 = pow(_big.w, 4.54545438E-01);\n" +" _big = vec4(_TMP16, _TMP17, _TMP18, _TMP19);\n" +" FragColor = _big;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/color-grid-1080p.h b/src/video/sdl/shaders/hunterk/resources/color-grid-1080p.h new file mode 100644 index 000000000..d09f41592 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/color-grid-1080p.h @@ -0,0 +1,178 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count1;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP6;\n" +"vec2 _TMP5;\n" +"vec2 _TMP12;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"vec3 _TMP4;\n" +"float _TMP9;\n" +"float _TMP8;\n" +"float _TMP7;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"vec2 _TMP0;\n" +"uniform sampler2D Texture;\n" +"uniform sampler2D bg;\n" +"input_dummy _IN1;\n" +"vec2 _x0019;\n" +"float _a0025;\n" +"vec3 _x0027;\n" +"vec2 _x0035;\n" +"vec2 _x0041;\n" +"vec2 _x0043;\n" +"vec2 _TMP44;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _px;\n" +" float _id;\n" +" vec3 _co;\n" +" vec2 _pa;\n" +" vec4 _colorgrid;\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" vec3 _TMP17;\n" +" _px = (1.00000000E+03*(-TextureSize.xy + 8.00000000E+00*(TEX0.xy*(TextureSize.xy/InputSize.xy)).xy))/TextureSize.y;\n" +" _x0019 = _px + 5.00000000E-01;\n" +" _TMP0 = floor(_x0019);\n" +" _TMP1 = dot(_TMP0, vec2( 1.13099998E+02, 1.78099995E+01));\n" +" _TMP2 = sin(_TMP1);\n" +" _a0025 = float(FrameCount)*9.99999978E-03*4.00000000E+00 + _TMP2*4.37585469E+04;\n" +" _TMP3 = cos(_a0025);\n" +" _id = 5.00000000E-01 + 5.00000000E-01*_TMP3;\n" +" _x0027 = (float(FrameCount)*9.99999978E-03 + 3.50000000E+00*_id) + vec3( 0.00000000E+00, 1.57000005E+00, 3.14000010E+00);\n" +" _TMP7 = cos(_x0027.x);\n" +" _TMP8 = cos(_x0027.y);\n" +" _TMP9 = cos(_x0027.z);\n" +" _TMP4 = vec3(_TMP7, _TMP8, _TMP9);\n" +" _co = 5.00000000E-01 + 5.00000000E-01*_TMP4;\n" +" _x0035 = 6.28310013E+00*_px;\n" +" _TMP10 = cos(_x0035.x);\n" +" _TMP11 = cos(_x0035.y);\n" +" _TMP5 = vec2(_TMP10, _TMP11);\n" +" _x0041 = _id*(5.00000000E-01 + 5.00000000E-01*_TMP5);\n" +" _x0043 = _x0041/vec2( 2.00000003E-01, 2.00000003E-01);\n" +" _TMP12 = min(vec2( 1.00000000E+00, 1.00000000E+00), _x0043);\n" +" _TMP44 = max(vec2( 0.00000000E+00, 0.00000000E+00), _TMP12);\n" +" _pa = _TMP44*_TMP44*(vec2( 3.00000000E+00, 3.00000000E+00) - 2.00000000E+00*_TMP44);\n" +" _TMP17 = _co*_pa.x*_pa.y;\n" +" _colorgrid = vec4(_TMP17.x, _TMP17.y, _TMP17.z, 1.00000000E+00);\n" +" _frame = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP6 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _background = vec4(_TMP6.x, _TMP6.y, _TMP6.z, _TMP6.w);\n" +" _ret_0 = _frame + _background.w*(_colorgrid - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/mudlord-1080p.h b/src/video/sdl/shaders/hunterk/resources/mudlord-1080p.h new file mode 100644 index 000000000..66b6fb094 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/mudlord-1080p.h @@ -0,0 +1,175 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count1;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP8;\n" +"float _TMP7;\n" +"float _TMP9;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"float _TMP0;\n" +"uniform sampler2D Texture;\n" +"uniform sampler2D bg;\n" +"input_dummy _IN1;\n" +"float _a0016;\n" +"float _a0018;\n" +"float _a0020;\n" +"float _a0022;\n" +"float _a0024;\n" +"float _a0026;\n" +"vec2 _a0028;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _sp;\n" +" vec2 _p;\n" +" vec2 _i;\n" +" float _c;\n" +" float _t;\n" +" vec4 _mudscape;\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" vec3 _TMP14;\n" +" _sp = TEX0.xy*(TextureSize.xy/InputSize.xy);\n" +" _p = _sp*1.00000000E+01 - vec2( 1.00000000E+01, 1.00000000E+01);\n" +" _t = 9.99999940E-02*float(FrameCount)*-2.00000000E+00;\n" +" _a0016 = _t - _p.x;\n" +" _TMP0 = cos(_a0016);\n" +" _a0018 = _t + _p.y;\n" +" _TMP1 = sin(_a0018);\n" +" _a0020 = _t - _p.y;\n" +" _TMP2 = sin(_a0020);\n" +" _a0022 = _t + _p.x;\n" +" _TMP3 = cos(_a0022);\n" +" _i = _p + vec2(_TMP0 + _TMP1, _TMP2 + _TMP3);\n" +" _a0024 = _i.x + _t;\n" +" _TMP4 = sin(_a0024);\n" +" _a0026 = _i.y + _t;\n" +" _TMP5 = cos(_a0026);\n" +" _a0028 = vec2(_p.x/(_TMP4/1.00000001E-01), _p.y/(_TMP5/1.00000001E-01));\n" +" _TMP6 = length(_a0028);\n" +" _c = 1.00000000E+00 + 1.20000005E+00/_TMP6;\n" +" _TMP9 = inversesqrt(_c);\n" +" _TMP7 = 1.00000000E+00/_TMP9;\n" +" _c = 2.00000000E+00 - _TMP7;\n" +" _TMP14 = vec3(_c*_c*_c*_c, _c*_c*_c*_c, _c*_c*_c*_c);\n" +" _mudscape = vec4(_TMP14.x, _TMP14.y, _TMP14.z, 9.99900000E+03) + vec4( 0.00000000E+00, 3.00000012E-01, 5.00000000E-01, 1.00000000E+00);\n" +" _frame = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP8 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _background = vec4(_TMP8.x, _TMP8.y, _TMP8.z, _TMP8.w);\n" +" _ret_0 = _frame + _background.w*(_mudscape - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/shiny-iterations-1080p.h b/src/video/sdl/shaders/hunterk/resources/shiny-iterations-1080p.h new file mode 100644 index 000000000..7c20bba74 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/shiny-iterations-1080p.h @@ -0,0 +1,419 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0008;\n" +" _oColor = COLOR;\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0008;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP25;\n" +"float _TMP24;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"float _TMP30;\n" +"float _TMP29;\n" +"float _TMP28;\n" +"float _TMP21;\n" +"float _TMP20;\n" +"float _TMP19;\n" +"float _TMP18;\n" +"float _TMP35;\n" +"float _TMP34;\n" +"float _TMP31;\n" +"float _TMP33;\n" +"float _TMP32;\n" +"vec2 _TMP16;\n" +"vec2 _TMP15;\n" +"float _TMP27;\n" +"float _TMP26;\n" +"vec2 _TMP14;\n" +"float _TMP13;\n" +"vec2 _TMP11;\n" +"vec2 _TMP10;\n" +"vec2 _TMP9;\n" +"float _TMP8;\n" +"vec2 _TMP6;\n" +"vec2 _TMP5;\n" +"vec2 _TMP4;\n" +"float _TMP3;\n" +"uniform sampler2D Texture;\n" +"uniform sampler2D bg;\n" +"input_dummy _IN1;\n" +"vec2 _x0046;\n" +"vec2 _x0052;\n" +"vec2 _x0058;\n" +"vec2 _a0064;\n" +"vec2 _b0064;\n" +"float _y0066;\n" +"float _x0066;\n" +"float _t30068;\n" +"float _t10068;\n" +"float _t00068;\n" +"float _t40068;\n" +"vec2 _x0084;\n" +"vec2 _x0090;\n" +"vec2 _x0096;\n" +"vec2 _a0102;\n" +"vec2 _b0102;\n" +"float _y0104;\n" +"float _x0104;\n" +"float _t30106;\n" +"float _t10106;\n" +"float _t00106;\n" +"float _t40106;\n" +"vec2 _x0122;\n" +"vec2 _x0128;\n" +"vec2 _x0134;\n" +"vec2 _a0140;\n" +"vec2 _b0140;\n" +"float _y0142;\n" +"float _x0142;\n" +"float _t30144;\n" +"float _t10144;\n" +"float _t00144;\n" +"float _t40144;\n" +"vec3 _TMP159;\n" +"float _a0164;\n" +"float _x0168;\n" +"float _TMP169;\n" +"vec3 _TMP175;\n" +"vec3 _v0182;\n" +"float _TMP189;\n" +"float _x0190;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _pc;\n" +" vec2 _pa;\n" +" vec2 _pb;\n" +" vec2 _zc;\n" +" vec3 _fc;\n" +" int _i1;\n" +" float _d1;\n" +" vec2 _za;\n" +" vec3 _fa;\n" +" int _i2;\n" +" float _d2;\n" +" vec2 _zb;\n" +" vec3 _fb;\n" +" int _i3;\n" +" float _d3;\n" +" vec3 _col;\n" +" vec3 _nor;\n" +" vec4 _effect;\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" _TMP3 = min(TextureSize.y, TextureSize.x);\n" +" _pc = (2.00000000E+03*(TEX0.xy*(TextureSize.xy/InputSize.xy)).xy - TextureSize.xy)/_TMP3;\n" +" _pa = _pc + vec2( 3.99999991E-02, 0.00000000E+00);\n" +" _pb = _pc + vec2( 0.00000000E+00, 3.99999991E-02);\n" +" _zc = _pc;\n" +" _fc = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _i1 = 0;\n" +" for (; _i1 < 8; _i1 = _i1 + 1) { \n" +" _x0046 = _zc.yx + float(FrameCount)*9.99999978E-03*5.00000000E+00;\n" +" _TMP26 = cos(_x0046.x);\n" +" _TMP27 = cos(_x0046.y);\n" +" _TMP4 = vec2(_TMP26, _TMP27);\n" +" _x0052 = _zc.yx + _TMP4;\n" +" _TMP26 = cos(_x0052.x);\n" +" _TMP27 = cos(_x0052.y);\n" +" _TMP5 = vec2(_TMP26, _TMP27);\n" +" _x0058 = _zc.yx + _TMP5;\n" +" _TMP26 = cos(_x0058.x);\n" +" _TMP27 = cos(_x0058.y);\n" +" _TMP6 = vec2(_TMP26, _TMP27);\n" +" _zc = _zc + _TMP6;\n" +" _a0064 = _zc - _pc;\n" +" _b0064 = _zc - _pc;\n" +" _d1 = dot(_a0064, _b0064);\n" +" _fc.x = _fc.x + 1.00000000E+00/(1.00000000E+00 + _d1);\n" +" _fc.y = _fc.y + _d1;\n" +" _y0066 = _zc.y - _pc.y;\n" +" _x0066 = _zc.x - _pc.x;\n" +" _t30068 = abs(_x0066);\n" +" _t10068 = abs(_y0066);\n" +" _t00068 = max(_t30068, _t10068);\n" +" _t10068 = min(_t30068, _t10068);\n" +" _t30068 = 1.00000000E+00/_t00068;\n" +" _t30068 = _t10068*_t30068;\n" +" _t40068 = _t30068*_t30068;\n" +" _t00068 = -1.34804696E-02*_t40068 + 5.74773103E-02;\n" +" _t00068 = _t00068*_t40068 - 1.21239103E-01;\n" +" _t00068 = _t00068*_t40068 + 1.95635900E-01;\n" +" _t00068 = _t00068*_t40068 - 3.32994610E-01;\n" +" _t00068 = _t00068*_t40068 + 9.99995589E-01;\n" +" _t30068 = _t00068*_t30068;\n" +" _TMP32 = abs(_y0066);\n" +" _TMP33 = abs(_x0066);\n" +" if (_TMP32 > _TMP33) { \n" +" _TMP31 = 1.57079601E+00 - _t30068;\n" +" } else {\n" +" _TMP31 = _t30068;\n" +" } \n" +" if (_x0066 < 0.00000000E+00) { \n" +" _TMP34 = 3.14159298E+00 - _TMP31;\n" +" } else {\n" +" _TMP34 = _TMP31;\n" +" } \n" +" if (_y0066 < 0.00000000E+00) { \n" +" _TMP35 = -_TMP34;\n" +" } else {\n" +" _TMP35 = _TMP34;\n" +" } \n" +" _TMP8 = sin(_TMP35);\n" +" _fc.z = _fc.z + _TMP8;\n" +" } \n" +" _fc = _fc/8.00000000E+00;\n" +" _za = _pa;\n" +" _fa = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _i2 = 0;\n" +" for (; _i2 < 8; _i2 = _i2 + 1) { \n" +" _x0084 = _za.yx + float(FrameCount)*9.99999978E-03*5.00000000E+00;\n" +" _TMP26 = cos(_x0084.x);\n" +" _TMP27 = cos(_x0084.y);\n" +" _TMP9 = vec2(_TMP26, _TMP27);\n" +" _x0090 = _za.yx + _TMP9;\n" +" _TMP26 = cos(_x0090.x);\n" +" _TMP27 = cos(_x0090.y);\n" +" _TMP10 = vec2(_TMP26, _TMP27);\n" +" _x0096 = _za.yx + _TMP10;\n" +" _TMP26 = cos(_x0096.x);\n" +" _TMP27 = cos(_x0096.y);\n" +" _TMP11 = vec2(_TMP26, _TMP27);\n" +" _za = _za + _TMP11;\n" +" _a0102 = _za - _pa;\n" +" _b0102 = _za - _pa;\n" +" _d2 = dot(_a0102, _b0102);\n" +" _fa.x = _fa.x + 1.00000000E+00/(1.00000000E+00 + _d2);\n" +" _fa.y = _fa.y + _d2;\n" +" _y0104 = _za.y - _pa.y;\n" +" _x0104 = _za.x - _pa.x;\n" +" _t30106 = abs(_x0104);\n" +" _t10106 = abs(_y0104);\n" +" _t00106 = max(_t30106, _t10106);\n" +" _t10106 = min(_t30106, _t10106);\n" +" _t30106 = 1.00000000E+00/_t00106;\n" +" _t30106 = _t10106*_t30106;\n" +" _t40106 = _t30106*_t30106;\n" +" _t00106 = -1.34804696E-02*_t40106 + 5.74773103E-02;\n" +" _t00106 = _t00106*_t40106 - 1.21239103E-01;\n" +" _t00106 = _t00106*_t40106 + 1.95635900E-01;\n" +" _t00106 = _t00106*_t40106 - 3.32994610E-01;\n" +" _t00106 = _t00106*_t40106 + 9.99995589E-01;\n" +" _t30106 = _t00106*_t30106;\n" +" _TMP32 = abs(_y0104);\n" +" _TMP33 = abs(_x0104);\n" +" if (_TMP32 > _TMP33) { \n" +" _TMP31 = 1.57079601E+00 - _t30106;\n" +" } else {\n" +" _TMP31 = _t30106;\n" +" } \n" +" if (_x0104 < 0.00000000E+00) { \n" +" _TMP34 = 3.14159298E+00 - _TMP31;\n" +" } else {\n" +" _TMP34 = _TMP31;\n" +" } \n" +" if (_y0104 < 0.00000000E+00) { \n" +" _TMP35 = -_TMP34;\n" +" } else {\n" +" _TMP35 = _TMP34;\n" +" } \n" +" _TMP13 = sin(_TMP35);\n" +" _fa.z = _fa.z + _TMP13;\n" +" } \n" +" _fa = _fa/8.00000000E+00;\n" +" _zb = _pb;\n" +" _fb = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _i3 = 0;\n" +" for (; _i3 < 8; _i3 = _i3 + 1) { \n" +" _x0122 = _zb.yx + float(FrameCount)*9.99999978E-03*5.00000000E+00;\n" +" _TMP26 = cos(_x0122.x);\n" +" _TMP27 = cos(_x0122.y);\n" +" _TMP14 = vec2(_TMP26, _TMP27);\n" +" _x0128 = _zb.yx + _TMP14;\n" +" _TMP26 = cos(_x0128.x);\n" +" _TMP27 = cos(_x0128.y);\n" +" _TMP15 = vec2(_TMP26, _TMP27);\n" +" _x0134 = _zb.yx + _TMP15;\n" +" _TMP26 = cos(_x0134.x);\n" +" _TMP27 = cos(_x0134.y);\n" +" _TMP16 = vec2(_TMP26, _TMP27);\n" +" _zb = _zb + _TMP16;\n" +" _a0140 = _zb - _pb;\n" +" _b0140 = _zb - _pb;\n" +" _d3 = dot(_a0140, _b0140);\n" +" _fb.x = _fb.x + 1.00000000E+00/(1.00000000E+00 + _d3);\n" +" _fb.y = _fb.y + _d3;\n" +" _y0142 = _zb.y - _pb.y;\n" +" _x0142 = _zb.x - _pb.x;\n" +" _t30144 = abs(_x0142);\n" +" _t10144 = abs(_y0142);\n" +" _t00144 = max(_t30144, _t10144);\n" +" _t10144 = min(_t30144, _t10144);\n" +" _t30144 = 1.00000000E+00/_t00144;\n" +" _t30144 = _t10144*_t30144;\n" +" _t40144 = _t30144*_t30144;\n" +" _t00144 = -1.34804696E-02*_t40144 + 5.74773103E-02;\n" +" _t00144 = _t00144*_t40144 - 1.21239103E-01;\n" +" _t00144 = _t00144*_t40144 + 1.95635900E-01;\n" +" _t00144 = _t00144*_t40144 - 3.32994610E-01;\n" +" _t00144 = _t00144*_t40144 + 9.99995589E-01;\n" +" _t30144 = _t00144*_t30144;\n" +" _TMP32 = abs(_y0142);\n" +" _TMP33 = abs(_x0142);\n" +" if (_TMP32 > _TMP33) { \n" +" _TMP31 = 1.57079601E+00 - _t30144;\n" +" } else {\n" +" _TMP31 = _t30144;\n" +" } \n" +" if (_x0142 < 0.00000000E+00) { \n" +" _TMP34 = 3.14159298E+00 - _TMP31;\n" +" } else {\n" +" _TMP34 = _TMP31;\n" +" } \n" +" if (_y0142 < 0.00000000E+00) { \n" +" _TMP35 = -_TMP34;\n" +" } else {\n" +" _TMP35 = _TMP34;\n" +" } \n" +" _TMP18 = sin(_TMP35);\n" +" _fb.z = _fb.z + _TMP18;\n" +" } \n" +" _fb = _fb/8.00000000E+00;\n" +" _TMP159 = vec3( 7.99999982E-02, 1.99999996E-02, 1.50000006E-01) + _fc.x*vec3( 5.20000041E-01, 1.08000004E+00, 1.45000005E+00);\n" +" _a0164 = 9.99999978E-03*float(FrameCount)*5.00000000E+00;\n" +" _TMP19 = cos(_a0164);\n" +" _x0168 = _TMP19 - -5.00000000E-01;\n" +" _TMP30 = min(1.00000000E+00, _x0168);\n" +" _TMP169 = max(0.00000000E+00, _TMP30);\n" +" _TMP20 = _TMP169*_TMP169*(3.00000000E+00 - 2.00000000E+00*_TMP169);\n" +" _TMP175 = _TMP159 + _TMP20*(_TMP159.zxy - _TMP159);\n" +" _col = _TMP175*(1.50000006E-01*_fc.y);\n" +" _TMP21 = abs(_fc.z);\n" +" _col = _col + (4.00000006E-01*_TMP21 - 1.00000001E-01);\n" +" _v0182 = vec3(_fa.x - _fc.x, 9.99999978E-03, _fb.x - _fc.x);\n" +" _TMP28 = dot(_v0182, _v0182);\n" +" _TMP29 = inversesqrt(_TMP28);\n" +" _nor = _TMP29*_v0182;\n" +" _TMP22 = dot(_nor, vec3( 5.77300012E-01, 5.77300012E-01, 5.77300012E-01));\n" +" _x0190 = 5.00000000E-01 + 5.00000000E-01*_TMP22;\n" +" _TMP30 = min(1.00000000E+00, _x0190);\n" +" _TMP189 = max(0.00000000E+00, _TMP30);\n" +" _col = _col*(1.00000000E+00 + (6.99999988E-01*_TMP189)*_col);\n" +" _TMP23 = pow(_nor.y, 1.28000000E+02);\n" +" _col = _col + 3.00000012E-01*_TMP23;\n" +" _TMP24 = length(_pc);\n" +" _col = _col*(1.00000000E+00 - 1.00000001E-01*_TMP24);\n" +" _effect = vec4(_col.x, _col.y, _col.z, 1.00000000E+00);\n" +" _frame = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP25 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _background = vec4(_TMP25.x, _TMP25.y, _TMP25.z, _TMP25.w);\n" +" _ret_0 = _frame + _background.w*(_effect - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/snow-1080p.h b/src/video/sdl/shaders/hunterk/resources/snow-1080p.h new file mode 100644 index 000000000..7b944b1d7 --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/snow-1080p.h @@ -0,0 +1,223 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0008;\n" +" _oColor = COLOR;\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0008;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP16;\n" +"float _TMP15;\n" +"float _TMP19;\n" +"float _TMP14;\n" +"float _TMP13;\n" +"float _TMP12;\n" +"float _TMP11;\n" +"vec2 _TMP10;\n" +"vec2 _TMP9;\n" +"vec2 _TMP18;\n" +"vec3 _TMP7;\n" +"vec3 _TMP5;\n" +"vec3 _TMP4;\n" +"vec2 _TMP3;\n" +"float _TMP2;\n" +"float _TMP17;\n" +"float _TMP1;\n" +"uniform sampler2D Texture;\n" +"uniform sampler2D bg;\n" +"input_dummy _IN1;\n" +"float _a0030;\n" +"float _x0032;\n" +"vec3 _r0042;\n" +"vec2 _TMP53;\n" +"vec2 _a0060;\n" +"vec2 _x0062;\n" +"vec2 _a0064;\n" +"float _a0066;\n" +"float _b0066;\n" +"float _a0070;\n" +"float _a0072;\n" +"float _b0074;\n" +"float _x0076;\n" +"float _TMP77;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _uv;\n" +" vec3 _acc;\n" +" float _dof;\n" +" int _i1;\n" +" float _fi1;\n" +" vec2 _q1;\n" +" vec3 _n1;\n" +" vec3 _m1;\n" +" vec3 _mp1;\n" +" vec3 _r1;\n" +" vec2 _s1;\n" +" float _d1;\n" +" float _edge1;\n" +" vec4 _snowscape;\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" _uv = TEX0.xy*(TextureSize.xy/InputSize.xy);\n" +" _acc = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _a0030 = float(FrameCount)*1.00000001E-01;\n" +" _TMP1 = sin(_a0030);\n" +" _dof = 5.00000000E+00*_TMP1;\n" +" _i1 = 0;\n" +" for (; float(_i1) < 1.50000000E+01; _i1 = _i1 + 1) { \n" +" _fi1 = float(_i1);\n" +" _q1 = _uv*(1.00000000E+00 + _fi1);\n" +" _x0032 = _fi1*7.23891687E+00;\n" +" _TMP17 = floor(_x0032);\n" +" _TMP2 = _x0032 - _TMP17;\n" +" _q1 = _q1 + vec2(_q1.y*(7.50000000E-01*_TMP2 - 3.75000000E-01), (-2.99999993E-02*float(FrameCount))/(1.00000000E+00 + _fi1*2.99999993E-02));\n" +" _TMP3 = floor(_q1);\n" +" _n1 = vec3(_TMP3.x, _TMP3.y, 3.11889992E+01 + _fi1);\n" +" _TMP4 = floor(_n1);\n" +" _TMP5 = fract(_n1);\n" +" _m1 = _TMP4*9.99999975E-06 + _TMP5;\n" +" _r0042.x = dot(vec3( 1.33231220E+01, 2.11212006E+01, 2.18111992E+01), _m1);\n" +" _r0042.y = dot(vec3( 2.35112000E+01, 2.87311993E+01, 1.47212000E+01), _m1);\n" +" _r0042.z = dot(vec3( 2.17112293E+01, 1.19312000E+01, 6.13933983E+01), _m1);\n" +" _TMP7 = fract(_r0042);\n" +" _mp1 = (3.14159004E+04 + _m1)/_TMP7;\n" +" _r1 = fract(_mp1);\n" +" _TMP18 = floor(_q1);\n" +" _TMP53 = _q1 - _TMP18;\n" +" _a0060 = ((_TMP53 - 5.00000000E-01) + 8.99999976E-01*_r1.xy) - 4.49999988E-01;\n" +" _s1 = abs(_a0060);\n" +" _x0062 = 1.00000000E+01*_q1.yx;\n" +" _TMP9 = fract(_x0062);\n" +" _a0064 = 2.00000000E+00*_TMP9 - 1.00000000E+00;\n" +" _TMP10 = abs(_a0064);\n" +" _s1 = _s1 + 9.99999978E-03*_TMP10;\n" +" _a0066 = _s1.x - _s1.y;\n" +" _b0066 = _s1.x + _s1.y;\n" +" _TMP11 = max(_a0066, _b0066);\n" +" _TMP12 = max(_s1.x, _s1.y);\n" +" _d1 = (6.00000024E-01*_TMP11 + _TMP12) - 9.99999978E-03;\n" +" _a0070 = (_fi1 - 5.00000000E+00) - _dof;\n" +" _TMP13 = abs(_a0070);\n" +" _a0072 = 5.00000000E-01*_TMP13;\n" +" _TMP14 = min(_a0072, 1.00000000E+00);\n" +" _edge1 = 5.00000007E-02 + 5.00000007E-02*_TMP14;\n" +" _b0074 = -_edge1;\n" +" _x0076 = (_d1 - _edge1)/(_b0074 - _edge1);\n" +" _TMP19 = min(1.00000000E+00, _x0076);\n" +" _TMP77 = max(0.00000000E+00, _TMP19);\n" +" _TMP15 = _TMP77*_TMP77*(3.00000000E+00 - 2.00000000E+00*_TMP77);\n" +" _acc = _acc + vec3(_TMP15*(_r1.x/(1.00000000E+00 + 1.99999996E-02*_fi1)), _TMP15*(_r1.x/(1.00000000E+00 + 1.99999996E-02*_fi1)), _TMP15*(_r1.x/(1.00000000E+00 + 1.99999996E-02*_fi1)));\n" +" } \n" +" _snowscape = vec4(_acc.x, _acc.y, _acc.z, 1.00000000E+00);\n" +" _frame = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP16 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _background = vec4(_TMP16.x, _TMP16.y, _TMP16.z, _TMP16.w);\n" +" _ret_0 = _frame + _background.w*(_snowscape - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/voronoi-1080p.h b/src/video/sdl/shaders/hunterk/resources/voronoi-1080p.h new file mode 100644 index 000000000..7a2a3643a --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/voronoi-1080p.h @@ -0,0 +1,254 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0008;\n" +" _oColor = COLOR;\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0008;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP12;\n" +"float _TMP11;\n" +"float _TMP10;\n" +"float _TMP28;\n" +"float _TMP9;\n" +"float _TMP8;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"vec3 _TMP16;\n" +"float _TMP27;\n" +"float _TMP26;\n" +"float _TMP25;\n" +"float _TMP14;\n" +"float _TMP24;\n" +"vec2 _TMP13;\n" +"float _TMP23;\n" +"float _TMP22;\n" +"vec2 _TMP21;\n" +"float _TMP20;\n" +"float _TMP19;\n" +"float _TMP4;\n" +"uniform sampler2D Texture;\n" +"uniform sampler2D bg;\n" +"input_dummy _IN1;\n" +"float _a0041;\n" +"vec2 _n0043;\n" +"vec2 _x0043;\n" +"vec2 _f0043;\n" +"vec4 _m0043;\n" +"int _j10043;\n" +"int _i10043;\n" +"vec2 _g10043;\n" +"vec2 _o10043;\n" +"float _d10043;\n" +"vec3 _col10043;\n" +"float _h10043;\n" +"vec2 _TMP48;\n" +"vec2 _p0049;\n" +"vec2 _x0061;\n" +"vec2 _x0063;\n" +"vec2 _a0069;\n" +"vec2 _a0071;\n" +"float _TMP72;\n" +"float _x0077;\n" +"vec3 _x0079;\n" +"float _x0087;\n" +"float _TMP90;\n" +"float _TMP96;\n" +"vec3 _TMP100;\n" +"float _TMP108;\n" +"float _a0113;\n" +"float _x0117;\n" +"float _TMP118;\n" +"float _a0125;\n" +"float _x0129;\n" +"float _TMP130;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _p1;\n" +" float _k;\n" +" vec3 _col;\n" +" vec4 _hexscape;\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" _p1 = (5.00000000E+02*(TEX0.xy*(TextureSize.xy/InputSize.xy)))/TextureSize.yy;\n" +" _a0041 = 4.71232496E-02*float(FrameCount);\n" +" _TMP4 = cos(_a0041);\n" +" _k = 5.00000000E-01 - 5.00000000E-01*_TMP4;\n" +" _x0043 = 6.00000000E+00*_p1;\n" +" _n0043 = floor(_x0043);\n" +" _f0043 = fract(_x0043);\n" +" _m0043 = vec4( 8.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" _j10043 = -1;\n" +" for (; _j10043 <= 1; _j10043 = _j10043 + 1) { \n" +" _i10043 = -1;\n" +" for (; _i10043 <= 1; _i10043 = _i10043 + 1) { \n" +" _g10043 = vec2(float(_i10043), float(_j10043));\n" +" _p0049 = _n0043 + _g10043;\n" +" _TMP19 = dot(_p0049, vec2( 1.27099998E+02, 3.11700012E+02));\n" +" _TMP20 = dot(_p0049, vec2( 2.69500000E+02, 1.83300003E+02));\n" +" _p0049 = vec2(_TMP19, _TMP20);\n" +" _TMP22 = sin(_p0049.x);\n" +" _TMP23 = sin(_p0049.y);\n" +" _TMP21 = vec2(_TMP22, _TMP23);\n" +" _x0061 = _TMP21*4.37585469E+04;\n" +" _TMP48 = fract(_x0061);\n" +" _x0063 = 9.99999978E-03*float(FrameCount) + 6.28310013E+00*_TMP48;\n" +" _TMP22 = sin(_x0063.x);\n" +" _TMP23 = sin(_x0063.y);\n" +" _TMP13 = vec2(_TMP22, _TMP23);\n" +" _o10043 = 5.00000000E-01 + 5.00000000E-01*_TMP13;\n" +" _a0069 = (_g10043 - _f0043) + _o10043;\n" +" _d10043 = length(_a0069);\n" +" _a0071 = _n0043 + _g10043;\n" +" _TMP14 = dot(_a0071, vec2( 7.00000000E+00, 1.13000000E+02));\n" +" _TMP24 = sin(_TMP14);\n" +" _x0077 = _TMP24*4.37585469E+04;\n" +" _TMP72 = fract(_x0077);\n" +" _x0079 = (_TMP72*2.50000000E+00 + 3.50000000E+00) + vec3( 2.00000000E+00, 3.00000000E+00, 0.00000000E+00);\n" +" _TMP25 = sin(_x0079.x);\n" +" _TMP26 = sin(_x0079.y);\n" +" _TMP27 = sin(_x0079.z);\n" +" _TMP16 = vec3(_TMP25, _TMP26, _TMP27);\n" +" _col10043 = 5.00000000E-01 + 5.00000000E-01*_TMP16;\n" +" _x0087 = 5.00000000E-01 + (5.00000000E-01*(_m0043.x - _d10043))/_k;\n" +" _TMP28 = min(1.00000000E+00, _x0087);\n" +" _TMP90 = max(0.00000000E+00, _TMP28);\n" +" _h10043 = _TMP90*_TMP90*(3.00000000E+00 - 2.00000000E+00*_TMP90);\n" +" _TMP96 = _m0043.x + _h10043*(_d10043 - _m0043.x);\n" +" _m0043.x = _TMP96 - (_h10043*(1.00000000E+00 - _h10043)*_k)/(1.00000000E+00 + 3.00000000E+00*_k);\n" +" _TMP100 = _m0043.yzw + _h10043*(_col10043 - _m0043.yzw);\n" +" _m0043.yzw = _TMP100 - (_h10043*(1.00000000E+00 - _h10043)*_k)/(1.00000000E+00 + 3.00000000E+00*_k);\n" +" } \n" +" } \n" +" _TMP5 = float((3.30000013E-01 >= _p1.y));\n" +" _col = _m0043.yzw*(1.00000000E+00 - 8.00000012E-01*_m0043.x*_TMP5);\n" +" _TMP6 = float((6.60000026E-01 >= _p1.y));\n" +" _TMP108 = _m0043.x + _TMP6*(1.00000000E+00 - _m0043.x);\n" +" _col = _col*_TMP108;\n" +" _a0113 = _p1.y - 3.30000013E-01;\n" +" _TMP8 = abs(_a0113);\n" +" _x0117 = (_TMP8 - 4.99999989E-03)/2.00000033E-03;\n" +" _TMP28 = min(1.00000000E+00, _x0117);\n" +" _TMP118 = max(0.00000000E+00, _TMP28);\n" +" _TMP9 = _TMP118*_TMP118*(3.00000000E+00 - 2.00000000E+00*_TMP118);\n" +" _col = _col*_TMP9;\n" +" _a0125 = _p1.y - 6.60000026E-01;\n" +" _TMP10 = abs(_a0125);\n" +" _x0129 = (_TMP10 - 4.99999989E-03)/2.00000033E-03;\n" +" _TMP28 = min(1.00000000E+00, _x0129);\n" +" _TMP130 = max(0.00000000E+00, _TMP28);\n" +" _TMP11 = _TMP130*_TMP130*(3.00000000E+00 - 2.00000000E+00*_TMP130);\n" +" _col = _col*_TMP11;\n" +" _hexscape = vec4(_col.x, _col.y, _col.z, 1.00000000E+00);\n" +" _frame = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP12 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _background = vec4(_TMP12.x, _TMP12.y, _TMP12.z, _TMP12.w);\n" +" _ret_0 = _frame + _background.w*(_hexscape - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/hunterk/resources/water-1080p.h b/src/video/sdl/shaders/hunterk/resources/water-1080p.h new file mode 100644 index 000000000..763677cce --- /dev/null +++ b/src/video/sdl/shaders/hunterk/resources/water-1080p.h @@ -0,0 +1,210 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying \n" +"#define COMPAT_ATTRIBUTE attribute \n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0013;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_ATTRIBUTE vec4 LUTTexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" vec2 _otex_border;\n" +" vec2 _scale;\n" +" vec2 _middle;\n" +" vec2 _diff;\n" +" vec2 _dist;\n" +" _r0013 = VertexCoord.x*MVPMatrix[0];\n" +" _r0013 = _r0013 + VertexCoord.y*MVPMatrix[1];\n" +" _r0013 = _r0013 + VertexCoord.z*MVPMatrix[2];\n" +" _r0013 = _r0013 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0013;\n" +" _oColor = COLOR;\n" +" _scale = (OutputSize/vec2( 3.20000000E+02, 2.40000000E+02))/4.00000000E+00;\n" +" _middle = (5.00000000E-01*InputSize)/TextureSize;\n" +" _diff = TexCoord.xy - _middle;\n" +" _oTex = _middle + _diff*_scale;\n" +" _dist = LUTTexCoord.xy - vec2( 4.99989986E-01, 4.99989986E-01);\n" +" _otex_border = vec2( 4.99989986E-01, 4.99989986E-01) + (_dist*OutputSize)/vec2( 1.92000000E+03, 1.08000000E+03);\n" +" gl_Position = _r0013;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _oTex;\n" +" TEX1.xy = _otex_border;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count1;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP0;\n" +"float _TMP8;\n" +"float _TMP7;\n" +"float _TMP9;\n" +"uniform sampler2D Texture;\n" +"uniform sampler2D bg;\n" +"input_dummy _IN1;\n" +"float _res0026;\n" +"vec3 _TMP200026;\n" +"float _TMP27;\n" +"vec2 _diff0028;\n" +"float _dist0028;\n" +"float _TMP37;\n" +"vec2 _diff0038;\n" +"float _dist0038;\n" +"float _TMP47;\n" +"vec2 _diff0048;\n" +"float _dist0048;\n" +"float _TMP57;\n" +"vec2 _diff0058;\n" +"float _dist0058;\n" +"float _TMP67;\n" +"vec2 _diff0068;\n" +"float _dist0068;\n" +"float _TMP77;\n" +"vec2 _diff0078;\n" +"float _dist0078;\n" +"float _TMP87;\n" +"vec2 _diff0088;\n" +"float _dist0088;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _frame;\n" +" vec4 _background;\n" +" _frame = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP0 = COMPAT_TEXTURE(bg, TEX1.xy);\n" +" _diff0028 = TEX1.xy - vec2( 6.00000024E-01, 6.99999988E-01);\n" +" _TMP7 = dot(_diff0028, _diff0028);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0028 = 3.00000000E+02*_TMP8;\n" +" _dist0028 = _dist0028 - 1.50000006E-01*float(FrameCount);\n" +" _TMP27 = sin(_dist0028);\n" +" _diff0038 = TEX1.xy - vec2( 8.99999976E-01, 8.99999976E-01);\n" +" _TMP7 = dot(_diff0038, _diff0038);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0038 = 3.00000000E+02*_TMP8;\n" +" _dist0038 = _dist0038 - 1.50000006E-01*float(FrameCount);\n" +" _TMP37 = sin(_dist0038);\n" +" _res0026 = _TMP27 + _TMP37;\n" +" _diff0048 = TEX1.xy - vec2( -6.00000024E-01, 3.00000012E-01);\n" +" _TMP7 = dot(_diff0048, _diff0048);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0048 = 3.00000000E+02*_TMP8;\n" +" _dist0048 = _dist0048 - 1.50000006E-01*float(FrameCount);\n" +" _TMP47 = sin(_dist0048);\n" +" _res0026 = _res0026 + _TMP47;\n" +" _diff0058 = TEX1.xy - vec2( 1.00000001E-01, 4.00000006E-01);\n" +" _TMP7 = dot(_diff0058, _diff0058);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0058 = 3.00000000E+02*_TMP8;\n" +" _dist0058 = _dist0058 - 1.50000006E-01*float(FrameCount);\n" +" _TMP57 = sin(_dist0058);\n" +" _res0026 = _res0026 + _TMP57;\n" +" _diff0068 = TEX1.xy - vec2( 1.00000001E-01, 4.00000006E-01);\n" +" _TMP7 = dot(_diff0068, _diff0068);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0068 = 3.00000000E+02*_TMP8;\n" +" _dist0068 = _dist0068 - 1.50000006E-01*float(FrameCount);\n" +" _TMP67 = sin(_dist0068);\n" +" _res0026 = _res0026 + _TMP67;\n" +" _diff0078 = TEX1.xy - vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _TMP7 = dot(_diff0078, _diff0078);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0078 = 3.00000000E+02*_TMP8;\n" +" _dist0078 = _dist0078 - 1.50000006E-01*float(FrameCount);\n" +" _TMP77 = sin(_dist0078);\n" +" _res0026 = _res0026 + _TMP77;\n" +" _diff0088 = TEX1.xy - vec2( -1.00000000E+00, 1.00000000E+00);\n" +" _TMP7 = dot(_diff0088, _diff0088);\n" +" _TMP9 = inversesqrt(_TMP7);\n" +" _TMP8 = 1.00000000E+00/_TMP9;\n" +" _dist0088 = 3.00000000E+02*_TMP8;\n" +" _dist0088 = _dist0088 - 1.50000006E-01*float(FrameCount);\n" +" _TMP87 = sin(_dist0088);\n" +" _res0026 = _res0026 + _TMP87;\n" +" _TMP200026 = _TMP0.xyz*(6.99999988E-01 + 5.00000007E-02*_res0026);\n" +" _background = vec4(_TMP200026.x, _TMP200026.y, _TMP200026.z, _TMP0.w);\n" +" _ret_0 = _frame + _background.w*(_background - _frame);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/interpolation.h b/src/video/sdl/shaders/interpolation.h deleted file mode 100644 index adcbabea8..000000000 --- a/src/video/sdl/shaders/interpolation.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - - " float sharpness = 0.8;\n" - - " if (full_interpolation == 1.0) {\n" - " sharpness = 0.0;\n" - " }\n" - - " vec2 scale = (size_video_mode / vec2(pixel_aspect_ratio, 1.0)) / size_screen_emu;\n" - " vec2 interp = (scale - mix(scale, vec2(1.0), vec2(sharpness))) / (scale * 2.0);\n" - " vec2 pnt = v_texCoord.xy;\n" - - " interp = clamp(interp, 0.0, 1.0);\n" - " pnt = (pnt * size_texture) + 0.5;\n" - - " vec2 i = floor(pnt);\n" - " vec2 f = pnt - i;\n" - - " f = (f - interp) / (1.0 - interp * 2.0);\n" - " f = clamp(f, 0.0, 1.0);\n" - - " pnt = i + f;\n" - " pnt = (pnt - 0.5) / size_texture;\n" diff --git a/src/video/sdl/shaders/misc/image-adjustment.h b/src/video/sdl/shaders/misc/image-adjustment.h new file mode 100644 index 000000000..8737830fd --- /dev/null +++ b/src/video/sdl/shaders/misc/image-adjustment.h @@ -0,0 +1,149 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color1;\n" +"};\n" +"vec4 _oPosition1;\n" +"input_dummy _IN1;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _otexCoord;\n" +" vec2 _shift;\n" +" vec2 _overscan_coord;\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0006;\n" +" _oColor = COLOR;\n" +" _shift = (5.00000000E-01*InputSize)/TextureSize;\n" +" _overscan_coord = (TexCoord.xy - _shift) + _shift;\n" +" _otexCoord = _overscan_coord;\n" +" gl_Position = _r0006;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _overscan_coord;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"float _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec3 _TMP29;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec2 _fragcoord;\n" +" vec3 _satColor;\n" +" vec3 _conColor;\n" +" _fragcoord = TEX0.xy*(TextureSize.xy/InputSize.xy);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _TMP1 = dot(_TMP0.xyz, vec3( 2.12599993E-01, 7.15200007E-01, 7.22000003E-02));\n" +" _satColor = vec3(_TMP1, _TMP1, _TMP1) + (_TMP0.xyz - vec3(_TMP1, _TMP1, _TMP1));\n" +" _conColor = vec3( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01) + (_satColor - vec3( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01));\n" +" _TMP2 = pow(_conColor.x, 1.09090912E+00);\n" +" _TMP3 = pow(_conColor.y, 1.09090912E+00);\n" +" _TMP4 = pow(_conColor.z, 1.09090912E+00);\n" +" _conColor = vec3(_TMP2, _TMP3, _TMP4);\n" +" _TMP5 = min(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _conColor);\n" +" _TMP29 = max(vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP5);\n" +" _conColor = _TMP29;\n" +" if (_fragcoord.y > 0.00000000E+00 && _fragcoord.y < 1.00000000E+00) { \n" +" } else {\n" +" _conColor = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" } \n" +" if (_fragcoord.x > 0.00000000E+00 && _fragcoord.x < 1.00000000E+00) { \n" +" } else {\n" +" _conColor = vec3( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00);\n" +" } \n" +" _ret_0 = vec4(_conColor.x, _conColor.y, _conColor.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/motionblur/feedback.h b/src/video/sdl/shaders/motionblur/feedback.h new file mode 100644 index 000000000..c6fbae596 --- /dev/null +++ b/src/video/sdl/shaders/motionblur/feedback.h @@ -0,0 +1,138 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARfeedbacktex;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"COMPAT_VARYING vec2 VARtex_coord;\n" +"struct input_dummy {\n" +" vec2 VARtex_coord;\n" +" vec4 _vertex_coord;\n" +" vec4 _mvp_matrix[4];\n" +"float _placeholder35;\n" +"};\n" +"struct vertex_data {\n" +" vec2 VARtex;\n" +" vec2 VARfeedbacktex;\n" +"};\n" +"vec4 _oPosition1;\n" +"vertex_data _vert1;\n" +"input_dummy _IN1;\n" +"input_dummy _FEEDBACK1;\n" +"vec4 _r0007;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"COMPAT_ATTRIBUTE vec2 FeedbackTexCoord;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec2 TexCoord;\n" +"void main()\n" +"{\n" +" _r0007 = VertexCoord.x*MVPMatrix[0];\n" +" _r0007 = _r0007 + VertexCoord.y*MVPMatrix[1];\n" +" _r0007 = _r0007 + VertexCoord.z*MVPMatrix[2];\n" +" _r0007 = _r0007 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0007;\n" +" VARtex = TexCoord;\n" +" VARfeedbacktex = FeedbackTexCoord;\n" +" gl_Position = _r0007;\n" +"}\n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARfeedbacktex;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"COMPAT_VARYING vec2 VARtex_coord;\n" +"struct input_dummy {\n" +" vec2 VARtex_coord;\n" +" vec4 _vertex_coord;\n" +" vec4 _mvp_matrix[4];\n" +"float _placeholder35;\n" +"};\n" +"struct vertex_data {\n" +" vec2 VARtex;\n" +" vec2 VARfeedbacktex;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"vertex_data _vert1;\n" +"input_dummy _IN1;\n" +"input_dummy _FEEDBACK1;\n" +" \n" +"uniform sampler2D Texture;\n" +"uniform sampler2D FeedbackTexture;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _current;\n" +" vec4 _fdback;\n" +" vec4 _mixed;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _TMP2 = pow(_TMP0.x, 2.20000005E+00);\n" +" _TMP3 = pow(_TMP0.y, 2.20000005E+00);\n" +" _TMP4 = pow(_TMP0.z, 2.20000005E+00);\n" +" _TMP5 = pow(_TMP0.w, 2.20000005E+00);\n" +" _current = vec4(_TMP2, _TMP3, _TMP4, _TMP5);\n" +" _TMP1 = COMPAT_TEXTURE(FeedbackTexture, VARfeedbacktex);\n" +" _TMP2 = pow(_TMP1.x, 2.20000005E+00);\n" +" _TMP3 = pow(_TMP1.y, 2.20000005E+00);\n" +" _TMP4 = pow(_TMP1.z, 2.20000005E+00);\n" +" _TMP5 = pow(_TMP1.w, 2.20000005E+00);\n" +" _fdback = vec4(_TMP2, _TMP3, _TMP4, _TMP5);\n" +" _mixed = 2.50000000E-01*_current + 7.50000000E-01*_fdback;\n" +" _TMP2 = pow(_mixed.x, 4.54545438E-01);\n" +" _TMP3 = pow(_mixed.y, 4.54545438E-01);\n" +" _TMP4 = pow(_mixed.z, 4.54545438E-01);\n" +" _TMP5 = pow(_mixed.w, 4.54545438E-01);\n" +" _ret_0 = vec4(_TMP2, _TMP3, _TMP4, _TMP5);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n"}, diff --git a/src/video/sdl/shaders/mudlord/emboss.h b/src/video/sdl/shaders/mudlord/emboss.h new file mode 100644 index 000000000..4d70c446b --- /dev/null +++ b/src/video/sdl/shaders/mudlord/emboss.h @@ -0,0 +1,139 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _CT;\n" +"COMPAT_VARYING vec4 _position2;\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _position1;\n" +" vec2 _texCoord1;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"struct VERTEX_INPUT {\n" +" vec4 _position2;\n" +" vec2 _CT;\n" +"};\n" +"VERTEX_OUTPUT _ret_0;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _ret_0._position1 = _r0005;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _CT;\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec2 _texCoord;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"struct VERTEX_INPUT {\n" +" vec2 _CT;\n" +"};\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0008;\n" +"vec2 _c0010;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _Color;\n" +" _c0008 = TEX0.xy - 1.00000005E-03;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, _c0008);\n" +" _Color = vec4( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01, 1.00000000E+00) - _TMP0*2.00000000E+00;\n" +" _c0010 = TEX0.xy + 1.00000005E-03;\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0010);\n" +" _Color = _Color + _TMP1*2.00000000E+00;\n" +" _Color.xyz = vec3((_Color.x + _Color.y + _Color.z)/3.00000000E+00, (_Color.x + _Color.y + _Color.z)/3.00000000E+00, (_Color.x + _Color.y + _Color.z)/3.00000000E+00);\n" +" FragColor = _Color;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/mudlord/mud-mudlord.h b/src/video/sdl/shaders/mudlord/mud-mudlord.h new file mode 100644 index 000000000..629082a25 --- /dev/null +++ b/src/video/sdl/shaders/mudlord/mud-mudlord.h @@ -0,0 +1,128 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oColor = COLOR;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP2;\n" +"float _TMP3;\n" +"float _TMP1;\n" +"float _TMP0;\n" +"uniform sampler2D Texture;\n" +"float _frame_cnt0007;\n" +"vec2 _constant10007;\n" +"float _constant20007;\n" +"float _x0015;\n" +"float _x0017;\n" +"float _TMP18;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _color;\n" +" _frame_cnt0007 = cos(0.00000000E+00);\n" +" _constant10007 = _frame_cnt0007*vec2( 1.29090910E+01, 7.82307663E+01);\n" +" _constant20007 = (_frame_cnt0007*4.81344000E+05)/1.10000000E+01;\n" +" _TMP0 = dot(TEX0.xy, _constant10007);\n" +" _TMP1 = sin(_TMP0);\n" +" _x0015 = _TMP1*_constant20007;\n" +" _TMP2 = fract(_x0015);\n" +" _x0017 = _TMP2 + 2.00000003E-01;\n" +" _TMP3 = min(1.00000000E+00, _x0017);\n" +" _TMP18 = max(0.00000000E+00, _TMP3);\n" +" _color = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _color = (_color - 6.27451017E-02)*1.16438353E+00;\n" +" _ret_0 = _color*_TMP18;\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/mudlord/noise-mudlord.h b/src/video/sdl/shaders/mudlord/noise-mudlord.h new file mode 100644 index 000000000..09c69cb81 --- /dev/null +++ b/src/video/sdl/shaders/mudlord/noise-mudlord.h @@ -0,0 +1,129 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0005;\n" +" _oColor = COLOR;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0005;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP2;\n" +"float _TMP3;\n" +"float _TMP1;\n" +"float _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _frame_cnt0007;\n" +"vec2 _constant10007;\n" +"float _constant20007;\n" +"float _x0015;\n" +"float _x0017;\n" +"float _TMP18;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _color;\n" +" _frame_cnt0007 = cos(float(FrameCount));\n" +" _constant10007 = _frame_cnt0007*vec2( 1.29090910E+01, 7.82307663E+01);\n" +" _constant20007 = (_frame_cnt0007*4.81344000E+05)/1.10000000E+01;\n" +" _TMP0 = dot(TEX0.xy, _constant10007);\n" +" _TMP1 = sin(_TMP0);\n" +" _x0015 = _TMP1*_constant20007;\n" +" _TMP2 = fract(_x0015);\n" +" _x0017 = _TMP2 + 2.00000003E-01;\n" +" _TMP3 = min(1.00000000E+00, _x0017);\n" +" _TMP18 = max(0.00000000E+00, _TMP3);\n" +" _color = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _color = (_color - 6.27451017E-02)*1.16438353E+00;\n" +" _ret_0 = _color*_TMP18;\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/mudlord/oldtv.h b/src/video/sdl/shaders/mudlord/oldtv.h new file mode 100644 index 000000000..494020544 --- /dev/null +++ b/src/video/sdl/shaders/mudlord/oldtv.h @@ -0,0 +1,172 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord1;\n" +"COMPAT_VARYING vec4 _vpos1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _position1;\n" +" vec4 _vpos1;\n" +" vec2 _texCoord1;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"VERTEX_OUTPUT _ret_0;\n" +"vec4 _r0006;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0006 = VertexCoord.x*MVPMatrix[0];\n" +" _r0006 = _r0006 + VertexCoord.y*MVPMatrix[1];\n" +" _r0006 = _r0006 + VertexCoord.z*MVPMatrix[2];\n" +" _r0006 = _r0006 + VertexCoord.w*MVPMatrix[3];\n" +" _ret_0._position1 = _r0006;\n" +" _ret_0._vpos1 = _r0006;\n" +" _ret_0._texCoord1 = TexCoord.xy;\n" +" gl_Position = _r0006;\n" +" TEX1 = _r0006;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" TEX1 = _ret_0._vpos1;\n" +" TEX0.xy = _ret_0._texCoord1;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _color;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _vpos;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct VERTEX_OUTPUT {\n" +" vec4 _vpos;\n" +" vec2 _texCoord;\n" +"};\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"float _TMP4;\n" +"float _TMP1;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"float _TMP0;\n" +"VERTEX_OUTPUT _TMP8;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"float _TMP13;\n" +"float _x0014;\n" +"float _frame_cnt0020;\n" +"vec2 _constant10020;\n" +"float _constant20020;\n" +"float _x0028;\n" +"float _TMP29;\n" +"float _x0030;\n" +"vec2 _c0038;\n" +"vec2 _c0042;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" output_dummy _OUT;\n" +" float _f;\n" +" vec4 _distortion2;\n" +" _TMP8._vpos = TEX1/TEX1.w;\n" +" _f = (1.00000000E+00 - _TMP8._vpos.x*_TMP8._vpos.x)*(1.00000000E+00 - _TMP8._vpos.y*_TMP8._vpos.y);\n" +" _TMP0 = pow(_f, 4.39999998E-01);\n" +" _x0014 = 8.00000012E-01*(_TMP0 - 1.59999996E-01);\n" +" _TMP1 = min(1.00000000E+00, _x0014);\n" +" _TMP13 = max(0.00000000E+00, _TMP1);\n" +" _frame_cnt0020 = cos(float(FrameCount));\n" +" _constant10020 = _frame_cnt0020*vec2( 1.29090910E+01, 7.82307663E+01);\n" +" _constant20020 = (_frame_cnt0020*4.81344000E+05)/1.10000000E+01;\n" +" _TMP2 = dot(TEX0.xy, _constant10020);\n" +" _TMP3 = sin(_TMP2);\n" +" _x0028 = _TMP3*_constant20020;\n" +" _TMP4 = fract(_x0028);\n" +" _x0030 = _TMP4 + 2.00000003E-01;\n" +" _TMP1 = min(1.00000000E+00, _x0030);\n" +" _TMP29 = max(0.00000000E+00, _TMP1);\n" +" _c0038 = TEX0.xy + 1.95312500E-03;\n" +" _TMP5 = COMPAT_TEXTURE(Texture, _c0038);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _c0042 = TEX0.xy - 1.95312500E-03;\n" +" _TMP7 = COMPAT_TEXTURE(Texture, _c0042);\n" +" _distortion2 = vec4(_TMP5.x, _TMP6.y, _TMP7.z, 1.00000000E+00);\n" +" _OUT._color = _TMP13*(_distortion2*_TMP29);\n" +" FragColor = _OUT._color;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/no_filter.h b/src/video/sdl/shaders/no_filter.h index 7a805ebda..ca277f4f2 100644 --- a/src/video/sdl/shaders/no_filter.h +++ b/src/video/sdl/shaders/no_filter.h @@ -1,49 +1,109 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/*****************************************************************************************/ -/* NO_FILTER */ -/*****************************************************************************************/ { - // vertex shader - "varying vec4 v_texCoord;\n" - - "void main(void) {\n" - " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" - " gl_FrontColor = gl_Color;\n" - " v_texCoord = gl_MultiTexCoord0;\n" - "}", - // fragment shader - "uniform vec2 size_screen_emu;\n" - "uniform vec2 size_video_mode;\n" - "uniform vec2 size_texture;\n" - "uniform float pixel_aspect_ratio;\n" - "uniform float full_interpolation;\n" - - "uniform sampler2D texture_scr;\n" - - "varying vec4 v_texCoord;\n" - - "void main(void) {\n" - -#include "interpolation.h" - - " vec4 scr = texture2D(texture_scr, pnt);\n" - " gl_FragColor = scr * gl_Color;\n" - "}" +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec4 _color;\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _r0005;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0005 = VertexCoord.x*MVPMatrix[0];\n" +" _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];\n" +" _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];\n" +" _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];\n" +" gl_Position = _r0005;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"COMPAT_VARYING vec4 _color;\n" +"struct output_dummy {\n" +" vec4 _color;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"input_dummy _IN1;\n" +"uniform sampler2D Texture;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" output_dummy _OUT;\n" +" _OUT._color = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" FragColor = _OUT._color;\n" +" return;\n" +"} \n" +"#endif\n" }, + diff --git a/src/video/sdl/shaders/ntsc/ntsc-pass1-composite-2phase.h b/src/video/sdl/shaders/ntsc/ntsc-pass1-composite-2phase.h new file mode 100644 index 000000000..347b514f4 --- /dev/null +++ b/src/video/sdl/shaders/ntsc/ntsc-pass1-composite-2phase.h @@ -0,0 +1,145 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" vec2 VARpix_no;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0009;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0009 = VertexCoord.x*MVPMatrix[0];\n" +" _r0009 = _r0009 + VertexCoord.y*MVPMatrix[1];\n" +" _r0009 = _r0009 + VertexCoord.z*MVPMatrix[2];\n" +" _r0009 = _r0009 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0009;\n" +" VARtex = TexCoord.xy;\n" +" VARpix_no = TexCoord.xy*TextureSize*(OutputSize/InputSize);\n" +" gl_Position = _r0009;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" vec2 VARpix_no;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"vec4 _TMP0;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec3 _r0018;\n" +"float _c0026;\n" +"float _a0028;\n" +"vec3 _r0038;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _yiq;\n" +" float _chroma_phase;\n" +" float _mod_phase;\n" +" float _i_mod;\n" +" float _q_mod;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _r0018.x = dot(vec3( 2.98900008E-01, 5.87000012E-01, 1.14000000E-01), _TMP0.xyz);\n" +" _r0018.y = dot(vec3( 5.95899999E-01, -2.74399996E-01, -3.21599990E-01), _TMP0.xyz);\n" +" _r0018.z = dot(vec3( 2.11500004E-01, -5.22899985E-01, 3.11399996E-01), _TMP0.xyz);\n" +" _yiq = _r0018;\n" +" _a0028 = VARpix_no.y/2.00000000E+00;\n" +" _TMP2 = abs(_a0028);\n" +" _TMP3 = fract(_TMP2);\n" +" _TMP4 = abs(2.00000000E+00);\n" +" _c0026 = _TMP3*_TMP4;\n" +" if (VARpix_no.y < 0.00000000E+00) { \n" +" _TMP5 = -_c0026;\n" +" } else {\n" +" _TMP5 = _c0026;\n" +" } \n" +" _chroma_phase = 3.14159274E+00*(_TMP5 + float(FrameCount));\n" +" _mod_phase = _chroma_phase + VARpix_no.x*8.37758064E-01;\n" +" _i_mod = cos(_mod_phase);\n" +" _q_mod = sin(_mod_phase);\n" +" _yiq.yz = _r0018.yz*vec2(_i_mod, _q_mod);\n" +" _r0038.x = dot(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _yiq);\n" +" _r0038.y = dot(vec3( 1.00000000E+00, 2.00000000E+00, 0.00000000E+00), _yiq);\n" +" _r0038.z = dot(vec3( 1.00000000E+00, 0.00000000E+00, 2.00000000E+00), _yiq);\n" +" _yiq.yz = _r0038.yz*vec2(_i_mod, _q_mod);\n" +" _ret_0 = vec4(_r0038.x, _yiq.y, _yiq.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/ntsc/ntsc-pass1-composite-3phase.h b/src/video/sdl/shaders/ntsc/ntsc-pass1-composite-3phase.h new file mode 100644 index 000000000..4983f5c80 --- /dev/null +++ b/src/video/sdl/shaders/ntsc/ntsc-pass1-composite-3phase.h @@ -0,0 +1,145 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" vec2 VARpix_no;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0009;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0009 = VertexCoord.x*MVPMatrix[0];\n" +" _r0009 = _r0009 + VertexCoord.y*MVPMatrix[1];\n" +" _r0009 = _r0009 + VertexCoord.z*MVPMatrix[2];\n" +" _r0009 = _r0009 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0009;\n" +" VARtex = TexCoord.xy;\n" +" VARpix_no = TexCoord.xy*TextureSize*(OutputSize/InputSize);\n" +" gl_Position = _r0009;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" vec2 VARpix_no;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"vec4 _TMP0;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec3 _r0018;\n" +"float _c0026;\n" +"float _a0028;\n" +"vec3 _r0038;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _yiq;\n" +" float _chroma_phase;\n" +" float _mod_phase;\n" +" float _i_mod;\n" +" float _q_mod;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _r0018.x = dot(vec3( 2.98900008E-01, 5.87000012E-01, 1.14000000E-01), _TMP0.xyz);\n" +" _r0018.y = dot(vec3( 5.95899999E-01, -2.74399996E-01, -3.21599990E-01), _TMP0.xyz);\n" +" _r0018.z = dot(vec3( 2.11500004E-01, -5.22899985E-01, 3.11399996E-01), _TMP0.xyz);\n" +" _yiq = _r0018;\n" +" _a0028 = VARpix_no.y/3.00000000E+00;\n" +" _TMP2 = abs(_a0028);\n" +" _TMP3 = fract(_TMP2);\n" +" _TMP4 = abs(3.00000000E+00);\n" +" _c0026 = _TMP3*_TMP4;\n" +" if (VARpix_no.y < 0.00000000E+00) { \n" +" _TMP5 = -_c0026;\n" +" } else {\n" +" _TMP5 = _c0026;\n" +" } \n" +" _chroma_phase = 2.09449983E+00*(_TMP5 + float(FrameCount));\n" +" _mod_phase = _chroma_phase + VARpix_no.x*1.04719758E+00;\n" +" _i_mod = cos(_mod_phase);\n" +" _q_mod = sin(_mod_phase);\n" +" _yiq.yz = _r0018.yz*vec2(_i_mod, _q_mod);\n" +" _r0038.x = dot(vec3( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _yiq);\n" +" _r0038.y = dot(vec3( 1.00000000E+00, 2.00000000E+00, 0.00000000E+00), _yiq);\n" +" _r0038.z = dot(vec3( 1.00000000E+00, 0.00000000E+00, 2.00000000E+00), _yiq);\n" +" _yiq.yz = _r0038.yz*vec2(_i_mod, _q_mod);\n" +" _ret_0 = vec4(_r0038.x, _yiq.y, _yiq.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/ntsc/ntsc-pass1-svideo-3phase.h b/src/video/sdl/shaders/ntsc/ntsc-pass1-svideo-3phase.h new file mode 100644 index 000000000..3630e5e52 --- /dev/null +++ b/src/video/sdl/shaders/ntsc/ntsc-pass1-svideo-3phase.h @@ -0,0 +1,145 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" vec2 VARpix_no;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0009;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0009 = VertexCoord.x*MVPMatrix[0];\n" +" _r0009 = _r0009 + VertexCoord.y*MVPMatrix[1];\n" +" _r0009 = _r0009 + VertexCoord.z*MVPMatrix[2];\n" +" _r0009 = _r0009 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0009;\n" +" VARtex = TexCoord.xy;\n" +" VARpix_no = TexCoord.xy*TextureSize*(OutputSize/InputSize);\n" +" gl_Position = _r0009;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARpix_no;\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +" vec2 VARpix_no;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP5;\n" +"float _TMP4;\n" +"float _TMP3;\n" +"float _TMP2;\n" +"vec4 _TMP0;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec3 _r0018;\n" +"float _c0026;\n" +"float _a0028;\n" +"vec3 _r0038;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _yiq;\n" +" float _chroma_phase;\n" +" float _mod_phase;\n" +" float _i_mod;\n" +" float _q_mod;\n" +" _TMP0 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _r0018.x = dot(vec3( 2.98900008E-01, 5.87000012E-01, 1.14000000E-01), _TMP0.xyz);\n" +" _r0018.y = dot(vec3( 5.95899999E-01, -2.74399996E-01, -3.21599990E-01), _TMP0.xyz);\n" +" _r0018.z = dot(vec3( 2.11500004E-01, -5.22899985E-01, 3.11399996E-01), _TMP0.xyz);\n" +" _yiq = _r0018;\n" +" _a0028 = VARpix_no.y/3.00000000E+00;\n" +" _TMP2 = abs(_a0028);\n" +" _TMP3 = fract(_TMP2);\n" +" _TMP4 = abs(3.00000000E+00);\n" +" _c0026 = _TMP3*_TMP4;\n" +" if (VARpix_no.y < 0.00000000E+00) { \n" +" _TMP5 = -_c0026;\n" +" } else {\n" +" _TMP5 = _c0026;\n" +" } \n" +" _chroma_phase = 2.09449983E+00*(_TMP5 + float(FrameCount));\n" +" _mod_phase = _chroma_phase + VARpix_no.x*1.04719758E+00;\n" +" _i_mod = cos(_mod_phase);\n" +" _q_mod = sin(_mod_phase);\n" +" _yiq.yz = _r0018.yz*vec2(_i_mod, _q_mod);\n" +" _r0038.x = dot(vec3( 1.00000000E+00, 0.00000000E+00, 0.00000000E+00), _yiq);\n" +" _r0038.y = dot(vec3( 0.00000000E+00, 2.00000000E+00, 0.00000000E+00), _yiq);\n" +" _r0038.z = dot(vec3( 0.00000000E+00, 0.00000000E+00, 2.00000000E+00), _yiq);\n" +" _yiq.yz = _r0038.yz*vec2(_i_mod, _q_mod);\n" +" _ret_0 = vec4(_r0038.x, _yiq.y, _yiq.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/ntsc/ntsc-pass2-2phase.h b/src/video/sdl/shaders/ntsc/ntsc-pass2-2phase.h new file mode 100644 index 000000000..b0f94b316 --- /dev/null +++ b/src/video/sdl/shaders/ntsc/ntsc-pass2-2phase.h @@ -0,0 +1,309 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0010;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0010 = VertexCoord.x*MVPMatrix[0];\n" +" _r0010 = _r0010 + VertexCoord.y*MVPMatrix[1];\n" +" _r0010 = _r0010 + VertexCoord.z*MVPMatrix[2];\n" +" _r0010 = _r0010 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0010;\n" +" VARtex = TexCoord.xy - vec2(5.00000000E-01/TextureSize.x, 0.00000000E+00);\n" +" gl_Position = _r0010;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0013;\n" +"vec2 _c0015;\n" +"vec3 _r0021;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" float _one_x;\n" +" vec3 _signal;\n" +" vec3 _sums1;\n" +" _one_x = 1.00000000E+00/TextureSize.x;\n" +" _c0013 = VARtex + vec2(-3.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(3.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _sums1*vec3( -1.74843997E-04, 1.38476200E-03, 1.38476200E-03);\n" +" _c0013 = VARtex + vec2(-3.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(3.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.05844000E-04, 1.67831196E-03, 1.67831196E-03);\n" +" _c0013 = VARtex + vec2(-3.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(3.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.49453001E-04, 2.02171504E-03, 2.02171504E-03);\n" +" _c0013 = VARtex + vec2(-2.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -5.16930013E-05, 2.42056209E-03, 2.42056209E-03);\n" +" _c0013 = VARtex + vec2(-2.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 0.00000000E+00, 2.88045988E-03, 2.88045988E-03);\n" +" _c0013 = VARtex + vec2(-2.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -6.61710001E-05, 3.40687903E-03, 3.40687903E-03);\n" +" _c0013 = VARtex + vec2(-2.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.45058007E-04, 4.00498509E-03, 4.00498509E-03);\n" +" _c0013 = VARtex + vec2(-2.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -4.32928005E-04, 4.67944518E-03, 4.67944518E-03);\n" +" _c0013 = VARtex + vec2(-2.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -4.72643995E-04, 5.43421786E-03, 5.43421786E-03);\n" +" _c0013 = VARtex + vec2(-2.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.52236001E-04, 6.27233181E-03, 6.27233181E-03);\n" +" _c0013 = VARtex + vec2(-2.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.98929003E-04, 7.19565386E-03, 7.19565386E-03);\n" +" _c0013 = VARtex + vec2(-2.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 6.87058026E-04, 8.20466504E-03, 8.20466504E-03);\n" +" _c0013 = VARtex + vec2(-2.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 9.44112020E-04, 9.29823797E-03, 9.29823797E-03);\n" +" _c0013 = VARtex + vec2(-1.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 8.03467003E-04, 1.04734497E-02, 1.04734497E-02);\n" +" _c0013 = VARtex + vec2(-1.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 3.63199011E-04, 1.17254127E-02, 1.17254127E-02);\n" +" _c0013 = VARtex + vec2(-1.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.34219999E-05, 1.30471550E-02, 1.30471550E-02);\n" +" _c0013 = VARtex + vec2(-1.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.53401988E-04, 1.44295478E-02, 1.44295478E-02);\n" +" _c0013 = VARtex + vec2(-1.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.33946096E-03, 1.58613063E-02, 1.58613063E-02);\n" +" _c0013 = VARtex + vec2(-1.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.93297204E-03, 1.73290372E-02, 1.73290372E-02);\n" +" _c0013 = VARtex + vec2(-1.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 3.98348505E-03, 1.88173819E-02, 1.88173819E-02);\n" +" _c0013 = VARtex + vec2(-1.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 3.02668312E-03, 2.03092191E-02, 2.03092191E-02);\n" +" _c0013 = VARtex + vec2(-1.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.10205601E-03, 2.17859522E-02, 2.17859522E-02);\n" +" _c0013 = VARtex + vec2(-1.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -8.37302580E-03, 2.32278574E-02, 2.32278574E-02);\n" +" _c0013 = VARtex + vec2(-9.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(9.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.68977007E-02, 2.46144999E-02, 2.46144999E-02);\n" +" _c0013 = VARtex + vec2(-8.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(8.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.29144804E-02, 2.59252023E-02, 2.59252023E-02);\n" +" _c0013 = VARtex + vec2(-7.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(7.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.16423478E-02, 2.71395463E-02, 2.71395463E-02);\n" +" _c0013 = VARtex + vec2(-6.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(6.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -8.86327308E-03, 2.82378923E-02, 2.82378923E-02);\n" +" _c0013 = VARtex + vec2(-5.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(5.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.72719564E-02, 2.92019099E-02, 2.92019099E-02);\n" +" _c0013 = VARtex + vec2(-4.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(4.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 5.49219213E-02, 3.00150812E-02, 3.00150812E-02);\n" +" _c0013 = VARtex + vec2(-3.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(3.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 9.83425826E-02, 3.06631699E-02, 3.06631699E-02);\n" +" _c0013 = VARtex + vec2(-2.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.39044285E-01, 3.11346408E-02, 3.11346408E-02);\n" +" _c0013 = VARtex + vec2(-_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.68055832E-01, 3.14209945E-02, 3.14209945E-02);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _signal = _signal + _TMP3.xyz*vec3( 1.78571433E-01, 3.15170325E-02, 3.15170325E-02);\n" +" _r0021.x = dot(vec3( 1.00000000E+00, 9.55999970E-01, 6.20999992E-01), _signal);\n" +" _r0021.y = dot(vec3( 1.00000000E+00, -2.72000015E-01, -6.47400022E-01), _signal);\n" +" _r0021.z = dot(vec3( 1.00000000E+00, -1.10599995E+00, 1.70459998E+00), _signal);\n" +" _ret_0 = vec4(_r0021.x, _r0021.y, _r0021.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/ntsc/ntsc-pass2-3phase-linear.h b/src/video/sdl/shaders/ntsc/ntsc-pass2-3phase-linear.h new file mode 100644 index 000000000..83fb84a15 --- /dev/null +++ b/src/video/sdl/shaders/ntsc/ntsc-pass2-3phase-linear.h @@ -0,0 +1,271 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0011;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0011 = VertexCoord.x*MVPMatrix[0];\n" +" _r0011 = _r0011 + VertexCoord.y*MVPMatrix[1];\n" +" _r0011 = _r0011 + VertexCoord.z*MVPMatrix[2];\n" +" _r0011 = _r0011 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0011;\n" +" VARtex = TexCoord.xy - vec2(5.00000000E-01/TextureSize.x, 0.00000000E+00);\n" +" gl_Position = _r0011;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP4;\n" +"float _TMP7;\n" +"float _TMP6;\n" +"float _TMP5;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0018;\n" +"vec2 _c0020;\n" +"vec3 _r0026;\n" +"#define _NTSC_CRT_GAMMA 2.4\n" +//"uniform float _NTSC_CRT_GAMMA;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" float _one_x;\n" +" vec3 _signal;\n" +" vec3 _sums1;\n" +" _one_x = 1.00000000E+00/TextureSize.x;\n" +" _c0018 = VARtex + vec2(-2.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(2.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _sums1*vec3( -1.20200002E-05, -1.18846998E-04, -1.18846998E-04);\n" +" _c0018 = VARtex + vec2(-2.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(2.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.21459995E-05, -2.71305995E-04, -2.71305995E-04);\n" +" _c0018 = VARtex + vec2(-2.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(2.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.31549996E-05, -5.02642011E-04, -5.02642011E-04);\n" +" _c0018 = VARtex + vec2(-2.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(2.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.20200002E-05, -9.30832990E-04, -9.30832990E-04);\n" +" _c0018 = VARtex + vec2(-2.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(2.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -4.99790003E-05, -1.45101303E-03, -1.45101303E-03);\n" +" _c0018 = VARtex + vec2(-1.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.13939997E-04, -2.06474401E-03, -2.06474401E-03);\n" +" _c0018 = VARtex + vec2(-1.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.22149999E-04, -2.70043197E-03, -2.70043197E-03);\n" +" _c0018 = VARtex + vec2(-1.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -5.61200022E-06, -3.24127590E-03, -3.24127590E-03);\n" +" _c0018 = VARtex + vec2(-1.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.70515996E-04, -3.52494791E-03, -3.52494791E-03);\n" +" _c0018 = VARtex + vec2(-1.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.37198998E-04, -3.35028395E-03, -3.35028395E-03);\n" +" _c0018 = VARtex + vec2(-1.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.69640000E-04, -2.49172910E-03, -2.49172910E-03);\n" +" _c0018 = VARtex + vec2(-1.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.85688002E-04, -7.21148972E-04, -7.21148972E-04);\n" +" _c0018 = VARtex + vec2(-1.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 9.84573970E-04, 2.16465909E-03, 2.16465909E-03);\n" +" _c0018 = VARtex + vec2(-1.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.01868289E-03, 6.31363504E-03, 6.31363504E-03);\n" +" _c0018 = VARtex + vec2(-1.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(1.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.00227508E-03, 1.17891030E-02, 1.17891030E-02);\n" +" _c0018 = VARtex + vec2(-9.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(9.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -9.09882016E-04, 1.85456593E-02, 1.85456593E-02);\n" +" _c0018 = VARtex + vec2(-8.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(8.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -7.04908092E-03, 2.64143962E-02, 2.64143962E-02);\n" +" _c0018 = VARtex + vec2(-7.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(7.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.32228602E-02, 3.51007096E-02, 3.51007096E-02);\n" +" _c0018 = VARtex + vec2(-6.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(6.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.26069309E-02, 4.41965684E-02, 4.41965684E-02);\n" +" _c0018 = VARtex + vec2(-5.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(5.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.46085995E-03, 5.32072037E-02, 5.32072037E-02);\n" +" _c0018 = VARtex + vec2(-4.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(4.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 3.58682238E-02, 6.15902767E-02, 6.15902767E-02);\n" +" _c0018 = VARtex + vec2(-3.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(3.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 8.40164497E-02, 6.88036010E-02, 6.88036010E-02);\n" +" _c0018 = VARtex + vec2(-2.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(2.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.35563493E-01, 7.43561909E-02, 7.43561909E-02);\n" +" _c0018 = VARtex + vec2(-_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0018);\n" +" _c0020 = VARtex + vec2(_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0020);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.75261274E-01, 7.78565630E-02, 7.78565630E-02);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _signal = _signal + _TMP3.xyz*vec3( 1.90176547E-01, 7.90523961E-02, 7.90523961E-02);\n" +" _r0026.x = dot(vec3( 1.00000000E+00, 9.55999970E-01, 6.20999992E-01), _signal);\n" +" _r0026.y = dot(vec3( 1.00000000E+00, -2.72000015E-01, -6.47400022E-01), _signal);\n" +" _r0026.z = dot(vec3( 1.00000000E+00, -1.10599995E+00, 1.70459998E+00), _signal);\n" +" _TMP5 = pow(_r0026.x, _NTSC_CRT_GAMMA);\n" +" _TMP6 = pow(_r0026.y, _NTSC_CRT_GAMMA);\n" +" _TMP7 = pow(_r0026.z, _NTSC_CRT_GAMMA);\n" +" _TMP4 = vec3(_TMP5, _TMP6, _TMP7);\n" +" _ret_0 = vec4(_TMP4.x, _TMP4.y, _TMP4.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/ntsc/ntsc-pass2-3phase.h b/src/video/sdl/shaders/ntsc/ntsc-pass2-3phase.h new file mode 100644 index 000000000..fddfd7255 --- /dev/null +++ b/src/video/sdl/shaders/ntsc/ntsc-pass2-3phase.h @@ -0,0 +1,261 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _oPosition1;\n" +"data _oData1;\n" +"input_dummy _IN1;\n" +"vec4 _r0010;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0010 = VertexCoord.x*MVPMatrix[0];\n" +" _r0010 = _r0010 + VertexCoord.y*MVPMatrix[1];\n" +" _r0010 = _r0010 + VertexCoord.z*MVPMatrix[2];\n" +" _r0010 = _r0010 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0010;\n" +" VARtex = TexCoord.xy - vec2(5.00000000E-01/TextureSize.x, 0.00000000E+00);\n" +" gl_Position = _r0010;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 VARtex;\n" +"struct data {\n" +" vec2 VARtex;\n" +"};\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 VARtexture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +"};\n" +"vec4 _ret_0;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"input_dummy _IN1;\n" +"data _vertex1;\n" +"uniform sampler2D Texture;\n" +"vec2 _c0013;\n" +"vec2 _c0015;\n" +"vec3 _r0021;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" float _one_x;\n" +" vec3 _signal;\n" +" vec3 _sums1;\n" +" _one_x = 1.00000000E+00/TextureSize.x;\n" +" _c0013 = VARtex + vec2(-2.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _sums1*vec3( -1.20200002E-05, -1.18846998E-04, -1.18846998E-04);\n" +" _c0013 = VARtex + vec2(-2.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -2.21459995E-05, -2.71305995E-04, -2.71305995E-04);\n" +" _c0013 = VARtex + vec2(-2.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.31549996E-05, -5.02642011E-04, -5.02642011E-04);\n" +" _c0013 = VARtex + vec2(-2.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.20200002E-05, -9.30832990E-04, -9.30832990E-04);\n" +" _c0013 = VARtex + vec2(-2.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -4.99790003E-05, -1.45101303E-03, -1.45101303E-03);\n" +" _c0013 = VARtex + vec2(-1.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.90000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.13939997E-04, -2.06474401E-03, -2.06474401E-03);\n" +" _c0013 = VARtex + vec2(-1.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.80000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.22149999E-04, -2.70043197E-03, -2.70043197E-03);\n" +" _c0013 = VARtex + vec2(-1.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.70000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -5.61200022E-06, -3.24127590E-03, -3.24127590E-03);\n" +" _c0013 = VARtex + vec2(-1.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.60000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.70515996E-04, -3.52494791E-03, -3.52494791E-03);\n" +" _c0013 = VARtex + vec2(-1.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.50000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.37198998E-04, -3.35028395E-03, -3.35028395E-03);\n" +" _c0013 = VARtex + vec2(-1.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.40000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.69640000E-04, -2.49172910E-03, -2.49172910E-03);\n" +" _c0013 = VARtex + vec2(-1.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.30000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.85688002E-04, -7.21148972E-04, -7.21148972E-04);\n" +" _c0013 = VARtex + vec2(-1.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.20000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 9.84573970E-04, 2.16465909E-03, 2.16465909E-03);\n" +" _c0013 = VARtex + vec2(-1.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.10000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.01868289E-03, 6.31363504E-03, 6.31363504E-03);\n" +" _c0013 = VARtex + vec2(-1.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(1.00000000E+01*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.00227508E-03, 1.17891030E-02, 1.17891030E-02);\n" +" _c0013 = VARtex + vec2(-9.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(9.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -9.09882016E-04, 1.85456593E-02, 1.85456593E-02);\n" +" _c0013 = VARtex + vec2(-8.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(8.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -7.04908092E-03, 2.64143962E-02, 2.64143962E-02);\n" +" _c0013 = VARtex + vec2(-7.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(7.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.32228602E-02, 3.51007096E-02, 3.51007096E-02);\n" +" _c0013 = VARtex + vec2(-6.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(6.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( -1.26069309E-02, 4.41965684E-02, 4.41965684E-02);\n" +" _c0013 = VARtex + vec2(-5.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(5.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 2.46085995E-03, 5.32072037E-02, 5.32072037E-02);\n" +" _c0013 = VARtex + vec2(-4.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(4.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 3.58682238E-02, 6.15902767E-02, 6.15902767E-02);\n" +" _c0013 = VARtex + vec2(-3.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(3.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 8.40164497E-02, 6.88036010E-02, 6.88036010E-02);\n" +" _c0013 = VARtex + vec2(-2.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(2.00000000E+00*_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.35563493E-01, 7.43561909E-02, 7.43561909E-02);\n" +" _c0013 = VARtex + vec2(-_one_x, 0.00000000E+00);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, _c0013);\n" +" _c0015 = VARtex + vec2(_one_x, 0.00000000E+00);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, _c0015);\n" +" _sums1 = _TMP1.xyz + _TMP2.xyz;\n" +" _signal = _signal + _sums1*vec3( 1.75261274E-01, 7.78565630E-02, 7.78565630E-02);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, VARtex);\n" +" _signal = _signal + _TMP3.xyz*vec3( 1.90176547E-01, 7.90523961E-02, 7.90523961E-02);\n" +" _r0021.x = dot(vec3( 1.00000000E+00, 9.55999970E-01, 6.20999992E-01), _signal);\n" +" _r0021.y = dot(vec3( 1.00000000E+00, -2.72000015E-01, -6.47400022E-01), _signal);\n" +" _r0021.z = dot(vec3( 1.00000000E+00, -1.10599995E+00, 1.70459998E+00), _signal);\n" +" _ret_0 = vec4(_r0021.x, _r0021.y, _r0021.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/phosphor.h b/src/video/sdl/shaders/phosphor.h deleted file mode 100644 index ae217f451..000000000 --- a/src/video/sdl/shaders/phosphor.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/*****************************************************************************************/ -/* Phosphor */ -/*****************************************************************************************/ -{ - // vertex shader - "varying vec4 v_texCoord;\n" - - "void main(void) {\n" - " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" - " gl_FrontColor = gl_Color;\n" - " v_texCoord = gl_MultiTexCoord0;\n" - "}", - // fragment shader - "uniform vec2 size_texture;\n" - "uniform vec2 size_screen_emu;\n" - "uniform vec2 size_video_mode;\n" - "uniform float pixel_aspect_ratio;\n" - "uniform float param;\n" - "uniform float full_interpolation;\n" - - "uniform sampler2D texture_scr;\n" - - "varying vec4 v_texCoord;\n" - - "vec3 to_focus(float pixel, float green) {\n" - " pixel = mod(pixel + 3.0, 3.0);\n" - " if (pixel >= 2.0) { // Blue\n" - " return vec3(pixel - 2.0, 0.0, 3.0 - pixel);\n" - " } else if (pixel >= 1.0) { // Green\n" - " return vec3(0.0, green - pixel, pixel - 1.0);\n" - " } else { // Red\n" - " return vec3(1.0 - pixel, pixel, 0.0);\n" - " }\n" - "}\n" - - "void main() {\n" - " float green;" - " vec2 aspect1;\n" - " vec2 aspect2;\n" - - " if (param == 0.0) {\n" - " aspect1 = vec2(size_video_mode.x / pixel_aspect_ratio, size_video_mode.y);\n" - " aspect2 = size_video_mode * (256.0 / size_screen_emu) * 0.5;\n" - " green = 2.50;\n" - " } else {\n" - " aspect1 = size_screen_emu * pixel_aspect_ratio;\n" - " aspect2 = 256.0 * (size_video_mode / size_screen_emu);\n" - " green = 2.10;" - " }\n" - -#include "interpolation.h" - - " float y = mod(v_texCoord.y, 1.0);\n" - " float intensity = exp(-0.2 * y);\n" - - " vec2 one_x = vec2(1.0 / (aspect1.x * 3.0), 0.0);\n" - - " vec3 color = texture2D(texture_scr, pnt.xy).rgb;\n" - " vec3 color_prev = texture2D(texture_scr, pnt.xy - one_x).rgb;\n" - " vec3 color_prev_prev = texture2D(texture_scr, pnt.xy - (2.0 * one_x)).rgb;\n" - - " float pixel_x = 3.0 * (v_texCoord.x * aspect2.x);\n" - - " vec3 focus = to_focus(pixel_x - 0.0, green);\n" - " vec3 focus_prev = to_focus(pixel_x - 1.0, green);\n" - " vec3 focus_prev_prev = to_focus(pixel_x - 2.0, green);\n" - - " vec3 result = 0.8 * color * focus +" - " 0.6 * color_prev * focus_prev +" - " 0.3 * color_prev_prev * focus_prev_prev;\n" - - " result = 2.3 * pow(result, vec3(1.4));\n" - - " vec4 scr = vec4(intensity * result, 1.0);\n" - - " gl_FragColor = scr * gl_Color;\n" - "}" -}, diff --git a/src/video/sdl/shaders/scanline.h b/src/video/sdl/shaders/scanline.h deleted file mode 100644 index bd78b5d80..000000000 --- a/src/video/sdl/shaders/scanline.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/*****************************************************************************************/ -/* Scanline */ -/*****************************************************************************************/ -{ - // vertex shader - "varying vec4 v_texCoord;\n" - - "void main() {\n" - " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" - " gl_FrontColor = gl_Color;\n" - " v_texCoord = gl_MultiTexCoord0;\n" - "}", - // fragment shader - "uniform vec2 size_screen_emu;\n" - "uniform vec2 size_video_mode;\n" - "uniform vec2 size_texture;\n" - "uniform float pixel_aspect_ratio;\n" - "uniform float full_interpolation;\n" - - "uniform sampler2D texture_scr;\n" - - "varying vec4 v_texCoord;\n" - - "const float base_brightness = 0.95;\n" - //"const vec2 sine_comp = vec2(0.05, 0.15);\n" - "const vec2 sine_comp = vec2(0.00, 0.05);\n" - - "void main() {\n" -#include "interpolation.h" - " vec4 c11 = texture2D(texture_scr, pnt);\n" - " vec2 omega = vec2(3.1415, 2.0 * 3.1415 * 256.0);\n" - " vec4 scanline = c11 * (base_brightness + dot(sine_comp * sin(v_texCoord.xy * omega), vec2(1.0)));\n" - " vec4 scr = clamp(scanline, 0.0, 1.0);\n" - " gl_FragColor = scr * gl_Color;\n" - "}" -}, diff --git a/src/video/sdl/shaders/waterpaint/water.h b/src/video/sdl/shaders/waterpaint/water.h new file mode 100644 index 000000000..f8d121bbb --- /dev/null +++ b/src/video/sdl/shaders/waterpaint/water.h @@ -0,0 +1,190 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _oPosition1;\n" +"vec4 _r0013;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _oColor;\n" +" vec2 _oTex;\n" +" _r0013 = VertexCoord.x*MVPMatrix[0];\n" +" _r0013 = _r0013 + VertexCoord.y*MVPMatrix[1];\n" +" _r0013 = _r0013 + VertexCoord.z*MVPMatrix[2];\n" +" _r0013 = _r0013 + VertexCoord.w*MVPMatrix[3];\n" +" _oPosition1 = _r0013;\n" +" _oColor = COLOR;\n" +" _oTex = TexCoord.xy;\n" +" gl_Position = _r0013;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"vec4 _ret_0;\n" +"float _TMP7;\n" +"float _TMP6;\n" +"float _TMP8;\n" +"input_dummy _IN1;\n" +"uniform sampler2D Texture;\n" +"float _TMP20;\n" +"vec2 _diff0021;\n" +"float _dist0021;\n" +"float _TMP30;\n" +"vec2 _diff0031;\n" +"float _dist0031;\n" +"float _TMP40;\n" +"vec2 _diff0041;\n" +"float _dist0041;\n" +"float _TMP50;\n" +"vec2 _diff0051;\n" +"float _dist0051;\n" +"float _TMP60;\n" +"vec2 _diff0061;\n" +"float _dist0061;\n" +"float _TMP70;\n" +"vec2 _diff0071;\n" +"float _dist0071;\n" +"float _TMP80;\n" +"vec2 _diff0081;\n" +"float _dist0081;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec4 _output_dummy;\n" +" vec2 _scale;\n" +" float _res;\n" +" _output_dummy = COMPAT_TEXTURE(Texture, TEX0.xy);\n" +" _scale = (TEX0.xy*TextureSize)/InputSize;\n" +" _diff0021 = _scale - vec2( 6.00000024E-01, 6.99999988E-01);\n" +" _TMP6 = dot(_diff0021, _diff0021);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0021 = 3.00000000E+02*_TMP7;\n" +" _dist0021 = _dist0021 - 1.50000006E-01*float(FrameCount);\n" +" _TMP20 = sin(_dist0021);\n" +" _diff0031 = _scale - vec2( 8.99999976E-01, 8.99999976E-01);\n" +" _TMP6 = dot(_diff0031, _diff0031);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0031 = 3.00000000E+02*_TMP7;\n" +" _dist0031 = _dist0031 - 1.50000006E-01*float(FrameCount);\n" +" _TMP30 = sin(_dist0031);\n" +" _res = _TMP20 + _TMP30;\n" +" _diff0041 = _scale - vec2( -6.00000024E-01, 3.00000012E-01);\n" +" _TMP6 = dot(_diff0041, _diff0041);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0041 = 3.00000000E+02*_TMP7;\n" +" _dist0041 = _dist0041 - 1.50000006E-01*float(FrameCount);\n" +" _TMP40 = sin(_dist0041);\n" +" _res = _res + _TMP40;\n" +" _diff0051 = _scale - vec2( 1.00000001E-01, 4.00000006E-01);\n" +" _TMP6 = dot(_diff0051, _diff0051);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0051 = 3.00000000E+02*_TMP7;\n" +" _dist0051 = _dist0051 - 1.50000006E-01*float(FrameCount);\n" +" _TMP50 = sin(_dist0051);\n" +" _res = _res + _TMP50;\n" +" _diff0061 = _scale - vec2( 1.00000001E-01, 4.00000006E-01);\n" +" _TMP6 = dot(_diff0061, _diff0061);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0061 = 3.00000000E+02*_TMP7;\n" +" _dist0061 = _dist0061 - 1.50000006E-01*float(FrameCount);\n" +" _TMP60 = sin(_dist0061);\n" +" _res = _res + _TMP60;\n" +" _diff0071 = _scale - vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _TMP6 = dot(_diff0071, _diff0071);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0071 = 3.00000000E+02*_TMP7;\n" +" _dist0071 = _dist0071 - 1.50000006E-01*float(FrameCount);\n" +" _TMP70 = sin(_dist0071);\n" +" _res = _res + _TMP70;\n" +" _diff0081 = _scale - vec2( -1.00000000E+00, 1.00000000E+00);\n" +" _TMP6 = dot(_diff0081, _diff0081);\n" +" _TMP8 = inversesqrt(_TMP6);\n" +" _TMP7 = 1.00000000E+00/_TMP8;\n" +" _dist0081 = 3.00000000E+02*_TMP7;\n" +" _dist0081 = _dist0081 - 1.50000006E-01*float(FrameCount);\n" +" _TMP80 = sin(_dist0081);\n" +" _res = _res + _TMP80;\n" +" _ret_0 = _output_dummy*(8.99999976E-01 + 1.20000001E-02*_res);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/windowed/jinc2-sharper.h b/src/video/sdl/shaders/windowed/jinc2-sharper.h new file mode 100644 index 000000000..8089b41c8 --- /dev/null +++ b/src/video/sdl/shaders/windowed/jinc2-sharper.h @@ -0,0 +1,451 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord;\n" +"};\n" +"out_vertex _ret_0;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _ret_0._position1 = _r0008;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord = TexCoord.xy;\n" +" gl_Position = _r0008;\n" +" COL0 = COLOR;\n" +" TEX0.xy = TexCoord.xy;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING float _frame_rotation;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +" float _frame_count;\n" +" float _frame_direction;\n" +" float _frame_rotation;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color1;\n" +" vec2 _texCoord;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP45;\n" +"float _TMP37;\n" +"vec3 _TMP44;\n" +"vec3 _TMP43;\n" +"vec3 _TMP42;\n" +"vec3 _TMP41;\n" +"vec4 _TMP32;\n" +"vec4 _TMP31;\n" +"vec4 _TMP30;\n" +"vec4 _TMP29;\n" +"vec4 _TMP28;\n" +"vec4 _TMP27;\n" +"vec4 _TMP26;\n" +"vec4 _TMP25;\n" +"vec4 _TMP24;\n" +"vec4 _TMP23;\n" +"vec4 _TMP22;\n" +"vec4 _TMP21;\n" +"vec4 _TMP20;\n" +"vec4 _TMP19;\n" +"vec4 _TMP18;\n" +"vec4 _TMP17;\n" +"vec4 _TMP40;\n" +"vec4 _TMP39;\n" +"float _TMP50;\n" +"float _TMP49;\n" +"float _TMP48;\n" +"float _TMP47;\n" +"float _TMP38;\n" +"float _TMP46;\n" +"vec2 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _x0060;\n" +"float _TMP61;\n" +"vec2 _v0062;\n" +"vec2 _pt20062;\n" +"float _TMP69;\n" +"vec2 _v0070;\n" +"vec2 _pt20070;\n" +"float _TMP77;\n" +"vec2 _v0078;\n" +"vec2 _pt20078;\n" +"float _TMP85;\n" +"vec2 _v0086;\n" +"vec2 _pt20086;\n" +"vec4 _x0094;\n" +"vec4 _res0094;\n" +"vec4 _x0096;\n" +"vec4 _x0106;\n" +"float _TMP115;\n" +"vec2 _v0116;\n" +"vec2 _pt20116;\n" +"float _TMP123;\n" +"vec2 _v0124;\n" +"float _TMP131;\n" +"vec2 _v0132;\n" +"vec2 _pt20132;\n" +"float _TMP139;\n" +"vec2 _v0140;\n" +"vec2 _pt20140;\n" +"vec4 _x0148;\n" +"vec4 _res0148;\n" +"vec4 _x0150;\n" +"vec4 _x0160;\n" +"float _TMP169;\n" +"vec2 _v0170;\n" +"vec2 _pt20170;\n" +"float _TMP177;\n" +"vec2 _v0178;\n" +"vec2 _pt20178;\n" +"float _TMP185;\n" +"vec2 _v0186;\n" +"vec2 _pt20186;\n" +"float _TMP193;\n" +"vec2 _v0194;\n" +"vec2 _pt20194;\n" +"vec4 _x0202;\n" +"vec4 _res0202;\n" +"vec4 _x0204;\n" +"vec4 _x0214;\n" +"float _TMP223;\n" +"vec2 _v0224;\n" +"vec2 _pt20224;\n" +"float _TMP231;\n" +"vec2 _v0232;\n" +"vec2 _pt20232;\n" +"float _TMP239;\n" +"vec2 _v0240;\n" +"vec2 _pt20240;\n" +"float _TMP247;\n" +"vec2 _v0248;\n" +"vec2 _pt20248;\n" +"vec4 _x0256;\n" +"vec4 _res0256;\n" +"vec4 _x0258;\n" +"vec4 _x0268;\n" +"vec2 _c0278;\n" +"vec2 _c0280;\n" +"vec2 _c0282;\n" +"vec2 _c0284;\n" +"vec2 _c0286;\n" +"vec2 _c0290;\n" +"vec2 _c0292;\n" +"vec2 _c0294;\n" +"vec2 _c0296;\n" +"vec2 _c0298;\n" +"vec2 _c0300;\n" +"vec2 _c0302;\n" +"vec2 _c0304;\n" +"vec2 _c0306;\n" +"vec2 _c0308;\n" +"vec3 _TMP309;\n" +"vec3 _TMP317;\n" +"vec3 _r0326;\n" +"vec3 _r0328;\n" +"vec3 _r0330;\n" +"vec3 _r0332;\n" +"vec4 _r0334;\n" +"vec3 _TMP345;\n" +"COMPAT_VARYING vec4 TEX0;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" vec3 _color;\n" +" vec2 _dx;\n" +" vec2 _dy;\n" +" vec2 _pc;\n" +" vec2 _tc;\n" +" _pc = TEX0.xy*TextureSize;\n" +" _x0060 = _pc - vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _TMP0 = floor(_x0060);\n" +" _tc = _TMP0 + vec2( 5.00000000E-01, 5.00000000E-01);\n" +" _pt20062 = (_tc - vec2( 1.00000000E+00, 0.00000000E+00)) - vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0062 = _pt20062 - _pc;\n" +" _TMP38 = dot(_v0062, _v0062);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP61 = 1.00000000E+00/_TMP46;\n" +" _pt20070 = _tc - vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0070 = _pt20070 - _pc;\n" +" _TMP38 = dot(_v0070, _v0070);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP69 = 1.00000000E+00/_TMP46;\n" +" _pt20078 = (_tc + vec2( 1.00000000E+00, 0.00000000E+00)) - vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0078 = _pt20078 - _pc;\n" +" _TMP38 = dot(_v0078, _v0078);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP77 = 1.00000000E+00/_TMP46;\n" +" _pt20086 = (_tc + vec2( 2.00000000E+00, 0.00000000E+00)) - vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0086 = _pt20086 - _pc;\n" +" _TMP38 = dot(_v0086, _v0086);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP85 = 1.00000000E+00/_TMP46;\n" +" _x0094 = vec4(_TMP61, _TMP69, _TMP77, _TMP85);\n" +" _x0096 = _x0094*1.31946886E+00;\n" +" _TMP47 = sin(_x0096.x);\n" +" _TMP48 = sin(_x0096.y);\n" +" _TMP49 = sin(_x0096.z);\n" +" _TMP50 = sin(_x0096.w);\n" +" _TMP39 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _x0106 = _x0094*2.89026546E+00;\n" +" _TMP47 = sin(_x0106.x);\n" +" _TMP48 = sin(_x0106.y);\n" +" _TMP49 = sin(_x0106.z);\n" +" _TMP50 = sin(_x0106.w);\n" +" _TMP40 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _res0094 = vec4(_x0094.x == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0094*_x0094)).x, _x0094.y == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0094*_x0094)).y, _x0094.z == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0094*_x0094)).z, _x0094.w == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0094*_x0094)).w);\n" +" _pt20116 = _tc - vec2( 1.00000000E+00, 0.00000000E+00);\n" +" _v0116 = _pt20116 - _pc;\n" +" _TMP38 = dot(_v0116, _v0116);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP115 = 1.00000000E+00/_TMP46;\n" +" _v0124 = _tc - _pc;\n" +" _TMP38 = dot(_v0124, _v0124);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP123 = 1.00000000E+00/_TMP46;\n" +" _pt20132 = _tc + vec2( 1.00000000E+00, 0.00000000E+00);\n" +" _v0132 = _pt20132 - _pc;\n" +" _TMP38 = dot(_v0132, _v0132);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP131 = 1.00000000E+00/_TMP46;\n" +" _pt20140 = _tc + vec2( 2.00000000E+00, 0.00000000E+00);\n" +" _v0140 = _pt20140 - _pc;\n" +" _TMP38 = dot(_v0140, _v0140);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP139 = 1.00000000E+00/_TMP46;\n" +" _x0148 = vec4(_TMP115, _TMP123, _TMP131, _TMP139);\n" +" _x0150 = _x0148*1.31946886E+00;\n" +" _TMP47 = sin(_x0150.x);\n" +" _TMP48 = sin(_x0150.y);\n" +" _TMP49 = sin(_x0150.z);\n" +" _TMP50 = sin(_x0150.w);\n" +" _TMP39 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _x0160 = _x0148*2.89026546E+00;\n" +" _TMP47 = sin(_x0160.x);\n" +" _TMP48 = sin(_x0160.y);\n" +" _TMP49 = sin(_x0160.z);\n" +" _TMP50 = sin(_x0160.w);\n" +" _TMP40 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _res0148 = vec4(_x0148.x == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0148*_x0148)).x, _x0148.y == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0148*_x0148)).y, _x0148.z == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0148*_x0148)).z, _x0148.w == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0148*_x0148)).w);\n" +" _pt20170 = (_tc - vec2( 1.00000000E+00, 0.00000000E+00)) + vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0170 = _pt20170 - _pc;\n" +" _TMP38 = dot(_v0170, _v0170);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP169 = 1.00000000E+00/_TMP46;\n" +" _pt20178 = _tc + vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0178 = _pt20178 - _pc;\n" +" _TMP38 = dot(_v0178, _v0178);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP177 = 1.00000000E+00/_TMP46;\n" +" _pt20186 = _tc + vec2( 1.00000000E+00, 0.00000000E+00) + vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0186 = _pt20186 - _pc;\n" +" _TMP38 = dot(_v0186, _v0186);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP185 = 1.00000000E+00/_TMP46;\n" +" _pt20194 = _tc + vec2( 2.00000000E+00, 0.00000000E+00) + vec2( 0.00000000E+00, 1.00000000E+00);\n" +" _v0194 = _pt20194 - _pc;\n" +" _TMP38 = dot(_v0194, _v0194);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP193 = 1.00000000E+00/_TMP46;\n" +" _x0202 = vec4(_TMP169, _TMP177, _TMP185, _TMP193);\n" +" _x0204 = _x0202*1.31946886E+00;\n" +" _TMP47 = sin(_x0204.x);\n" +" _TMP48 = sin(_x0204.y);\n" +" _TMP49 = sin(_x0204.z);\n" +" _TMP50 = sin(_x0204.w);\n" +" _TMP39 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _x0214 = _x0202*2.89026546E+00;\n" +" _TMP47 = sin(_x0214.x);\n" +" _TMP48 = sin(_x0214.y);\n" +" _TMP49 = sin(_x0214.z);\n" +" _TMP50 = sin(_x0214.w);\n" +" _TMP40 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _res0202 = vec4(_x0202.x == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0202*_x0202)).x, _x0202.y == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0202*_x0202)).y, _x0202.z == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0202*_x0202)).z, _x0202.w == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0202*_x0202)).w);\n" +" _pt20224 = (_tc - vec2( 1.00000000E+00, 0.00000000E+00)) + vec2( 0.00000000E+00, 2.00000000E+00);\n" +" _v0224 = _pt20224 - _pc;\n" +" _TMP38 = dot(_v0224, _v0224);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP223 = 1.00000000E+00/_TMP46;\n" +" _pt20232 = _tc + vec2( 0.00000000E+00, 2.00000000E+00);\n" +" _v0232 = _pt20232 - _pc;\n" +" _TMP38 = dot(_v0232, _v0232);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP231 = 1.00000000E+00/_TMP46;\n" +" _pt20240 = _tc + vec2( 1.00000000E+00, 0.00000000E+00) + vec2( 0.00000000E+00, 2.00000000E+00);\n" +" _v0240 = _pt20240 - _pc;\n" +" _TMP38 = dot(_v0240, _v0240);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP239 = 1.00000000E+00/_TMP46;\n" +" _pt20248 = _tc + vec2( 2.00000000E+00, 0.00000000E+00) + vec2( 0.00000000E+00, 2.00000000E+00);\n" +" _v0248 = _pt20248 - _pc;\n" +" _TMP38 = dot(_v0248, _v0248);\n" +" _TMP46 = inversesqrt(_TMP38);\n" +" _TMP247 = 1.00000000E+00/_TMP46;\n" +" _x0256 = vec4(_TMP223, _TMP231, _TMP239, _TMP247);\n" +" _x0258 = _x0256*1.31946886E+00;\n" +" _TMP47 = sin(_x0258.x);\n" +" _TMP48 = sin(_x0258.y);\n" +" _TMP49 = sin(_x0258.z);\n" +" _TMP50 = sin(_x0258.w);\n" +" _TMP39 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _x0268 = _x0256*2.89026546E+00;\n" +" _TMP47 = sin(_x0268.x);\n" +" _TMP48 = sin(_x0268.y);\n" +" _TMP49 = sin(_x0268.z);\n" +" _TMP50 = sin(_x0268.w);\n" +" _TMP40 = vec4(_TMP47, _TMP48, _TMP49, _TMP50);\n" +" _res0256 = vec4(_x0256.x == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0256*_x0256)).x, _x0256.y == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0256*_x0256)).y, _x0256.z == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0256*_x0256)).z, _x0256.w == 0.00000000E+00 ? 3.81361532E+00 : ((_TMP39*_TMP40)/(_x0256*_x0256)).w);\n" +" _dx = vec2( 1.00000000E+00, 0.00000000E+00)/TextureSize;\n" +" _dy = vec2( 0.00000000E+00, 1.00000000E+00)/TextureSize;\n" +" _tc = _tc/TextureSize;\n" +" _c0278 = (_tc - _dx) - _dy;\n" +" _TMP17 = COMPAT_TEXTURE(Texture, _c0278);\n" +" _c0280 = _tc - _dy;\n" +" _TMP18 = COMPAT_TEXTURE(Texture, _c0280);\n" +" _c0282 = (_tc + _dx) - _dy;\n" +" _TMP19 = COMPAT_TEXTURE(Texture, _c0282);\n" +" _c0284 = (_tc + 2.00000000E+00*_dx) - _dy;\n" +" _TMP20 = COMPAT_TEXTURE(Texture, _c0284);\n" +" _c0286 = _tc - _dx;\n" +" _TMP21 = COMPAT_TEXTURE(Texture, _c0286);\n" +" _TMP22 = COMPAT_TEXTURE(Texture, _tc);\n" +" _c0290 = _tc + _dx;\n" +" _TMP23 = COMPAT_TEXTURE(Texture, _c0290);\n" +" _c0292 = _tc + 2.00000000E+00*_dx;\n" +" _TMP24 = COMPAT_TEXTURE(Texture, _c0292);\n" +" _c0294 = (_tc - _dx) + _dy;\n" +" _TMP25 = COMPAT_TEXTURE(Texture, _c0294);\n" +" _c0296 = _tc + _dy;\n" +" _TMP26 = COMPAT_TEXTURE(Texture, _c0296);\n" +" _c0298 = _tc + _dx + _dy;\n" +" _TMP27 = COMPAT_TEXTURE(Texture, _c0298);\n" +" _c0300 = _tc + 2.00000000E+00*_dx + _dy;\n" +" _TMP28 = COMPAT_TEXTURE(Texture, _c0300);\n" +" _c0302 = (_tc - _dx) + 2.00000000E+00*_dy;\n" +" _TMP29 = COMPAT_TEXTURE(Texture, _c0302);\n" +" _c0304 = _tc + 2.00000000E+00*_dy;\n" +" _TMP30 = COMPAT_TEXTURE(Texture, _c0304);\n" +" _c0306 = _tc + _dx + 2.00000000E+00*_dy;\n" +" _TMP31 = COMPAT_TEXTURE(Texture, _c0306);\n" +" _c0308 = _tc + 2.00000000E+00*_dx + 2.00000000E+00*_dy;\n" +" _TMP32 = COMPAT_TEXTURE(Texture, _c0308);\n" +" _TMP41 = min(_TMP26.xyz, _TMP27.xyz);\n" +" _TMP42 = min(_TMP23.xyz, _TMP41);\n" +" _TMP309 = min(_TMP22.xyz, _TMP42);\n" +" _TMP43 = max(_TMP26.xyz, _TMP27.xyz);\n" +" _TMP44 = max(_TMP23.xyz, _TMP43);\n" +" _TMP317 = max(_TMP22.xyz, _TMP44);\n" +" _r0326 = _res0094.x*_TMP17.xyz;\n" +" _r0326 = _r0326 + _res0094.y*_TMP18.xyz;\n" +" _r0326 = _r0326 + _res0094.z*_TMP19.xyz;\n" +" _r0326 = _r0326 + _res0094.w*_TMP20.xyz;\n" +" _r0328 = _res0148.x*_TMP21.xyz;\n" +" _r0328 = _r0328 + _res0148.y*_TMP22.xyz;\n" +" _r0328 = _r0328 + _res0148.z*_TMP23.xyz;\n" +" _r0328 = _r0328 + _res0148.w*_TMP24.xyz;\n" +" _color = _r0326 + _r0328;\n" +" _r0330 = _res0202.x*_TMP25.xyz;\n" +" _r0330 = _r0330 + _res0202.y*_TMP26.xyz;\n" +" _r0330 = _r0330 + _res0202.z*_TMP27.xyz;\n" +" _r0330 = _r0330 + _res0202.w*_TMP28.xyz;\n" +" _color = _color + _r0330;\n" +" _r0332 = _res0256.x*_TMP29.xyz;\n" +" _r0332 = _r0332 + _res0256.y*_TMP30.xyz;\n" +" _r0332 = _r0332 + _res0256.z*_TMP31.xyz;\n" +" _r0332 = _r0332 + _res0256.w*_TMP32.xyz;\n" +" _color = _color + _r0332;\n" +" _r0334.x = dot(_res0094, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _r0334.y = dot(_res0148, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _r0334.z = dot(_res0202, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _r0334.w = dot(_res0256, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _TMP37 = dot(_r0334, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));\n" +" _color = _color/_TMP37;\n" +" _TMP45 = min(_TMP317, _color);\n" +" _TMP345 = max(_TMP309, _TMP45);\n" +" _color = _color + 8.00000012E-01*(_TMP345 - _color);\n" +" _ret_0 = vec4(_color.x, _color.y, _color.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shaders/xbr/legacy/2xbr-v3.8c.h b/src/video/sdl/shaders/xbr/legacy/2xbr-v3.8c.h new file mode 100644 index 000000000..c1bbdc2bb --- /dev/null +++ b/src/video/sdl/shaders/xbr/legacy/2xbr-v3.8c.h @@ -0,0 +1,493 @@ +{ +"// GLSL shader autogenerated by cg2glsl.py.\n" +"#if defined(VERTEX)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING out\n" +"#define COMPAT_ATTRIBUTE in\n" +"#define COMPAT_TEXTURE texture\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define COMPAT_ATTRIBUTE attribute\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord2;\n" +"COMPAT_VARYING vec4 _color1;\n" +"COMPAT_VARYING vec4 _position1;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _position1;\n" +" vec4 _color1;\n" +" vec2 _texCoord2;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"out_vertex _ret_0;\n" +"input_dummy _IN1;\n" +"vec4 _r0008;\n" +"COMPAT_ATTRIBUTE vec4 VertexCoord;\n" +"COMPAT_ATTRIBUTE vec4 COLOR;\n" +"COMPAT_ATTRIBUTE vec4 TexCoord;\n" +"COMPAT_VARYING vec4 COL0;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform mat4 MVPMatrix;\n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" out_vertex _OUT;\n" +" vec2 _ps;\n" +" vec2 _texCoord;\n" +" _r0008 = VertexCoord.x*MVPMatrix[0];\n" +" _r0008 = _r0008 + VertexCoord.y*MVPMatrix[1];\n" +" _r0008 = _r0008 + VertexCoord.z*MVPMatrix[2];\n" +" _r0008 = _r0008 + VertexCoord.w*MVPMatrix[3];\n" +" _ps = vec2(1.00000000E+00/TextureSize.x, 1.00000000E+00/TextureSize.y);\n" +" _texCoord = TexCoord.xy + vec2( 1.00000001E-07, 1.00000001E-07);\n" +" _OUT._t1 = _texCoord.xxxy + vec4(-_ps.x, 0.00000000E+00, _ps.x, -2.00000000E+00*_ps.y);\n" +" _OUT._t2 = _texCoord.xxxy + vec4(-_ps.x, 0.00000000E+00, _ps.x, -_ps.y);\n" +" _OUT._t3 = _texCoord.xxxy + vec4(-_ps.x, 0.00000000E+00, _ps.x, 0.00000000E+00);\n" +" _OUT._t4 = _texCoord.xxxy + vec4(-_ps.x, 0.00000000E+00, _ps.x, _ps.y);\n" +" _OUT._t5 = _texCoord.xxxy + vec4(-_ps.x, 0.00000000E+00, _ps.x, 2.00000000E+00*_ps.y);\n" +" _OUT._t6 = _texCoord.xyyy + vec4(-2.00000000E+00*_ps.x, -_ps.y, 0.00000000E+00, _ps.y);\n" +" _OUT._t7 = _texCoord.xyyy + vec4(2.00000000E+00*_ps.x, -_ps.y, 0.00000000E+00, _ps.y);\n" +" _ret_0._position1 = _r0008;\n" +" _ret_0._color1 = COLOR;\n" +" _ret_0._texCoord2 = _texCoord;\n" +" _ret_0._t1 = _OUT._t1;\n" +" _ret_0._t2 = _OUT._t2;\n" +" _ret_0._t3 = _OUT._t3;\n" +" _ret_0._t4 = _OUT._t4;\n" +" _ret_0._t5 = _OUT._t5;\n" +" _ret_0._t6 = _OUT._t6;\n" +" _ret_0._t7 = _OUT._t7;\n" +" gl_Position = _r0008;\n" +" COL0 = COLOR;\n" +" TEX0.xy = _texCoord;\n" +" TEX1 = _OUT._t1;\n" +" TEX2 = _OUT._t2;\n" +" TEX3 = _OUT._t3;\n" +" TEX4 = _OUT._t4;\n" +" TEX5 = _OUT._t5;\n" +" TEX6 = _OUT._t6;\n" +" TEX7 = _OUT._t7;\n" +" return;\n" +" COL0 = _ret_0._color1;\n" +" TEX0.xy = _ret_0._texCoord2;\n" +" TEX1 = _ret_0._t1;\n" +" TEX2 = _ret_0._t2;\n" +" TEX3 = _ret_0._t3;\n" +" TEX4 = _ret_0._t4;\n" +" TEX5 = _ret_0._t5;\n" +" TEX6 = _ret_0._t6;\n" +" TEX7 = _ret_0._t7;\n" +"} \n" +"#elif defined(FRAGMENT)\n" +"\n" +"#if __VERSION__ >= 130\n" +"#define COMPAT_VARYING in\n" +"#define COMPAT_TEXTURE texture\n" +"out vec4 FragColor;\n" +"#else\n" +"#define COMPAT_VARYING varying\n" +"#define FragColor gl_FragColor\n" +"#define COMPAT_TEXTURE texture2D\n" +"#endif\n" +"\n" +"#ifdef GL_ES\n" +"#ifdef GL_FRAGMENT_PRECISION_HIGH\n" +"precision highp float;\n" +"#else\n" +"precision mediump float;\n" +"#endif\n" +"#define COMPAT_PRECISION mediump\n" +"#else\n" +"#define COMPAT_PRECISION\n" +"#endif\n" +"COMPAT_VARYING vec4 _t7;\n" +"COMPAT_VARYING vec4 _t6;\n" +"COMPAT_VARYING vec4 _t5;\n" +"COMPAT_VARYING vec4 _t4;\n" +"COMPAT_VARYING vec4 _t3;\n" +"COMPAT_VARYING vec4 _t2;\n" +"COMPAT_VARYING vec4 _t1;\n" +"COMPAT_VARYING vec2 _texCoord;\n" +"COMPAT_VARYING vec4 _color;\n" +"struct input_dummy {\n" +" vec2 _video_size;\n" +" vec2 _texture_size;\n" +" vec2 _output_dummy_size;\n" +"};\n" +"struct out_vertex {\n" +" vec4 _color;\n" +" vec2 _texCoord;\n" +" vec4 _t1;\n" +" vec4 _t2;\n" +" vec4 _t3;\n" +" vec4 _t4;\n" +" vec4 _t5;\n" +" vec4 _t6;\n" +" vec4 _t7;\n" +"};\n" +"vec4 _ret_0;\n" +"vec3 _TMP48;\n" +"vec3 _TMP46;\n" +"vec3 _TMP44;\n" +"vec3 _TMP42;\n" +"vec3 _TMP47;\n" +"vec3 _TMP45;\n" +"vec3 _TMP43;\n" +"vec3 _TMP41;\n" +"vec4 _TMP40;\n" +"vec4 _TMP33;\n" +"vec4 _TMP32;\n" +"vec4 _TMP55;\n" +"bvec4 _TMP31;\n" +"bvec4 _TMP30;\n" +"bvec4 _TMP29;\n" +"bvec4 _TMP28;\n" +"bvec4 _TMP27;\n" +"bvec4 _TMP26;\n" +"bvec4 _TMP25;\n" +"bvec4 _TMP24;\n" +"bvec4 _TMP23;\n" +"bvec4 _TMP22;\n" +"bvec4 _TMP21;\n" +"vec4 _TMP20;\n" +"vec4 _TMP19;\n" +"vec4 _TMP18;\n" +"vec4 _TMP17;\n" +"vec4 _TMP16;\n" +"vec4 _TMP15;\n" +"vec4 _TMP14;\n" +"vec4 _TMP13;\n" +"vec4 _TMP12;\n" +"vec4 _TMP11;\n" +"vec4 _TMP10;\n" +"vec4 _TMP9;\n" +"vec4 _TMP8;\n" +"vec4 _TMP7;\n" +"vec4 _TMP6;\n" +"vec4 _TMP5;\n" +"vec4 _TMP4;\n" +"vec4 _TMP3;\n" +"vec4 _TMP2;\n" +"vec4 _TMP1;\n" +"vec4 _TMP0;\n" +"uniform sampler2D Texture;\n" +"input_dummy _IN1;\n" +"vec2 _x0070;\n" +"vec4 _r0114;\n" +"vec4 _r0124;\n" +"vec4 _r0134;\n" +"vec4 _r0144;\n" +"vec4 _r0154;\n" +"vec4 _r0164;\n" +"vec4 _TMP175;\n" +"vec4 _a0178;\n" +"vec4 _TMP181;\n" +"vec4 _a0184;\n" +"vec4 _TMP187;\n" +"vec4 _a0190;\n" +"vec4 _TMP193;\n" +"vec4 _a0196;\n" +"vec4 _TMP199;\n" +"vec4 _a0202;\n" +"vec4 _TMP205;\n" +"vec4 _a0208;\n" +"vec4 _TMP211;\n" +"vec4 _a0214;\n" +"vec4 _TMP217;\n" +"vec4 _a0220;\n" +"vec4 _TMP223;\n" +"vec4 _a0226;\n" +"vec4 _TMP229;\n" +"vec4 _a0232;\n" +"vec4 _TMP235;\n" +"vec4 _a0238;\n" +"vec4 _x0240;\n" +"vec4 _TMP241;\n" +"vec4 _x0248;\n" +"vec4 _TMP249;\n" +"vec4 _x0256;\n" +"vec4 _TMP257;\n" +"vec4 _TMP265;\n" +"vec4 _a0268;\n" +"vec4 _TMP269;\n" +"vec4 _a0272;\n" +"vec4 _TMP273;\n" +"vec4 _a0276;\n" +"vec4 _TMP277;\n" +"vec4 _a0280;\n" +"vec4 _TMP281;\n" +"vec4 _a0284;\n" +"vec4 _TMP287;\n" +"vec4 _a0290;\n" +"vec4 _TMP291;\n" +"vec4 _a0294;\n" +"vec4 _TMP295;\n" +"vec4 _a0298;\n" +"vec4 _TMP299;\n" +"vec4 _a0302;\n" +"vec4 _TMP303;\n" +"vec4 _a0306;\n" +"vec4 _TMP307;\n" +"vec4 _a0310;\n" +"vec4 _TMP311;\n" +"vec4 _a0314;\n" +"vec4 _TMP315;\n" +"vec4 _a0318;\n" +"vec4 _TMP319;\n" +"vec4 _a0322;\n" +"vec4 _TMP323;\n" +"vec4 _a0326;\n" +"vec4 _TMP327;\n" +"vec4 _a0330;\n" +"float _t0336;\n" +"float _t0340;\n" +"float _t0344;\n" +"float _t0348;\n" +"vec4 _r0352;\n" +"vec4 _TMP361;\n" +"vec4 _a0364;\n" +"COMPAT_VARYING vec4 TEX0;\n" +"COMPAT_VARYING vec4 TEX1;\n" +"COMPAT_VARYING vec4 TEX2;\n" +"COMPAT_VARYING vec4 TEX3;\n" +"COMPAT_VARYING vec4 TEX4;\n" +"COMPAT_VARYING vec4 TEX5;\n" +"COMPAT_VARYING vec4 TEX6;\n" +"COMPAT_VARYING vec4 TEX7;\n" +" \n" +"uniform int FrameDirection;\n" +"uniform int FrameCount;\n" +"uniform COMPAT_PRECISION vec2 OutputSize;\n" +"uniform COMPAT_PRECISION vec2 TextureSize;\n" +"uniform COMPAT_PRECISION vec2 InputSize;\n" +"void main()\n" +"{\n" +" bvec4 _edr;\n" +" bvec4 _edr_left;\n" +" bvec4 _edr_up;\n" +" bvec4 _px;\n" +" bvec4 _interp_restriction_lv1;\n" +" bvec4 _interp_restriction_lv2_left;\n" +" bvec4 _interp_restriction_lv2_up;\n" +" vec4 _fx;\n" +" vec4 _fx_left;\n" +" vec4 _fx_up;\n" +" vec2 _fp;\n" +" vec4 _fx45;\n" +" vec4 _fx30;\n" +" vec4 _fx60;\n" +" vec4 _maximo;\n" +" vec3 _res;\n" +" float _mx;\n" +" _x0070 = TEX0.xy*TextureSize;\n" +" _fp = fract(_x0070);\n" +" _TMP0 = COMPAT_TEXTURE(Texture, TEX1.xw);\n" +" _TMP1 = COMPAT_TEXTURE(Texture, TEX1.yw);\n" +" _TMP2 = COMPAT_TEXTURE(Texture, TEX1.zw);\n" +" _TMP3 = COMPAT_TEXTURE(Texture, TEX2.xw);\n" +" _TMP4 = COMPAT_TEXTURE(Texture, TEX2.yw);\n" +" _TMP5 = COMPAT_TEXTURE(Texture, TEX2.zw);\n" +" _TMP6 = COMPAT_TEXTURE(Texture, TEX3.xw);\n" +" _TMP7 = COMPAT_TEXTURE(Texture, TEX3.yw);\n" +" _TMP8 = COMPAT_TEXTURE(Texture, TEX3.zw);\n" +" _TMP9 = COMPAT_TEXTURE(Texture, TEX4.xw);\n" +" _TMP10 = COMPAT_TEXTURE(Texture, TEX4.yw);\n" +" _TMP11 = COMPAT_TEXTURE(Texture, TEX4.zw);\n" +" _TMP12 = COMPAT_TEXTURE(Texture, TEX5.xw);\n" +" _TMP13 = COMPAT_TEXTURE(Texture, TEX5.yw);\n" +" _TMP14 = COMPAT_TEXTURE(Texture, TEX5.zw);\n" +" _TMP15 = COMPAT_TEXTURE(Texture, TEX6.xy);\n" +" _TMP16 = COMPAT_TEXTURE(Texture, TEX6.xz);\n" +" _TMP17 = COMPAT_TEXTURE(Texture, TEX6.xw);\n" +" _TMP18 = COMPAT_TEXTURE(Texture, TEX7.xy);\n" +" _TMP19 = COMPAT_TEXTURE(Texture, TEX7.xz);\n" +" _TMP20 = COMPAT_TEXTURE(Texture, TEX7.xw);\n" +" _r0114.x = dot(_TMP4.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0114.y = dot(_TMP6.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0114.z = dot(_TMP10.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0114.w = dot(_TMP8.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0124.x = dot(_TMP5.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0124.y = dot(_TMP3.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0124.z = dot(_TMP9.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0124.w = dot(_TMP11.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0134.x = dot(_TMP7.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0134.y = dot(_TMP7.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0134.z = dot(_TMP7.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0134.w = dot(_TMP7.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0144.x = dot(_TMP20.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0144.y = dot(_TMP2.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0144.z = dot(_TMP15.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0144.w = dot(_TMP12.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0154.x = dot(_TMP14.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0154.y = dot(_TMP18.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0154.z = dot(_TMP0.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0154.w = dot(_TMP17.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0164.x = dot(_TMP13.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0164.y = dot(_TMP19.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0164.z = dot(_TMP1.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0164.w = dot(_TMP16.xyz, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _fx = vec4( 1.00000000E+00, -1.00000000E+00, -1.00000000E+00, 1.00000000E+00)*_fp.y + vec4( 1.00000000E+00, 1.00000000E+00, -1.00000000E+00, -1.00000000E+00)*_fp.x;\n" +" _fx_left = vec4( 1.00000000E+00, -1.00000000E+00, -1.00000000E+00, 1.00000000E+00)*_fp.y + vec4( 5.00000000E-01, 2.00000000E+00, -5.00000000E-01, -2.00000000E+00)*_fp.x;\n" +" _fx_up = vec4( 1.00000000E+00, -1.00000000E+00, -1.00000000E+00, 1.00000000E+00)*_fp.y + vec4( 2.00000000E+00, 5.00000000E-01, -2.00000000E+00, -5.00000000E-01)*_fp.x;\n" +" _a0178 = _r0114.wxyz - _r0114;\n" +" _TMP175 = abs(_a0178);\n" +" _TMP21 = bvec4(_TMP175.x < 1.50000000E+01, _TMP175.y < 1.50000000E+01, _TMP175.z < 1.50000000E+01, _TMP175.w < 1.50000000E+01);\n" +" _a0184 = _r0114.wxyz - _r0124;\n" +" _TMP181 = abs(_a0184);\n" +" _TMP22 = bvec4(_TMP181.x < 1.50000000E+01, _TMP181.y < 1.50000000E+01, _TMP181.z < 1.50000000E+01, _TMP181.w < 1.50000000E+01);\n" +" _a0190 = _r0114.zwxy - _r0114.yzwx;\n" +" _TMP187 = abs(_a0190);\n" +" _TMP23 = bvec4(_TMP187.x < 1.50000000E+01, _TMP187.y < 1.50000000E+01, _TMP187.z < 1.50000000E+01, _TMP187.w < 1.50000000E+01);\n" +" _a0196 = _r0114.zwxy - _r0124.zwxy;\n" +" _TMP193 = abs(_a0196);\n" +" _TMP24 = bvec4(_TMP193.x < 1.50000000E+01, _TMP193.y < 1.50000000E+01, _TMP193.z < 1.50000000E+01, _TMP193.w < 1.50000000E+01);\n" +" _a0202 = _r0134 - _r0124.wxyz;\n" +" _TMP199 = abs(_a0202);\n" +" _TMP25 = bvec4(_TMP199.x < 1.50000000E+01, _TMP199.y < 1.50000000E+01, _TMP199.z < 1.50000000E+01, _TMP199.w < 1.50000000E+01);\n" +" _a0208 = _r0114.wxyz - _r0164.yzwx;\n" +" _TMP205 = abs(_a0208);\n" +" _TMP26 = bvec4(_TMP205.x < 1.50000000E+01, _TMP205.y < 1.50000000E+01, _TMP205.z < 1.50000000E+01, _TMP205.w < 1.50000000E+01);\n" +" _a0214 = _r0114.wxyz - _r0144;\n" +" _TMP211 = abs(_a0214);\n" +" _TMP27 = bvec4(_TMP211.x < 1.50000000E+01, _TMP211.y < 1.50000000E+01, _TMP211.z < 1.50000000E+01, _TMP211.w < 1.50000000E+01);\n" +" _a0220 = _r0114.zwxy - _r0164;\n" +" _TMP217 = abs(_a0220);\n" +" _TMP28 = bvec4(_TMP217.x < 1.50000000E+01, _TMP217.y < 1.50000000E+01, _TMP217.z < 1.50000000E+01, _TMP217.w < 1.50000000E+01);\n" +" _a0226 = _r0114.zwxy - _r0154;\n" +" _TMP223 = abs(_a0226);\n" +" _TMP29 = bvec4(_TMP223.x < 1.50000000E+01, _TMP223.y < 1.50000000E+01, _TMP223.z < 1.50000000E+01, _TMP223.w < 1.50000000E+01);\n" +" _a0232 = _r0134 - _r0124.zwxy;\n" +" _TMP229 = abs(_a0232);\n" +" _TMP30 = bvec4(_TMP229.x < 1.50000000E+01, _TMP229.y < 1.50000000E+01, _TMP229.z < 1.50000000E+01, _TMP229.w < 1.50000000E+01);\n" +" _a0238 = _r0134 - _r0124;\n" +" _TMP235 = abs(_a0238);\n" +" _TMP31 = bvec4(_TMP235.x < 1.50000000E+01, _TMP235.y < 1.50000000E+01, _TMP235.z < 1.50000000E+01, _TMP235.w < 1.50000000E+01);\n" +" _interp_restriction_lv1 = bvec4(_r0134.x != _r0114.w && _r0134.x != _r0114.z && (!_TMP21.x && !_TMP22.x || !_TMP23.x && !_TMP24.x || _TMP25.x && (!_TMP26.x && !_TMP27.x || !_TMP28.x && !_TMP29.x) || _TMP30.x || _TMP31.x), _r0134.y != _r0114.x && _r0134.y != _r0114.w && (!_TMP21.y && !_TMP22.y || !_TMP23.y && !_TMP24.y || _TMP25.y && (!_TMP26.y && !_TMP27.y || !_TMP28.y && !_TMP29.y) || _TMP30.y || _TMP31.y), _r0134.z != _r0114.y && _r0134.z != _r0114.x && (!_TMP21.z && !_TMP22.z || !_TMP23.z && !_TMP24.z || _TMP25.z && (!_TMP26.z && !_TMP27.z || !_TMP28.z && !_TMP29.z) || _TMP30.z || _TMP31.z), _r0134.w != _r0114.z && _r0134.w != _r0114.y && (!_TMP21.w && !_TMP22.w || !_TMP23.w && !_TMP24.w || _TMP25.w && (!_TMP26.w && !_TMP27.w || !_TMP28.w && !_TMP29.w) || _TMP30.w || _TMP31.w));\n" +" _interp_restriction_lv2_left = bvec4(_r0134.x != _r0124.z && _r0114.y != _r0124.z, _r0134.y != _r0124.w && _r0114.z != _r0124.w, _r0134.z != _r0124.x && _r0114.w != _r0124.x, _r0134.w != _r0124.y && _r0114.x != _r0124.y);\n" +" _interp_restriction_lv2_up = bvec4(_r0134.x != _r0124.x && _r0114.x != _r0124.x, _r0134.y != _r0124.y && _r0114.y != _r0124.y, _r0134.z != _r0124.z && _r0114.z != _r0124.z, _r0134.w != _r0124.w && _r0114.w != _r0124.w);\n" +" _x0240 = (_fx + vec4( 5.00000000E-01, 5.00000000E-01, 5.00000000E-01, 5.00000000E-01)) - vec4( 1.50000000E+00, 5.00000000E-01, -5.00000000E-01, 5.00000000E-01);\n" +" _TMP55 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0240);\n" +" _TMP241 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP55);\n" +" _x0248 = ((_fx_left + vec4( 2.50000000E-01, 5.00000000E-01, 2.50000000E-01, 5.00000000E-01)) - vec4( 1.00000000E+00, 1.00000000E+00, -5.00000000E-01, 0.00000000E+00))/vec4( 5.00000000E-01, 1.00000000E+00, 5.00000000E-01, 1.00000000E+00);\n" +" _TMP55 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0248);\n" +" _TMP249 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP55);\n" +" _x0256 = ((_fx_up + vec4( 5.00000000E-01, 2.50000000E-01, 5.00000000E-01, 2.50000000E-01)) - vec4( 2.00000000E+00, 0.00000000E+00, -1.00000000E+00, 5.00000000E-01))/vec4( 1.00000000E+00, 5.00000000E-01, 1.00000000E+00, 5.00000000E-01);\n" +" _TMP55 = min(vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00), _x0256);\n" +" _TMP257 = max(vec4( 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00), _TMP55);\n" +" _a0268 = _r0134 - _r0124;\n" +" _TMP265 = abs(_a0268);\n" +" _a0272 = _r0134 - _r0124.zwxy;\n" +" _TMP269 = abs(_a0272);\n" +" _a0276 = _r0124.wxyz - _r0164;\n" +" _TMP273 = abs(_a0276);\n" +" _a0280 = _r0124.wxyz - _r0164.yzwx;\n" +" _TMP277 = abs(_a0280);\n" +" _a0284 = _r0114.zwxy - _r0114.wxyz;\n" +" _TMP281 = abs(_a0284);\n" +" _TMP32 = _TMP265 + _TMP269 + _TMP273 + _TMP277 + 4.00000000E+00*_TMP281;\n" +" _a0290 = _r0114.zwxy - _r0114.yzwx;\n" +" _TMP287 = abs(_a0290);\n" +" _a0294 = _r0114.zwxy - _r0154;\n" +" _TMP291 = abs(_a0294);\n" +" _a0298 = _r0114.wxyz - _r0144;\n" +" _TMP295 = abs(_a0298);\n" +" _a0302 = _r0114.wxyz - _r0114;\n" +" _TMP299 = abs(_a0302);\n" +" _a0306 = _r0134 - _r0124.wxyz;\n" +" _TMP303 = abs(_a0306);\n" +" _TMP33 = _TMP287 + _TMP291 + _TMP295 + _TMP299 + 4.00000000E+00*_TMP303;\n" +" _edr = bvec4(_TMP32.x < _TMP33.x && _interp_restriction_lv1.x, _TMP32.y < _TMP33.y && _interp_restriction_lv1.y, _TMP32.z < _TMP33.z && _interp_restriction_lv1.z, _TMP32.w < _TMP33.w && _interp_restriction_lv1.w);\n" +" _a0310 = _r0114.wxyz - _r0124.zwxy;\n" +" _TMP307 = abs(_a0310);\n" +" _a0314 = _r0114.zwxy - _r0124;\n" +" _TMP311 = abs(_a0314);\n" +" _edr_left = bvec4((2.00000000E+00*_TMP307).x <= _TMP311.x && _interp_restriction_lv2_left.x && _edr.x, (2.00000000E+00*_TMP307).y <= _TMP311.y && _interp_restriction_lv2_left.y && _edr.y, (2.00000000E+00*_TMP307).z <= _TMP311.z && _interp_restriction_lv2_left.z && _edr.z, (2.00000000E+00*_TMP307).w <= _TMP311.w && _interp_restriction_lv2_left.w && _edr.w);\n" +" _a0318 = _r0114.wxyz - _r0124.zwxy;\n" +" _TMP315 = abs(_a0318);\n" +" _a0322 = _r0114.zwxy - _r0124;\n" +" _TMP319 = abs(_a0322);\n" +" _edr_up = bvec4(_TMP315.x >= (2.00000000E+00*_TMP319).x && _interp_restriction_lv2_up.x && _edr.x, _TMP315.y >= (2.00000000E+00*_TMP319).y && _interp_restriction_lv2_up.y && _edr.y, _TMP315.z >= (2.00000000E+00*_TMP319).z && _interp_restriction_lv2_up.z && _edr.z, _TMP315.w >= (2.00000000E+00*_TMP319).w && _interp_restriction_lv2_up.w && _edr.w);\n" +" _fx45 = vec4(float(_edr.x), float(_edr.y), float(_edr.z), float(_edr.w))*_TMP241;\n" +" _fx30 = vec4(float(_edr_left.x), float(_edr_left.y), float(_edr_left.z), float(_edr_left.w))*_TMP249;\n" +" _fx60 = vec4(float(_edr_up.x), float(_edr_up.y), float(_edr_up.z), float(_edr_up.w))*_TMP257;\n" +" _a0326 = _r0134 - _r0114.wxyz;\n" +" _TMP323 = abs(_a0326);\n" +" _a0330 = _r0134 - _r0114.zwxy;\n" +" _TMP327 = abs(_a0330);\n" +" _px = bvec4(_TMP323.x <= _TMP327.x, _TMP323.y <= _TMP327.y, _TMP323.z <= _TMP327.z, _TMP323.w <= _TMP327.w);\n" +" _TMP40 = max(_fx30, _fx60);\n" +" _maximo = max(_TMP40, _fx45);\n" +" _t0336 = float(_px.x);\n" +" _TMP41 = _TMP10.xyz + _t0336*(_TMP8.xyz - _TMP10.xyz);\n" +" _TMP42 = _TMP7.xyz + _maximo.x*(_TMP41 - _TMP7.xyz);\n" +" _t0340 = float(_px.y);\n" +" _TMP43 = _TMP8.xyz + _t0340*(_TMP4.xyz - _TMP8.xyz);\n" +" _TMP44 = _TMP7.xyz + _maximo.y*(_TMP43 - _TMP7.xyz);\n" +" _t0344 = float(_px.z);\n" +" _TMP45 = _TMP4.xyz + _t0344*(_TMP6.xyz - _TMP4.xyz);\n" +" _TMP46 = _TMP7.xyz + _maximo.z*(_TMP45 - _TMP7.xyz);\n" +" _t0348 = float(_px.w);\n" +" _TMP47 = _TMP6.xyz + _t0348*(_TMP10.xyz - _TMP6.xyz);\n" +" _TMP48 = _TMP7.xyz + _maximo.w*(_TMP47 - _TMP7.xyz);\n" +" _r0352.x = dot(_TMP42, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0352.y = dot(_TMP44, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0352.z = dot(_TMP46, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _r0352.w = dot(_TMP48, vec3( 1.43519993E+01, 2.81760006E+01, 5.47200012E+00));\n" +" _a0364 = _r0352 - _r0134;\n" +" _TMP361 = abs(_a0364);\n" +" _res = _TMP42;\n" +" _mx = _TMP361.x;\n" +" if (_TMP361.y > _TMP361.x) { \n" +" _res = _TMP44;\n" +" _mx = _TMP361.y;\n" +" } \n" +" if (_TMP361.z > _mx) { \n" +" _res = _TMP46;\n" +" _mx = _TMP361.z;\n" +" } \n" +" if (_TMP361.w > _mx) { \n" +" _res = _TMP48;\n" +" } \n" +" _ret_0 = vec4(_res.x, _res.y, _res.z, 1.00000000E+00);\n" +" FragColor = _ret_0;\n" +" return;\n" +"} \n" +"#endif\n" +}, diff --git a/src/video/sdl/shdcode.h b/src/video/sdl/shdcode.h new file mode 100644 index 000000000..19b22702a --- /dev/null +++ b/src/video/sdl/shdcode.h @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2010-2016 Fabio Cavallo (aka FHorse) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef SHDCODE_H_ +#define SHDCODE_H_ + +#define SHDCODE(index) shader_code[index].code +#define LUTCODE(index) lut_resource[index].code + +enum shader_code_enum { + shc_no_filter, + shc_blend, + shc_anti_aliasing_advanced_aa, + shc_anti_aliasing_fx_aa, + shc_anti_aliasing_fxaa_edge_detect, + shc_crt_crt_easymode_halation_blur_horiz, + shc_crt_crt_easymode_halation_blur_vert, + shc_crt_crt_easymode_halation_crt_easymode_halation, + shc_crt_crt_easymode_halation_linearize, + shc_crt_crt_easymode_halation_threshold, + shc_crt_glow_blur_horiz, + shc_crt_glow_blur_vert, + shc_crt_glow_gauss_horiz, + shc_crt_glow_gauss_vert, + shc_crt_glow_linearize, + shc_crt_glow_resolve, + shc_crt_glow_threshold, + shc_crt_gtu_v050_pass1, + shc_crt_gtu_v050_pass2, + shc_crt_gtu_v050_pass3, + shc_crt_4xbr_hybrid_crt, + shc_crt_crt_caligari, + shc_crt_crt_cgwg_fast, // a schermo intero l'immagine e' "sporca" + shc_crt_crt_easymode, + shc_crt_crt_geom, + shc_crt_crt_hyllian, + shc_crt_crt_lottes, + shc_crt_crt_reverse_aa, + shc_crt_dotmask, + shc_crt_tvout_tweaks, + shc_eagle_super_eagle, + shc_hunterk_handheld_lcd_cgwg_lcd_grid, + shc_hunterk_hqx_hq3x, + shc_hunterk_hqx_pass1, + shc_hunterk_misc_color_mangler, + shc_hunterk_misc_image_adjustment, + shc_hunterk_motionblur_motionblur_simple, + shc_hunterk_motionblur_braid_rewind, + shc_hunterk_resources_bigblur_1080p, + shc_hunterk_resources_bigblur_horiz, + shc_hunterk_resources_bigblur_vert, + shc_hunterk_resources_color_grid_1080p, + shc_hunterk_resources_mudlord_1080p, + shc_hunterk_resources_shiny_iterations_1080p, + shc_hunterk_resources_snow_1080p, + shc_hunterk_resources_voronoi_1080p, + shc_hunterk_resources_water_1080p, + shc_misc_image_adjustment, + shc_motionblur_feedback, + shc_mudlord_emboss, + shc_mudlord_mud_mudlord, + shc_mudlord_noise_mudlord, + shc_mudlord_oldtv, + shc_ntsc_ntsc_pass1_composite_2phase, + shc_ntsc_ntsc_pass1_composite_3phase, + shc_ntsc_ntsc_pass1_svideo_3phase, + shc_ntsc_ntsc_pass2_2phase, + shc_ntsc_ntsc_pass2_3phase, + shc_ntsc_ntsc_pass2_3phase_linear, + shc_waterpaint_water, + shc_windowed_jinc2_sharper, + shc_xbr_legacy_2xbr_v38c, +}; +enum lut_code_enum { + lut_none, + lut_hunterk_borders_1080p_border_1080p, + lut_hunterk_hqx_resources_hq3x, +}; + +typedef struct _shader_code { + const char *code; +} _shader_code; + +static const _shader_code shader_code[] = { +#include "shaders/no_filter.h" +#include "shaders/blend.h" +#include "shaders/anti-aliasing/advanced-aa.h" +#include "shaders/anti-aliasing/fx-aa.h" +#include "shaders/anti-aliasing/fxaa-edge-detect.h" +#include "shaders/crt/crt-easymode-halation/blur_horiz.h" +#include "shaders/crt/crt-easymode-halation/blur_vert.h" +#include "shaders/crt/crt-easymode-halation/crt-easymode-halation.h" +#include "shaders/crt/crt-easymode-halation/linearize.h" +#include "shaders/crt/crt-easymode-halation/threshold.h" +#include "shaders/crt/glow/blur_horiz.h" +#include "shaders/crt/glow/blur_vert.h" +#include "shaders/crt/glow/gauss_horiz.h" +#include "shaders/crt/glow/gauss_vert.h" +#include "shaders/crt/glow/linearize.h" +#include "shaders/crt/glow/resolve.h" +#include "shaders/crt/glow/threshold.h" +#include "shaders/crt/gtu-v050/pass1.h" +#include "shaders/crt/gtu-v050/pass2.h" +#include "shaders/crt/gtu-v050/pass3.h" +#include "shaders/crt/4xbr-hybrid-crt.h" +#include "shaders/crt/crt-caligari.h" +#include "shaders/crt/crt-cgwg-fast.h" +#include "shaders/crt/crt-easymode.h" +#include "shaders/crt/crt-geom.h" +#include "shaders/crt/crt-hyllian.h" +#include "shaders/crt/crt-lottes.h" +#include "shaders/crt/crt-reverse-aa.h" +#include "shaders/crt/dotmask.h" +#include "shaders/crt/tvout-tweaks.h" +#include "shaders/eagle/super-eagle.h" +#include "shaders/hunterk/handheld/lcd_cgwg/lcd-grid.h" +#include "shaders/hunterk/hqx/hq3x.h" +#include "shaders/hunterk/hqx/pass1.h" +#include "shaders/hunterk/misc/color-mangler.h" +#include "shaders/hunterk/misc/image-adjustment.h" +#include "shaders/hunterk/motionblur/motionblur-simple.h" +#include "shaders/hunterk/motionblur/braid-rewind.h" +#include "shaders/hunterk/resources/bigblur-1080p.h" +#include "shaders/hunterk/resources/bigblur-horiz.h" +#include "shaders/hunterk/resources/bigblur-vert.h" +#include "shaders/hunterk/resources/color-grid-1080p.h" +#include "shaders/hunterk/resources/mudlord-1080p.h" +#include "shaders/hunterk/resources/shiny-iterations-1080p.h" +#include "shaders/hunterk/resources/snow-1080p.h" +#include "shaders/hunterk/resources/voronoi-1080p.h" +#include "shaders/hunterk/resources/water-1080p.h" +#include "shaders/misc/image-adjustment.h" +#include "shaders/motionblur/feedback.h" +#include "shaders/mudlord/emboss.h" +#include "shaders/mudlord/mud-mudlord.h" +#include "shaders/mudlord/noise-mudlord.h" +#include "shaders/mudlord/oldtv.h" +#include "shaders/ntsc/ntsc-pass1-composite-2phase.h" +#include "shaders/ntsc/ntsc-pass1-composite-3phase.h" +#include "shaders/ntsc/ntsc-pass1-svideo-3phase.h" +#include "shaders/ntsc/ntsc-pass2-2phase.h" +#include "shaders/ntsc/ntsc-pass2-3phase.h" +#include "shaders/ntsc/ntsc-pass2-3phase-linear.h" +#include "shaders/waterpaint/water.h" +#include "shaders/windowed/jinc2-sharper.h" +#include "shaders/xbr/legacy/2xbr-v3.8c.h" +}; + +static const _shader_code lut_resource[] = { + { "" }, + { ":/shaders/shaders/lut/hunterk/borders/1080p/border-1080p.png" }, + { ":/shaders/shaders/lut/hunterk/hqx/hq3x.png" }, +}; +#endif /* SHDCODE_H_ */