From 2df67ba204110a62f66a559ff9838287186b4299 Mon Sep 17 00:00:00 2001 From: Abdessamad Derraz <3028866+Abdess@users.noreply.github.com> Date: Tue, 11 Aug 2026 19:21:00 +0200 Subject: [PATCH] feat: collect the epsxe shader packs --- .../epsxe/shaders/5xBR-v3.7c/gpuCore.ini | 5 + .../epsxe/shaders/5xBR-v3.7c/gpuCore.slf | 437 ++++++++++++++ .../epsxe/shaders/5xBR-v3.7c/gpuCore.slv | 9 + .../gpuCore.slf | 71 +++ .../gpuCore.slv | 28 + .../gpuCore.slf | 221 +++++++ .../gpuCore.slv | 28 + .../epsxe/shaders/Brightness/gpuCore.ini | 4 + .../epsxe/shaders/Brightness/gpuCore.slf | 162 ++++++ .../epsxe/shaders/Brightness/gpuCore.slv | 9 + .../epsxe/shaders/CRT-Hyllian-3D/gpuCore.ini | 4 + .../epsxe/shaders/CRT-Hyllian-3D/gpuCore.slf | 301 ++++++++++ .../epsxe/shaders/CRT-Hyllian-3D/gpuCore.slv | 15 + .../epsxe/shaders/CRT-Hyllian/gpuCore.ini | 5 + .../epsxe/shaders/CRT-Hyllian/gpuCore.slf | 161 ++++++ .../epsxe/shaders/CRT-Hyllian/gpuCore.slv | 15 + .../epsxe/shaders/CRT-Lottes/gpuCore.ini | 4 + .../epsxe/shaders/CRT-Lottes/gpuCore.slf | 160 +++++ .../epsxe/shaders/CRT-Lottes/gpuCore.slv | 9 + .../shaders/Cartoon_shader_II/gpuCore.slf | 43 ++ .../shaders/Cartoon_shader_II/gpuCore.slv | 31 + .../shaders/FXAA_natural_vision/gpuCore.slf | 74 +++ .../shaders/FXAA_natural_vision/gpuCore.slv | 11 + .../Other/epsxe/shaders/Grayscale/gpuCore.slf | 14 + .../Other/epsxe/shaders/Grayscale/gpuCore.slv | 9 + bios/Other/epsxe/shaders/gpuPeteOGL2.fp | 64 ++ bios/Other/epsxe/shaders/gpuPeteOGL2.slf | 35 ++ bios/Other/epsxe/shaders/gpuPeteOGL2.slv | 26 + bios/Other/epsxe/shaders/gpuPeteOGL2.vp | 12 + bios/Other/epsxe/shaders/gpucore/delete.me | 1 + bios/Other/epsxe/shaders/ogl2/erase.me | 1 + .../epsxe/shaders/super-eagle/gpuCore.ini | 5 + .../epsxe/shaders/super-eagle/gpuCore.slf | 147 +++++ .../epsxe/shaders/super-eagle/gpuCore.slv | 44 ++ .../epsxe/shaders/xBR-LV2-3D/gpuCore.ini | 5 + .../epsxe/shaders/xBR-LV2-3D/gpuCore.slf | 266 +++++++++ .../epsxe/shaders/xBR-LV2-3D/gpuCore.slv | 32 + database.json | 545 +++++++++++++++++- 38 files changed, 3010 insertions(+), 3 deletions(-) create mode 100644 bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/Brightness/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/Brightness/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/Brightness/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/Grayscale/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/Grayscale/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/gpuPeteOGL2.fp create mode 100644 bios/Other/epsxe/shaders/gpuPeteOGL2.slf create mode 100644 bios/Other/epsxe/shaders/gpuPeteOGL2.slv create mode 100644 bios/Other/epsxe/shaders/gpuPeteOGL2.vp create mode 100644 bios/Other/epsxe/shaders/gpucore/delete.me create mode 100644 bios/Other/epsxe/shaders/ogl2/erase.me create mode 100644 bios/Other/epsxe/shaders/super-eagle/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/super-eagle/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/super-eagle/gpuCore.slv create mode 100644 bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.ini create mode 100644 bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slf create mode 100644 bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slv diff --git a/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.ini b/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.ini new file mode 100644 index 00000000..e3299128 --- /dev/null +++ b/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.ini @@ -0,0 +1,5 @@ +name=5xBR-v3.7c +version=1 +license=GPLv2 +copyright=Hyllian/Jararaca +filter_linear=0 diff --git a/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slf b/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slf new file mode 100644 index 00000000..ee964270 --- /dev/null +++ b/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slf @@ -0,0 +1,437 @@ +/* + Hyllian's 5xBR v3.5a Shader + + Copyright (C) 2011 Hyllian/Jararaca - sergiogdb@gmail.com + + 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. + +*/ + +#ifdef GL_ES +precision mediump float; +#endif + +varying vec2 v_texCoord; + +vec4 _ret_0; +vec3 _TMP46; +vec3 _TMP48; +vec3 _TMP50; +vec3 _TMP52; +vec3 _TMP53; +vec3 _TMP51; +vec3 _TMP49; +vec3 _TMP47; +vec4 _TMP39; +vec4 _TMP38; +bvec4 _TMP37; +bvec4 _TMP36; +bvec4 _TMP35; +bvec4 _TMP34; +bvec4 _TMP33; +bvec4 _TMP32; +bvec4 _TMP31; +bvec4 _TMP30; +bvec4 _TMP29; +bvec4 _TMP28; +bvec4 _TMP27; +float _TMP60; +vec4 _TMP20; +vec4 _TMP19; +vec4 _TMP18; +vec4 _TMP17; +vec4 _TMP16; +vec4 _TMP15; +vec4 _TMP14; +vec4 _TMP13; +vec4 _TMP12; +vec4 _TMP11; +vec4 _TMP10; +vec4 _TMP9; +vec4 _TMP8; +vec4 _TMP7; +vec4 _TMP6; +vec4 _TMP5; +vec4 _TMP4; +vec4 _TMP3; +vec4 _TMP2; +vec4 _TMP1; +vec4 _TMP0; +uniform sampler2D Sample; +vec2 _x0074; +vec2 _c0076; +vec2 _c0078; +vec2 _c0080; +vec2 _c0082; +vec2 _c0086; +vec2 _c0088; +vec2 _c0090; +vec2 _c0092; +vec2 _c0094; +vec2 _c0096; +vec2 _c0098; +vec2 _c0100; +vec2 _c0102; +vec2 _c0104; +vec2 _c0106; +vec2 _c0108; +vec2 _c0110; +vec2 _c0112; +vec2 _c0114; +vec2 _c0116; +vec4 _r0118; +vec4 _r0128; +vec4 _r0138; +vec4 _r0148; +vec4 _r0158; +vec4 _r0168; +vec4 _TMP179; +vec4 _a0182; +vec4 _TMP185; +vec4 _a0188; +vec4 _TMP191; +vec4 _a0194; +vec4 _TMP197; +vec4 _a0200; +vec4 _TMP203; +vec4 _a0206; +vec4 _TMP209; +vec4 _a0212; +vec4 _TMP215; +vec4 _a0218; +vec4 _TMP221; +vec4 _a0224; +vec4 _TMP227; +vec4 _a0230; +vec4 _TMP233; +vec4 _a0236; +vec4 _TMP239; +vec4 _a0242; +vec4 _TMP245; +vec4 _a0248; +vec4 _TMP249; +vec4 _a0252; +vec4 _TMP253; +vec4 _a0256; +vec4 _TMP257; +vec4 _a0260; +vec4 _TMP261; +vec4 _a0264; +vec4 _TMP267; +vec4 _a0270; +vec4 _TMP271; +vec4 _a0274; +vec4 _TMP275; +vec4 _a0278; +vec4 _TMP279; +vec4 _a0282; +vec4 _TMP283; +vec4 _a0286; +vec4 _TMP287; +vec4 _a0290; +vec4 _TMP291; +vec4 _a0294; +vec4 _TMP295; +vec4 _a0298; +vec4 _TMP299; +vec4 _a0302; +vec4 _TMP303; +vec4 _a0306; +vec4 _TMP307; +vec4 _a0310; + +void main() +{ + + bvec4 _edr; + bvec4 _edr_left; + bvec4 _edr_up; + bvec4 _px; + bvec4 _interp_restriction_lv1; + bvec4 _interp_restriction_lv2_left; + bvec4 _interp_restriction_lv2_up; + bvec4 _nc; + bvec4 _fx; + bvec4 _fx_left; + bvec4 _fx_up; + vec2 _fp; + vec3 _A2; + vec3 _B2; + vec3 _C; + vec3 _D; + vec3 _E; + vec3 _F; + vec3 _G; + vec3 _H; + vec3 _I; + vec3 _A11; + vec3 _C1; + vec3 _A0; + vec3 _G0; + vec3 _C4; + vec3 _I4; + vec3 _G5; + vec3 _I5; + vec3 _B11; + vec3 _D0; + vec3 _H5; + vec3 _F4; + vec4 _b1; + vec4 _c1; + vec4 _e1; + vec4 _i4; + vec4 _i5; + vec4 _h5; + + _x0074 = v_texCoord.xy*vec2( 1.02400000E+003, 5.12000000E+002); + _fp = fract(_x0074); + _c0076 = (v_texCoord.xy - vec2( 9.76562500E-004, 0.00000000E+000)) - vec2( 0.00000000E+000, 1.95312500E-003); + _TMP0 = texture2D(Sample, _c0076); + _A2 = vec3(float(_TMP0.x), float(_TMP0.y), float(_TMP0.z)); + _c0078 = v_texCoord.xy - vec2( 0.00000000E+000, 1.95312500E-003); + _TMP1 = texture2D(Sample, _c0078); + _B2 = vec3(float(_TMP1.x), float(_TMP1.y), float(_TMP1.z)); + _c0080 = (v_texCoord.xy + vec2( 9.76562500E-004, 0.00000000E+000)) - vec2( 0.00000000E+000, 1.95312500E-003); + _TMP2 = texture2D(Sample, _c0080); + _C = vec3(float(_TMP2.x), float(_TMP2.y), float(_TMP2.z)); + _c0082 = v_texCoord.xy - vec2( 9.76562500E-004, 0.00000000E+000); + _TMP3 = texture2D(Sample, _c0082); + _D = vec3(float(_TMP3.x), float(_TMP3.y), float(_TMP3.z)); + _TMP4 = texture2D(Sample, v_texCoord.xy); + _E = vec3(float(_TMP4.x), float(_TMP4.y), float(_TMP4.z)); + _c0086 = v_texCoord.xy + vec2( 9.76562500E-004, 0.00000000E+000); + _TMP5 = texture2D(Sample, _c0086); + _F = vec3(float(_TMP5.x), float(_TMP5.y), float(_TMP5.z)); + _c0088 = (v_texCoord.xy - vec2( 9.76562500E-004, 0.00000000E+000)) + vec2( 0.00000000E+000, 1.95312500E-003); + _TMP6 = texture2D(Sample, _c0088); + _G = vec3(float(_TMP6.x), float(_TMP6.y), float(_TMP6.z)); + _c0090 = v_texCoord.xy + vec2( 0.00000000E+000, 1.95312500E-003); + _TMP7 = texture2D(Sample, _c0090); + _H = vec3(float(_TMP7.x), float(_TMP7.y), float(_TMP7.z)); + _c0092 = v_texCoord.xy + vec2( 9.76562500E-004, 0.00000000E+000) + vec2( 0.00000000E+000, 1.95312500E-003); + _TMP8 = texture2D(Sample, _c0092); + _I = vec3(float(_TMP8.x), float(_TMP8.y), float(_TMP8.z)); + _c0094 = (v_texCoord.xy - vec2( 9.76562500E-004, 0.00000000E+000)) - vec2( 0.00000000E+000, 3.90625000E-003); + _TMP9 = texture2D(Sample, _c0094); + _A11 = vec3(float(_TMP9.x), float(_TMP9.y), float(_TMP9.z)); + _c0096 = (v_texCoord.xy + vec2( 9.76562500E-004, 0.00000000E+000)) - vec2( 0.00000000E+000, 3.90625000E-003); + _TMP10 = texture2D(Sample, _c0096); + _C1 = vec3(float(_TMP10.x), float(_TMP10.y), float(_TMP10.z)); + _c0098 = (v_texCoord.xy - vec2( 1.95312500E-003, 0.00000000E+000)) - vec2( 0.00000000E+000, 1.95312500E-003); + _TMP11 = texture2D(Sample, _c0098); + _A0 = vec3(float(_TMP11.x), float(_TMP11.y), float(_TMP11.z)); + _c0100 = (v_texCoord.xy - vec2( 1.95312500E-003, 0.00000000E+000)) + vec2( 0.00000000E+000, 1.95312500E-003); + _TMP12 = texture2D(Sample, _c0100); + _G0 = vec3(float(_TMP12.x), float(_TMP12.y), float(_TMP12.z)); + _c0102 = (v_texCoord.xy + vec2( 1.95312500E-003, 0.00000000E+000)) - vec2( 0.00000000E+000, 1.95312500E-003); + _TMP13 = texture2D(Sample, _c0102); + _C4 = vec3(float(_TMP13.x), float(_TMP13.y), float(_TMP13.z)); + _c0104 = v_texCoord.xy + vec2( 1.95312500E-003, 0.00000000E+000) + vec2( 0.00000000E+000, 1.95312500E-003); + _TMP14 = texture2D(Sample, _c0104); + _I4 = vec3(float(_TMP14.x), float(_TMP14.y), float(_TMP14.z)); + _c0106 = (v_texCoord.xy - vec2( 9.76562500E-004, 0.00000000E+000)) + vec2( 0.00000000E+000, 3.90625000E-003); + _TMP15 = texture2D(Sample, _c0106); + _G5 = vec3(float(_TMP15.x), float(_TMP15.y), float(_TMP15.z)); + _c0108 = v_texCoord.xy + vec2( 9.76562500E-004, 0.00000000E+000) + vec2( 0.00000000E+000, 3.90625000E-003); + _TMP16 = texture2D(Sample, _c0108); + _I5 = vec3(float(_TMP16.x), float(_TMP16.y), float(_TMP16.z)); + _c0110 = v_texCoord.xy - vec2( 0.00000000E+000, 3.90625000E-003); + _TMP17 = texture2D(Sample, _c0110); + _B11 = vec3(float(_TMP17.x), float(_TMP17.y), float(_TMP17.z)); + _c0112 = v_texCoord.xy - vec2( 1.95312500E-003, 0.00000000E+000); + _TMP18 = texture2D(Sample, _c0112); + _D0 = vec3(float(_TMP18.x), float(_TMP18.y), float(_TMP18.z)); + _c0114 = v_texCoord.xy + vec2( 0.00000000E+000, 3.90625000E-003); + _TMP19 = texture2D(Sample, _c0114); + _H5 = vec3(float(_TMP19.x), float(_TMP19.y), float(_TMP19.z)); + _c0116 = v_texCoord.xy + vec2( 1.95312500E-003, 0.00000000E+000); + _TMP20 = texture2D(Sample, _c0116); + _F4 = vec3(float(_TMP20.x), float(_TMP20.y), float(_TMP20.z)); + _TMP60 = dot(vec3(float(_B2.x), float(_B2.y), float(_B2.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0118.x = float(_TMP60); + _TMP60 = dot(vec3(float(_D.x), float(_D.y), float(_D.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0118.y = float(_TMP60); + _TMP60 = dot(vec3(float(_H.x), float(_H.y), float(_H.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0118.z = float(_TMP60); + _TMP60 = dot(vec3(float(_F.x), float(_F.y), float(_F.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0118.w = float(_TMP60); + _b1 = vec4(float(_r0118.x), float(_r0118.y), float(_r0118.z), float(_r0118.w)); + _TMP60 = dot(vec3(float(_C.x), float(_C.y), float(_C.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0128.x = float(_TMP60); + _TMP60 = dot(vec3(float(_A2.x), float(_A2.y), float(_A2.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0128.y = float(_TMP60); + _TMP60 = dot(vec3(float(_G.x), float(_G.y), float(_G.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0128.z = float(_TMP60); + _TMP60 = dot(vec3(float(_I.x), float(_I.y), float(_I.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0128.w = float(_TMP60); + _c1 = vec4(float(_r0128.x), float(_r0128.y), float(_r0128.z), float(_r0128.w)); + _TMP60 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0138.x = float(_TMP60); + _TMP60 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0138.y = float(_TMP60); + _TMP60 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0138.z = float(_TMP60); + _TMP60 = dot(vec3(float(_E.x), float(_E.y), float(_E.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0138.w = float(_TMP60); + _e1 = vec4(float(_r0138.x), float(_r0138.y), float(_r0138.z), float(_r0138.w)); + _TMP60 = dot(vec3(float(_I4.x), float(_I4.y), float(_I4.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0148.x = float(_TMP60); + _TMP60 = dot(vec3(float(_C1.x), float(_C1.y), float(_C1.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0148.y = float(_TMP60); + _TMP60 = dot(vec3(float(_A0.x), float(_A0.y), float(_A0.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0148.z = float(_TMP60); + _TMP60 = dot(vec3(float(_G5.x), float(_G5.y), float(_G5.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0148.w = float(_TMP60); + _i4 = vec4(float(_r0148.x), float(_r0148.y), float(_r0148.z), float(_r0148.w)); + _TMP60 = dot(vec3(float(_I5.x), float(_I5.y), float(_I5.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0158.x = float(_TMP60); + _TMP60 = dot(vec3(float(_C4.x), float(_C4.y), float(_C4.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0158.y = float(_TMP60); + _TMP60 = dot(vec3(float(_A11.x), float(_A11.y), float(_A11.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0158.z = float(_TMP60); + _TMP60 = dot(vec3(float(_G0.x), float(_G0.y), float(_G0.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0158.w = float(_TMP60); + _i5 = vec4(float(_r0158.x), float(_r0158.y), float(_r0158.z), float(_r0158.w)); + _TMP60 = dot(vec3(float(_H5.x), float(_H5.y), float(_H5.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0168.x = float(_TMP60); + _TMP60 = dot(vec3(float(_F4.x), float(_F4.y), float(_F4.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0168.y = float(_TMP60); + _TMP60 = dot(vec3(float(_B11.x), float(_B11.y), float(_B11.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0168.z = float(_TMP60); + _TMP60 = dot(vec3(float(_D0.x), float(_D0.y), float(_D0.z)), vec3( 1.43593750E+001, 2.81718750E+001, 5.47265625E+000)); + _r0168.w = float(_TMP60); + _h5 = vec4(float(_r0168.x), float(_r0168.y), float(_r0168.z), float(_r0168.w)); + _fx = bvec4((vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 1.00000000E+000, 1.00000000E+000, -1.00000000E+000, -1.00000000E+000)*_fp.x).x > 1.50000000E+000, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 1.00000000E+000, 1.00000000E+000, -1.00000000E+000, -1.00000000E+000)*_fp.x).y > 5.00000000E-001, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 1.00000000E+000, 1.00000000E+000, -1.00000000E+000, -1.00000000E+000)*_fp.x).z > -5.00000000E-001, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 1.00000000E+000, 1.00000000E+000, -1.00000000E+000, -1.00000000E+000)*_fp.x).w > 5.00000000E-001); + _fx_left = bvec4((vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 5.00000000E-001, 2.00000000E+000, -5.00000000E-001, -2.00000000E+000)*_fp.x).x > 1.00000000E+000, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 5.00000000E-001, 2.00000000E+000, -5.00000000E-001, -2.00000000E+000)*_fp.x).y > 1.00000000E+000, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 5.00000000E-001, 2.00000000E+000, -5.00000000E-001, -2.00000000E+000)*_fp.x).z > -5.00000000E-001, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 5.00000000E-001, 2.00000000E+000, -5.00000000E-001, -2.00000000E+000)*_fp.x).w > 0.00000000E+000); + _fx_up = bvec4((vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 2.00000000E+000, 5.00000000E-001, -2.00000000E+000, -5.00000000E-001)*_fp.x).x > 2.00000000E+000, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 2.00000000E+000, 5.00000000E-001, -2.00000000E+000, -5.00000000E-001)*_fp.x).y > 0.00000000E+000, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 2.00000000E+000, 5.00000000E-001, -2.00000000E+000, -5.00000000E-001)*_fp.x).z > -1.00000000E+000, (vec4( 1.00000000E+000, -1.00000000E+000, -1.00000000E+000, 1.00000000E+000)*_fp.y + vec4( 2.00000000E+000, 5.00000000E-001, -2.00000000E+000, -5.00000000E-001)*_fp.x).w > 5.00000000E-001); + _a0182 = _b1.wxyz - _b1; + _TMP179 = abs(_a0182); + _TMP27 = bvec4(_TMP179.x < 1.50000000E+001, _TMP179.y < 1.50000000E+001, _TMP179.z < 1.50000000E+001, _TMP179.w < 1.50000000E+001); + _a0188 = _b1.wxyz - _c1; + _TMP185 = abs(_a0188); + _TMP28 = bvec4(_TMP185.x < 1.50000000E+001, _TMP185.y < 1.50000000E+001, _TMP185.z < 1.50000000E+001, _TMP185.w < 1.50000000E+001); + _a0194 = _b1.zwxy - _b1.yzwx; + _TMP191 = abs(_a0194); + _TMP29 = bvec4(_TMP191.x < 1.50000000E+001, _TMP191.y < 1.50000000E+001, _TMP191.z < 1.50000000E+001, _TMP191.w < 1.50000000E+001); + _a0200 = _b1.zwxy - _c1.zwxy; + _TMP197 = abs(_a0200); + _TMP30 = bvec4(_TMP197.x < 1.50000000E+001, _TMP197.y < 1.50000000E+001, _TMP197.z < 1.50000000E+001, _TMP197.w < 1.50000000E+001); + _a0206 = _e1 - _c1.wxyz; + _TMP203 = abs(_a0206); + _TMP31 = bvec4(_TMP203.x < 1.50000000E+001, _TMP203.y < 1.50000000E+001, _TMP203.z < 1.50000000E+001, _TMP203.w < 1.50000000E+001); + _a0212 = _b1.wxyz - _h5.yzwx; + _TMP209 = abs(_a0212); + _TMP32 = bvec4(_TMP209.x < 1.50000000E+001, _TMP209.y < 1.50000000E+001, _TMP209.z < 1.50000000E+001, _TMP209.w < 1.50000000E+001); + _a0218 = _b1.wxyz - _i4; + _TMP215 = abs(_a0218); + _TMP33 = bvec4(_TMP215.x < 1.50000000E+001, _TMP215.y < 1.50000000E+001, _TMP215.z < 1.50000000E+001, _TMP215.w < 1.50000000E+001); + _a0224 = _b1.zwxy - _h5; + _TMP221 = abs(_a0224); + _TMP34 = bvec4(_TMP221.x < 1.50000000E+001, _TMP221.y < 1.50000000E+001, _TMP221.z < 1.50000000E+001, _TMP221.w < 1.50000000E+001); + _a0230 = _b1.zwxy - _i5; + _TMP227 = abs(_a0230); + _TMP35 = bvec4(_TMP227.x < 1.50000000E+001, _TMP227.y < 1.50000000E+001, _TMP227.z < 1.50000000E+001, _TMP227.w < 1.50000000E+001); + _a0236 = _e1 - _c1.zwxy; + _TMP233 = abs(_a0236); + _TMP36 = bvec4(_TMP233.x < 1.50000000E+001, _TMP233.y < 1.50000000E+001, _TMP233.z < 1.50000000E+001, _TMP233.w < 1.50000000E+001); + _a0242 = _e1 - _c1; + _TMP239 = abs(_a0242); + _TMP37 = bvec4(_TMP239.x < 1.50000000E+001, _TMP239.y < 1.50000000E+001, _TMP239.z < 1.50000000E+001, _TMP239.w < 1.50000000E+001); + _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), _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), _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), _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)); + _interp_restriction_lv2_left = bvec4(_e1.x != _c1.z && _b1.y != _c1.z, _e1.y != _c1.w && _b1.z != _c1.w, _e1.z != _c1.x && _b1.w != _c1.x, _e1.w != _c1.y && _b1.x != _c1.y); + _interp_restriction_lv2_up = bvec4(_e1.x != _c1.x && _b1.x != _c1.x, _e1.y != _c1.y && _b1.y != _c1.y, _e1.z != _c1.z && _b1.z != _c1.z, _e1.w != _c1.w && _b1.w != _c1.w); + _a0248 = _e1 - _c1; + _TMP245 = abs(_a0248); + _a0252 = _e1 - _c1.zwxy; + _TMP249 = abs(_a0252); + _a0256 = _c1.wxyz - _h5; + _TMP253 = abs(_a0256); + _a0260 = _c1.wxyz - _h5.yzwx; + _TMP257 = abs(_a0260); + _a0264 = _b1.zwxy - _b1.wxyz; + _TMP261 = abs(_a0264); + _TMP38 = _TMP245 + _TMP249 + _TMP253 + _TMP257 + 4.00000000E+000*_TMP261; + _a0270 = _b1.zwxy - _b1.yzwx; + _TMP267 = abs(_a0270); + _a0274 = _b1.zwxy - _i5; + _TMP271 = abs(_a0274); + _a0278 = _b1.wxyz - _i4; + _TMP275 = abs(_a0278); + _a0282 = _b1.wxyz - _b1; + _TMP279 = abs(_a0282); + _a0286 = _e1 - _c1.wxyz; + _TMP283 = abs(_a0286); + _TMP39 = _TMP267 + _TMP271 + _TMP275 + _TMP279 + 4.00000000E+000*_TMP283; + _edr = bvec4(_TMP38.x < _TMP39.x && _interp_restriction_lv1.x, _TMP38.y < _TMP39.y && _interp_restriction_lv1.y, _TMP38.z < _TMP39.z && _interp_restriction_lv1.z, _TMP38.w < _TMP39.w && _interp_restriction_lv1.w); + _a0290 = _b1.wxyz - _c1.zwxy; + _TMP287 = abs(_a0290); + _a0294 = _b1.zwxy - _c1; + _TMP291 = abs(_a0294); + _edr_left = bvec4((2.00000000E+000*_TMP287).x <= _TMP291.x && _interp_restriction_lv2_left.x, (2.00000000E+000*_TMP287).y <= _TMP291.y && _interp_restriction_lv2_left.y, (2.00000000E+000*_TMP287).z <= _TMP291.z && _interp_restriction_lv2_left.z, (2.00000000E+000*_TMP287).w <= _TMP291.w && _interp_restriction_lv2_left.w); + _a0298 = _b1.wxyz - _c1.zwxy; + _TMP295 = abs(_a0298); + _a0302 = _b1.zwxy - _c1; + _TMP299 = abs(_a0302); + _edr_up = bvec4(_TMP295.x >= (2.00000000E+000*_TMP299).x && _interp_restriction_lv2_up.x, _TMP295.y >= (2.00000000E+000*_TMP299).y && _interp_restriction_lv2_up.y, _TMP295.z >= (2.00000000E+000*_TMP299).z && _interp_restriction_lv2_up.z, _TMP295.w >= (2.00000000E+000*_TMP299).w && _interp_restriction_lv2_up.w); + _nc = bvec4(_edr.x && (_fx.x || _edr_left.x && _fx_left.x || _edr_up.x && _fx_up.x), _edr.y && (_fx.y || _edr_left.y && _fx_left.y || _edr_up.y && _fx_up.y), _edr.z && (_fx.z || _edr_left.z && _fx_left.z || _edr_up.z && _fx_up.z), _edr.w && (_fx.w || _edr_left.w && _fx_left.w || _edr_up.w && _fx_up.w)); + _a0306 = _e1 - _b1.wxyz; + _TMP303 = abs(_a0306); + _a0310 = _e1 - _b1.zwxy; + _TMP307 = abs(_a0310); + _px = bvec4(_TMP303.x <= _TMP307.x, _TMP303.y <= _TMP307.y, _TMP303.z <= _TMP307.z, _TMP303.w <= _TMP307.w); + if (_nc.x) { // if begin + if (_px.x) { // if begin + _TMP47 = _F; + } else { + _TMP47 = _H; + } // end if + _TMP46 = _TMP47; + } else { + if (_nc.y) { // if begin + if (_px.y) { // if begin + _TMP49 = _B2; + } else { + _TMP49 = _F; + } // end if + _TMP48 = _TMP49; + } else { + if (_nc.z) { // if begin + if (_px.z) { // if begin + _TMP51 = _D; + } else { + _TMP51 = _B2; + } // end if + _TMP50 = _TMP51; + } else { + if (_nc.w) { // if begin + if (_px.w) { // if begin + _TMP53 = _H; + } else { + _TMP53 = _D; + } // end if + _TMP52 = _TMP53; + } else { + _TMP52 = _E; + } // end if + _TMP50 = _TMP52; + } // end if + _TMP48 = _TMP50; + } // end if + _TMP46 = _TMP48; + } // end if + _ret_0 = vec4(_TMP46.x, _TMP46.y, _TMP46.z, 1.00000000E+000); + gl_FragColor = vec4(float(_ret_0.x), float(_ret_0.y), float(_ret_0.z), float(_ret_0.w)); + return; +} // main end diff --git a/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slv b/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slv new file mode 100644 index 00000000..7c1d3e72 --- /dev/null +++ b/bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slv @@ -0,0 +1,9 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + v_texCoord = a_texCoord; +} diff --git a/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slf b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slf new file mode 100644 index 00000000..23db8357 --- /dev/null +++ b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slf @@ -0,0 +1,71 @@ +/* + AA shader v2.o + Natural Vision + + Copyright (C) 2006 guest(r) - guest.r@gmail.com + + part of code by ShadX + + 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. + +*/ + +#ifdef GL_ES +precision mediump float; +#endif + +uniform sampler2D Frame; + +const mat3 RGBtoYIQ = mat3(0.299, 0.596, 0.212, + 0.587,-0.275,-0.523, + 0.114,-0.321, 0.311); + +const mat3 YIQtoRGB = mat3(1.0, 1.0, 1.0, + 0.95568806036115671171,-0.27158179694405859326,-1.1081773266826619523, + 0.61985809445637075388,-0.64687381613840131330, 1.7050645599191817149); + +varying vec4 TexCoord[8]; + +const vec3 val00 = vec3( 1.2, 1.2, 1.2); + +void main() +{ + vec3 c00 = texture2D(Frame, TexCoord[5].xy).xyz; + vec3 c10 = texture2D(Frame, TexCoord[1].xy).xyz; + vec3 c20 = texture2D(Frame, TexCoord[2].zw).xyz; + vec3 c01 = texture2D(Frame, TexCoord[3].xy).xyz; + vec3 c11 = texture2D(Frame, TexCoord[0].xy).xyz; + vec3 c21 = texture2D(Frame, TexCoord[4].xy).xyz; + vec3 c02 = texture2D(Frame, TexCoord[1].zw).xyz; + vec3 c12 = texture2D(Frame, TexCoord[2].xy).xyz; + vec3 c22 = texture2D(Frame, TexCoord[6].xy).xyz; + vec3 dt = vec3(1.0,1.0,1.0); + + float d1=dot(abs(c00-c22),dt)+0.0001; + float d2=dot(abs(c20-c02),dt)+0.0001; + float hl=dot(abs(c01-c21),dt)+0.0001; + float vl=dot(abs(c10-c12),dt)+0.0001; + + float md = d1+d2; float mc = hl+vl; + hl*= md;vl*= md; d1*= mc;d2*= mc; + + float ww = d1+d2+hl+vl; + + c00 = RGBtoYIQ*((hl*(c10+c12)+vl*(c01+c21)+d1*(c20+c02)+d2*(c00+c22)+ww*c11)/(3.0*ww)); + + c00 = vec3(pow(c00.x,val00.x),c00.yz*val00.yz); + + gl_FragColor.xyz= YIQtoRGB*c00; +} + diff --git a/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slv b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slv new file mode 100644 index 00000000..c584391a --- /dev/null +++ b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slv @@ -0,0 +1,28 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec4 TexCoord[8]; + +void main() +{ + gl_Position = a_position; + + //float x = (OGL2Size.x/2048.0)*OGL2Param.x; + //float y = (OGL2Size.y/1024.0)*OGL2Param.y; + float x = a_texCoord.x/1024.0; + float y = a_texCoord.y/512.0; + vec2 dg1 = vec2( x,y); + vec2 dg2 = vec2(-x,y); + vec2 dx = vec2(x,0.0); + vec2 dy = vec2(0.0,y); + TexCoord[0].xy = a_texCoord; + TexCoord[1].xy = TexCoord[0].xy - dy; + TexCoord[2].xy = TexCoord[0].xy + dy; + TexCoord[3].xy = TexCoord[0].xy - dx; + TexCoord[4].xy = TexCoord[0].xy + dx; + TexCoord[5].xy = TexCoord[0].xy - dg1; + TexCoord[6].xy = TexCoord[0].xy + dg1; + TexCoord[1].zw = TexCoord[0].xy - dg2; + TexCoord[2].zw = TexCoord[0].xy + dg2; + +} + diff --git a/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slf b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slf new file mode 100644 index 00000000..8f12c4b3 --- /dev/null +++ b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slf @@ -0,0 +1,221 @@ +/* + AA shader v2.o + Natural Vision + + Copyright (C) 2006 guest(r) - guest.r@gmail.com + + part of code by ShadX + + 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. + +*/ + +#ifdef GL_ES +precision mediump float; +#endif + +//#define BR1 +#define BR2 +//#define BR3 + +uniform sampler2D Frame; + +const mat3 RGBtoYIQ = mat3(0.299, 0.596, 0.212, + 0.587,-0.275,-0.523, + 0.114,-0.321, 0.311); + +const mat3 YIQtoRGB = mat3(1.0, 1.0, 1.0, + 0.95568806036115671171,-0.27158179694405859326,-1.1081773266826619523, + 0.61985809445637075388,-0.64687381613840131330, 1.7050645599191817149); + +varying vec4 TexCoord[8]; + +const vec3 val00 = vec3( 1.2, 1.2, 1.2); + +void br3(in vec4 natural, out vec4 fragcolor) { +int LUT[33]; +LUT[0] = 0; +LUT[1] = 2; +LUT[2] = 4; +LUT[3] = 6; +LUT[4] = 8; +LUT[5] = 10; +LUT[6] = 12; +LUT[7] = 14; +LUT[8] = 16; +LUT[9] = 17; +LUT[10] = 17; +LUT[11] = 18; +LUT[12] = 19; +LUT[13] = 19; +LUT[14] = 20; +LUT[15] = 21; +LUT[16] = 21; +LUT[17] = 22; +LUT[18] = 23; +LUT[19] = 23; +LUT[20] = 24; +LUT[21] = 25; +LUT[22] = 25; +LUT[23] = 26; +LUT[24] = 27; +LUT[25] = 27; +LUT[26] = 28; +LUT[27] = 29; +LUT[28] = 29; +LUT[29] = 30; +LUT[30] = 30; +LUT[31] = 31; +LUT[32] = 31; + +vec4 rgb16 = natural * vec4(31.0, 31.0, 31.0, 1.0); +rgb16.r = float(LUT[int(rgb16.r)])+float(LUT[int(rgb16.r)+1]-LUT[int(rgb16.r)])*fract(rgb16.r); +rgb16.g = float(LUT[int(rgb16.g)])+float(LUT[int(rgb16.g)+1]-LUT[int(rgb16.g)])*fract(rgb16.g); +rgb16.b = float(LUT[int(rgb16.b)])+float(LUT[int(rgb16.b)+1]-LUT[int(rgb16.b)])*fract(rgb16.b); +fragcolor = rgb16 / vec4(31.0,31.0,31.0,1.0); +} + +void br2(in vec4 natural, out vec4 fragcolor) { +int LUT[33]; +LUT[0] = 0; +LUT[1] = 2; +LUT[2] = 4; +LUT[3] = 6; +LUT[4] = 8; +LUT[5] = 10; +LUT[6] = 11; +LUT[7] = 12; +LUT[8] = 13; +LUT[9] = 14; +LUT[10] = 15; +LUT[11] = 16; +LUT[12] = 17; +LUT[13] = 18; +LUT[14] = 19; +LUT[15] = 19; +LUT[16] = 20; +LUT[17] = 21; +LUT[18] = 22; +LUT[19] = 22; +LUT[20] = 23; +LUT[21] = 24; +LUT[22] = 25; +LUT[23] = 25; +LUT[24] = 26; +LUT[25] = 27; +LUT[26] = 28; +LUT[27] = 28; +LUT[28] = 29; +LUT[29] = 30; +LUT[30] = 30; +LUT[31] = 31; +LUT[32] = 31; + +vec4 rgb16 = natural * vec4(31.0, 31.0, 31.0, 1.0); +rgb16.r = float(LUT[int(rgb16.r)])+float(LUT[int(rgb16.r)+1]-LUT[int(rgb16.r)])*fract(rgb16.r); +rgb16.g = float(LUT[int(rgb16.g)])+float(LUT[int(rgb16.g)+1]-LUT[int(rgb16.g)])*fract(rgb16.g); +rgb16.b = float(LUT[int(rgb16.b)])+float(LUT[int(rgb16.b)+1]-LUT[int(rgb16.b)])*fract(rgb16.b); +fragcolor = rgb16 / vec4(31.0,31.0,31.0,1.0); +} + +void br1(in vec4 natural, out vec4 fragcolor) { +int LUT[33]; +LUT[0] = 0; +LUT[1] = 2; +LUT[2] = 4; +LUT[3] = 5; +LUT[4] = 7; +LUT[5] = 8; +LUT[6] = 9; +LUT[7] = 10; +LUT[8] = 11; +LUT[9] = 12; +LUT[10] = 13; +LUT[11] = 14; +LUT[12] = 15; +LUT[13] = 16; +LUT[14] = 17; +LUT[15] = 17; +LUT[16] = 18; +LUT[17] = 19; +LUT[18] = 20; +LUT[19] = 21; +LUT[20] = 22; +LUT[21] = 23; +LUT[22] = 24; +LUT[23] = 24; +LUT[24] = 25; +LUT[25] = 26; +LUT[26] = 27; +LUT[27] = 28; +LUT[28] = 29; +LUT[29] = 30; +LUT[30] = 30; +LUT[31] = 31; +LUT[32] = 31; + +vec4 rgb16 = natural * vec4(31.0, 31.0, 31.0, 1.0); +rgb16.r = float(LUT[int(rgb16.r)])+float(LUT[int(rgb16.r)+1]-LUT[int(rgb16.r)])*fract(rgb16.r); +rgb16.g = float(LUT[int(rgb16.g)])+float(LUT[int(rgb16.g)+1]-LUT[int(rgb16.g)])*fract(rgb16.g); +rgb16.b = float(LUT[int(rgb16.b)])+float(LUT[int(rgb16.b)+1]-LUT[int(rgb16.b)])*fract(rgb16.b); +fragcolor = rgb16 / vec4(31.0,31.0,31.0,1.0); +} + + +void main() +{ + vec3 c00 = texture2D(Frame, TexCoord[5].xy).xyz; + vec3 c10 = texture2D(Frame, TexCoord[1].xy).xyz; + vec3 c20 = texture2D(Frame, TexCoord[2].zw).xyz; + vec3 c01 = texture2D(Frame, TexCoord[3].xy).xyz; + vec3 c11 = texture2D(Frame, TexCoord[0].xy).xyz; + vec3 c21 = texture2D(Frame, TexCoord[4].xy).xyz; + vec3 c02 = texture2D(Frame, TexCoord[1].zw).xyz; + vec3 c12 = texture2D(Frame, TexCoord[2].xy).xyz; + vec3 c22 = texture2D(Frame, TexCoord[6].xy).xyz; + vec3 dt = vec3(1.0,1.0,1.0); + + float d1=dot(abs(c00-c22),dt)+0.0001; + float d2=dot(abs(c20-c02),dt)+0.0001; + float hl=dot(abs(c01-c21),dt)+0.0001; + float vl=dot(abs(c10-c12),dt)+0.0001; + + float md = d1+d2; float mc = hl+vl; + hl*= md;vl*= md; d1*= mc;d2*= mc; + + float ww = d1+d2+hl+vl; + + c00 = RGBtoYIQ*((hl*(c10+c12)+vl*(c01+c21)+d1*(c20+c02)+d2*(c00+c22)+ww*c11)/(3.0*ww)); + + c00 = vec3(pow(c00.x,val00.x),c00.yz*val00.yz); + + vec4 natural; + natural.xyz= YIQtoRGB*c00; + vec4 rgb32 = natural; + +#ifdef BR1 + br1(natural,rgb32); +#else +#ifdef BR2 + br2(natural, rgb32); +#else +#ifdef BR3 + br3(natural, rgb32); +#endif +#endif +#endif + + gl_FragColor = rgb32; +} + diff --git a/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slv b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slv new file mode 100644 index 00000000..c584391a --- /dev/null +++ b/bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slv @@ -0,0 +1,28 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec4 TexCoord[8]; + +void main() +{ + gl_Position = a_position; + + //float x = (OGL2Size.x/2048.0)*OGL2Param.x; + //float y = (OGL2Size.y/1024.0)*OGL2Param.y; + float x = a_texCoord.x/1024.0; + float y = a_texCoord.y/512.0; + vec2 dg1 = vec2( x,y); + vec2 dg2 = vec2(-x,y); + vec2 dx = vec2(x,0.0); + vec2 dy = vec2(0.0,y); + TexCoord[0].xy = a_texCoord; + TexCoord[1].xy = TexCoord[0].xy - dy; + TexCoord[2].xy = TexCoord[0].xy + dy; + TexCoord[3].xy = TexCoord[0].xy - dx; + TexCoord[4].xy = TexCoord[0].xy + dx; + TexCoord[5].xy = TexCoord[0].xy - dg1; + TexCoord[6].xy = TexCoord[0].xy + dg1; + TexCoord[1].zw = TexCoord[0].xy - dg2; + TexCoord[2].zw = TexCoord[0].xy + dg2; + +} + diff --git a/bios/Other/epsxe/shaders/Brightness/gpuCore.ini b/bios/Other/epsxe/shaders/Brightness/gpuCore.ini new file mode 100644 index 00000000..87d02e2e --- /dev/null +++ b/bios/Other/epsxe/shaders/Brightness/gpuCore.ini @@ -0,0 +1,4 @@ +name=Brightness +version=1 +license=BSD +copyright=ePSXe Team diff --git a/bios/Other/epsxe/shaders/Brightness/gpuCore.slf b/bios/Other/epsxe/shaders/Brightness/gpuCore.slf new file mode 100644 index 00000000..7fe30759 --- /dev/null +++ b/bios/Other/epsxe/shaders/Brightness/gpuCore.slf @@ -0,0 +1,162 @@ +#ifdef GL_ES +precision mediump float; +#endif + +//#define BR1 +#define BR2 +//#define BR3 + +varying vec2 v_texCoord; +uniform sampler2D Frame; + +void br3(in vec4 natural, out vec4 fragcolor) { +int LUT[33]; +LUT[0] = 0; +LUT[1] = 2; +LUT[2] = 4; +LUT[3] = 6; +LUT[4] = 8; +LUT[5] = 10; +LUT[6] = 12; +LUT[7] = 14; +LUT[8] = 16; +LUT[9] = 17; +LUT[10] = 17; +LUT[11] = 18; +LUT[12] = 19; +LUT[13] = 19; +LUT[14] = 20; +LUT[15] = 21; +LUT[16] = 21; +LUT[17] = 22; +LUT[18] = 23; +LUT[19] = 23; +LUT[20] = 24; +LUT[21] = 25; +LUT[22] = 25; +LUT[23] = 26; +LUT[24] = 27; +LUT[25] = 27; +LUT[26] = 28; +LUT[27] = 29; +LUT[28] = 29; +LUT[29] = 30; +LUT[30] = 30; +LUT[31] = 31; +LUT[32] = 31; + +vec4 rgb16 = natural * vec4(31.0, 31.0, 31.0, 1.0); +rgb16.r = float(LUT[int(rgb16.r)])+float(LUT[int(rgb16.r)+1]-LUT[int(rgb16.r)])*fract(rgb16.r); +rgb16.g = float(LUT[int(rgb16.g)])+float(LUT[int(rgb16.g)+1]-LUT[int(rgb16.g)])*fract(rgb16.g); +rgb16.b = float(LUT[int(rgb16.b)])+float(LUT[int(rgb16.b)+1]-LUT[int(rgb16.b)])*fract(rgb16.b); +fragcolor = rgb16 / vec4(31.0,31.0,31.0,1.0); +} + +void br2(in vec4 natural, out vec4 fragcolor) { +int LUT[33]; +LUT[0] = 0; +LUT[1] = 2; +LUT[2] = 4; +LUT[3] = 6; +LUT[4] = 8; +LUT[5] = 10; +LUT[6] = 11; +LUT[7] = 12; +LUT[8] = 13; +LUT[9] = 14; +LUT[10] = 15; +LUT[11] = 16; +LUT[12] = 17; +LUT[13] = 18; +LUT[14] = 19; +LUT[15] = 19; +LUT[16] = 20; +LUT[17] = 21; +LUT[18] = 22; +LUT[19] = 22; +LUT[20] = 23; +LUT[21] = 24; +LUT[22] = 25; +LUT[23] = 25; +LUT[24] = 26; +LUT[25] = 27; +LUT[26] = 28; +LUT[27] = 28; +LUT[28] = 29; +LUT[29] = 30; +LUT[30] = 30; +LUT[31] = 31; +LUT[32] = 31; + +vec4 rgb16 = natural * vec4(31.0, 31.0, 31.0, 1.0); +rgb16.r = float(LUT[int(rgb16.r)])+float(LUT[int(rgb16.r)+1]-LUT[int(rgb16.r)])*fract(rgb16.r); +rgb16.g = float(LUT[int(rgb16.g)])+float(LUT[int(rgb16.g)+1]-LUT[int(rgb16.g)])*fract(rgb16.g); +rgb16.b = float(LUT[int(rgb16.b)])+float(LUT[int(rgb16.b)+1]-LUT[int(rgb16.b)])*fract(rgb16.b); +fragcolor = rgb16 / vec4(31.0,31.0,31.0,1.0); +} + +void br1(in vec4 natural, out vec4 fragcolor) { +int LUT[33]; +LUT[0] = 0; +LUT[1] = 2; +LUT[2] = 4; +LUT[3] = 5; +LUT[4] = 7; +LUT[5] = 8; +LUT[6] = 9; +LUT[7] = 10; +LUT[8] = 11; +LUT[9] = 12; +LUT[10] = 13; +LUT[11] = 14; +LUT[12] = 15; +LUT[13] = 16; +LUT[14] = 17; +LUT[15] = 17; +LUT[16] = 18; +LUT[17] = 19; +LUT[18] = 20; +LUT[19] = 21; +LUT[20] = 22; +LUT[21] = 23; +LUT[22] = 24; +LUT[23] = 24; +LUT[24] = 25; +LUT[25] = 26; +LUT[26] = 27; +LUT[27] = 28; +LUT[28] = 29; +LUT[29] = 30; +LUT[30] = 30; +LUT[31] = 31; +LUT[32] = 31; + +vec4 rgb16 = natural * vec4(31.0, 31.0, 31.0, 1.0); +rgb16.r = float(LUT[int(rgb16.r)])+float(LUT[int(rgb16.r)+1]-LUT[int(rgb16.r)])*fract(rgb16.r); +rgb16.g = float(LUT[int(rgb16.g)])+float(LUT[int(rgb16.g)+1]-LUT[int(rgb16.g)])*fract(rgb16.g); +rgb16.b = float(LUT[int(rgb16.b)])+float(LUT[int(rgb16.b)+1]-LUT[int(rgb16.b)])*fract(rgb16.b); +fragcolor = rgb16 / vec4(31.0,31.0,31.0,1.0); +} + + +void main() +{ + vec4 natural = texture2D(Frame, v_texCoord); + vec4 rgb32 = natural; + +#ifdef BR1 + br1(natural,rgb32); +#else +#ifdef BR2 + br2(natural, rgb32); +#else +#ifdef BR3 + br3(natural, rgb32); +#endif +#endif +#endif + + gl_FragColor = rgb32; +} + + diff --git a/bios/Other/epsxe/shaders/Brightness/gpuCore.slv b/bios/Other/epsxe/shaders/Brightness/gpuCore.slv new file mode 100644 index 00000000..7c1d3e72 --- /dev/null +++ b/bios/Other/epsxe/shaders/Brightness/gpuCore.slv @@ -0,0 +1,9 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + v_texCoord = a_texCoord; +} diff --git a/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.ini b/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.ini new file mode 100644 index 00000000..074d913d --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.ini @@ -0,0 +1,4 @@ +name=CRT Hyllian 3D +version=1 +license=Public Domain +copyright=Hyllian diff --git a/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slf b/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slf new file mode 100644 index 00000000..35c62cd8 --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slf @@ -0,0 +1,301 @@ +/* + Hyllian's CRT Shader + + Copyright (C) 2011-2015 Hyllian - sergiogdb@gmail.com + + 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. + +*/ + +#version 100 + +#ifdef GL_ES +precision mediump float; +#endif + +// Uncomment to enable anti-ringing to horizontal filter. +//#define ANTI_RINGING + +// Comment next line if you don't desire the phosphor effect. +//#define PHOSPHOR + +// Uncomment to enable adjustment of red and green saturation. +//#define RED_GREEN_CONTROL + +#define InputGamma 2.4 +#define OutputGamma 2.2 +#define RED_BOOST 1.0 +#define GREEN_BOOST 1.0 +#define SCANLINES_STRENGTH 0.72 +#define BEAM_MIN_WIDTH 0.86 +#define BEAM_MAX_WIDTH 1.0 +#define COLOR_BOOST 1.5 +#define CRT_TV_BLUE_TINT 1.0 + + +#define GAMMA_IN(color) pow(color, vec3(InputGamma, InputGamma, InputGamma)) +#define GAMMA_OUT(color) pow(color, vec3(1.0 / OutputGamma, 1.0 / OutputGamma, 1.0 / OutputGamma)) + +const vec3 dtt = vec3(65536,255,1); + + +// Horizontal cubic filter. + +// Some known filters use these values: + +// B = 0.0, C = 0.0 => Hermite cubic filter. +// B = 1.0, C = 0.0 => Cubic B-Spline filter. +// B = 0.0, C = 0.5 => Catmull-Rom Spline filter. This is the default used in this shader. +// B = C = 1.0/3.0 => Mitchell-Netravali cubic filter. +// B = 0.3782, C = 0.3109 => Robidoux filter. +// B = 0.2620, C = 0.3690 => Robidoux Sharp filter. +// B = 0.36, C = 0.28 => My best config for ringing elimination in pixel art (Hyllian). + + +// For more info, see: http://www.imagemagick.org/Usage/img_diagrams/cubic_survey.gif + +// Change these params to configure the horizontal filter. +const float B = 0.0; +const float C = 0.5; + +/* +const mat4 invX = mat4( (-B - 6.0*C)/6.0, (3.0*B + 12.0*C)/6.0, (-3.0*B - 6.0*C)/6.0, B/6.0, + (12.0 - 9.0*B - 6.0*C)/6.0, (-18.0 + 12.0*B + 6.0*C)/6.0, 0.0, (6.0 - 2.0*B)/6.0, + -(12.0 - 9.0*B - 6.0*C)/6.0, (18.0 - 15.0*B - 12.0*C)/6.0, (3.0*B + 6.0*C)/6.0, B/6.0, + (B + 6.0*C)/6.0, -C, 0.0, 0.0); + +*/ +const mat4 invX = mat4( (-B - 6.0*C)/6.0, (12.0 - 9.0*B - 6.0*C)/6.0, -(12.0 - 9.0*B - 6.0*C)/6.0, (B + 6.0*C)/6.0, + (3.0*B + 12.0*C)/6.0, (-18.0 + 12.0*B + 6.0*C)/6.0, (18.0 - 15.0*B - 12.0*C)/6.0, -C, + (-3.0*B - 6.0*C)/6.0, 0.0, (3.0*B + 6.0*C)/6.0, 0.0, + B/6.0, (6.0 - 2.0*B)/6.0, B/6.0, 0.0); + + +/* +const static float4x4 invX = float4x4( (-B - 6.0*C)/6.0, (3.0*B + 12.0*C)/6.0, (-3.0*B - 6.0*C)/6.0, B/6.0, + (12.0 - 9.0*B - 6.0*C)/6.0, (-18.0 + 12.0*B + 6.0*C)/6.0, 0.0, (6.0 - 2.0*B)/6.0, + -(12.0 - 9.0*B - 6.0*C)/6.0, (18.0 - 15.0*B - 12.0*C)/6.0, (3.0*B + 6.0*C)/6.0, B/6.0, + (B + 6.0*C)/6.0, -C, 0.0, 0.0); + +*/ + +const float halfpi = 1.5707963267948966192313216916398; +const float pi = 3.1415926535897932384626433832795; +const float JINC2_WINDOW_SINC = 0.42; +const float JINC2_SINC = 0.92; +const float wa = JINC2_WINDOW_SINC*pi; +const float wb = JINC2_SINC*pi; +const float JINC2_AR_STRENGTH = 0.8; + +/* +const vec2 OGLSize = vec2( 4096.0, 2048.0 ); + +const vec2 OGLInvSize = vec2( 1.0/4096.0, 1.0/2048.0 ); + +const vec2 dx = vec2( 1.0/4096.0, 0.0 ); + +const vec2 dy = vec2( 0.0, 1.0/2048.0 ); + +*/ +/* +const vec2 OGLSize = vec2( 1024.0, 512.0); + +const vec2 OGLInvSize = vec2( 0.0009765625, 0.001953125); + +const vec2 dx = vec2( 0.0009765625, 0.0); + +const vec2 dy = vec2( 0.0, 0.001953125 ); + +*/ + +//uniform vec4 OGL2InvSize; +//uniform vec4 OGL2Size; + +varying vec2 v_texCoord; + +float reduce(vec3 A) +{ + return dot(A, dtt); +} + + +// Calculates the distance between two points +float d(vec2 pt1, vec2 pt2) +{ + vec2 v = pt2 - pt1; + return sqrt(dot(v,v)); +} + +vec3 min4(vec3 a, vec3 b, vec3 c, vec3 d) +{ + return min(a, min(b, min(c, d))); +} + +vec3 max4(vec3 a, vec3 b, vec3 c, vec3 d) +{ + return max(a, max(b, max(c, d))); +} + +vec4 resampler(vec4 x) +{ + vec4 res; + + res = (x==vec4(0.0, 0.0, 0.0, 0.0)) ? vec4(wa*wb) : sin(x*wa)*sin(x*wb)/(x*x); + + return res; +} + + + +uniform sampler2D Sample; + +void main() +{ + vec3 color, E; + vec2 OGL2Size = vec2(1024, 512); + vec2 OGL2InvSize = 1.0/OGL2Size; + + vec2 dx = vec2(OGL2InvSize.x,0.0); + vec2 dy = vec2(0.0, OGL2InvSize.y); + + vec2 pix_coord = v_texCoord.xy*OGL2Size+vec2(-0.5,0.5); + vec2 tex = (floor(v_texCoord.xy*OGL2Size) + vec2(0.5, 0.5))/OGL2Size; + + vec2 tc = (floor(pix_coord)+vec2(0.5,0.5))/OGL2Size; + + vec2 fp = fract(pix_coord); + + vec4 c00 = vec4(GAMMA_IN(texture2D(Sample, tc - dx - dy).xyz),1.0); + vec4 c01 = vec4(GAMMA_IN(texture2D(Sample, tc - dy).xyz),1.0); + vec4 c02 = vec4(GAMMA_IN(texture2D(Sample, tc + dx - dy).xyz),1.0); + vec4 c03 = vec4(GAMMA_IN(texture2D(Sample, tc + 2.0*dx - dy).xyz),1.0); + vec4 c10 = vec4(GAMMA_IN(texture2D(Sample, tc - dx).xyz),1.0); + vec4 c11 = vec4(GAMMA_IN(texture2D(Sample, tc ).xyz),1.0); + vec4 c12 = vec4(GAMMA_IN(texture2D(Sample, tc + dx).xyz),1.0); + vec4 c13 = vec4(GAMMA_IN(texture2D(Sample, tc + 2.0*dx).xyz),1.0); + + color = E = GAMMA_IN(texture2D(Sample, v_texCoord.xy).xyz); + + vec3 F0 = texture2D(Sample, tex +dx+0.25*dx +0.25*dy).xyz; + vec3 F1 = texture2D(Sample, tex +dx+0.25*dx -0.25*dy).xyz; + vec3 F2 = texture2D(Sample, tex +dx-0.25*dx -0.25*dy).xyz; + vec3 F3 = texture2D(Sample, tex +dx-0.25*dx +0.25*dy).xyz; + + vec3 H0 = texture2D(Sample, tex +0.25*dx +0.25*dy+dy).xyz; + vec3 H1 = texture2D(Sample, tex +0.25*dx -0.25*dy+dy).xyz; + vec3 H2 = texture2D(Sample, tex -0.25*dx -0.25*dy+dy).xyz; + vec3 H3 = texture2D(Sample, tex -0.25*dx +0.25*dy+dy).xyz; + + float f0 = reduce(F0); + float f1 = reduce(F1); + float f2 = reduce(F2); + float f3 = reduce(F3); + + float h0 = reduce(H0); + float h1 = reduce(H1); + float h2 = reduce(H2); + float h3 = reduce(H3); + + float block_3d = (float(f0==f1)*float(f1==f2)*float(f2==f3)*float(h0==h1)*float(h1==h2)*float(h2==h3)); + + +#ifdef ANTI_RINGING + // Get min/max samples + vec4 min_sample = min(min(c01,c11), min(c02,c12)); + vec4 max_sample = max(max(c01,c11), max(c02,c12)); +// vec4 min_sample = min(min(c01,c11), min(c02,c12)) + (c10-c11)*(c12-c13); +// vec4 max_sample = max(max(c01,c11), max(c02,c12)) - (c10-c11)*(c12-c13); +#endif +; + + mat4 color_matrix0 = mat4(c00, c01, c02, c03); + mat4 color_matrix1 = mat4(c10, c11, c12, c13); + + vec4 lobes = vec4(fp.x*fp.x*fp.x, fp.x*fp.x, fp.x, 1.0); + + vec4 invX_Px = invX * lobes; + vec4 color0x = color_matrix0 * invX_Px; + vec4 color1x = color_matrix1 * invX_Px; + vec3 color0 = color0x.xyz; + vec3 color1 = color1x.xyz; + + +/* + vec4 invX_Px = vec4(dot(invX[0], poli), dot(invX[1], poli), dot(invX[2], poli), dot(invX[3], poli)); + vec3 color0 = vec3(dot(color_matrix0[0], invX_Px), dot(color_matrix0[1], invX_Px), dot(color_matrix0[2], invX_Px)); + vec3 color1 = vec3(dot(color_matrix1[0], invX_Px), dot(color_matrix1[1], invX_Px), dot(color_matrix1[2], invX_Px)); +*/ + +/* + float4x3 color_matrix0 = float4x3(c00, c01, c02, c03); + float4x3 color_matrix1 = float4x3(c10, c11, c12, c13); + + float4 invX_Px = mul(invX, float4(fp.x*fp.x*fp.x, fp.x*fp.x, fp.x, 1.0)); + float3 color0 = mul(invX_Px, color_matrix0); + float3 color1 = mul(invX_Px, color_matrix1); +*/ + +#ifdef ANTI_RINGING + // Anti-ringing + color0 = clamp(color0, min_sample, max_sample); + color1 = clamp(color1, min_sample, max_sample); +#endif + + float pos0 = fp.y; + float pos1 = 1.0 - fp.y; + + vec3 lum0 = mix(vec3(BEAM_MIN_WIDTH), vec3(BEAM_MAX_WIDTH), color0); + vec3 lum1 = mix(vec3(BEAM_MIN_WIDTH), vec3(BEAM_MAX_WIDTH), color1); + + vec3 d0 = clamp(pos0/(lum0+0.0000001), 0.0, 1.0); + vec3 d1 = clamp(pos1/(lum1+0.0000001), 0.0, 1.0); + + d0 = exp(-10.0*SCANLINES_STRENGTH*d0*d0); + d1 = exp(-10.0*SCANLINES_STRENGTH*d1*d1); + + color = clamp(color0*d0+color1*d1, 0.0, 1.0); + + color *= COLOR_BOOST; + +#ifdef RED_GREEN_CONTROL + color.rgb *= vec3(RED_BOOST, GREEN_BOOST, CRT_TV_BLUE_TINT); +#else + color.b *= CRT_TV_BLUE_TINT; +#endif + +#ifdef PHOSPHOR + float mod_factor = VAR.texCoord.x * IN.output_size.x * IN.texture_size.x / IN.video_size.x; + + vec3 dotMaskWeights = mix( + vec3(1.0, 0.7, 1.0), + vec3(0.7, 1.0, 0.7), + floor(fmod(mod_factor, 2.0)) + ); + + color.rgb *= dotMaskWeights; +#endif + + if (block_3d!=0.0) color = E; + //color = block_3d ? color : E; + + color = GAMMA_OUT(color); + + // final sum and weight normalization + gl_FragColor.xyz = color; +} diff --git a/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slv b/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slv new file mode 100644 index 00000000..3d052ebb --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slv @@ -0,0 +1,15 @@ +#ifdef GL_ES +precision mediump float; +#endif + +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + + v_texCoord = a_texCoord; +} + diff --git a/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.ini b/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.ini new file mode 100644 index 00000000..aa164cd6 --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.ini @@ -0,0 +1,5 @@ +name=CRT Hyllian +version=1 +license=Free +copyright=Hyllian +filter_linear=0 diff --git a/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slf b/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slf new file mode 100644 index 00000000..a45fc575 --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slf @@ -0,0 +1,161 @@ +#ifdef GL_ES +precision mediump float; +#endif + +#define PHOSPHOR 0.0 +#define InputGamma 2.4 +#define OutputGamma 2.2 +#define SHARPNESS 1.0 +#define COLOR_BOOST 1.5 +#define RED_BOOST 1.0 +#define GREEN_BOOST 1.0 +#define BLUE_BOOST 1.0 +#define SCANLINES_STRENGTH 0.72 +#define BEAM_MIN_WIDTH 0.86 +#define BEAM_MAX_WIDTH 1.0 +#define CRT_ANTI_RINGING 1.0 + +/* + Hyllian's CRT Shader + + Copyright (C) 2011-2016 Hyllian - sergiogdb@gmail.com + + 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. + +*/ + +#define GAMMA_IN(color) pow(color, vec3(InputGamma, InputGamma, InputGamma)) +#define GAMMA_OUT(color) pow(color, vec3(1.0 / OutputGamma, 1.0 / OutputGamma, 1.0 / OutputGamma)) + +// Horizontal cubic filter. + +// Some known filters use these values: + +// B = 0.0, C = 0.0 => Hermite cubic filter. +// B = 1.0, C = 0.0 => Cubic B-Spline filter. +// B = 0.0, C = 0.5 => Catmull-Rom Spline filter. This is the default used in this shader. +// B = C = 1.0/3.0 => Mitchell-Netravali cubic filter. +// B = 0.3782, C = 0.3109 => Robidoux filter. +// B = 0.2620, C = 0.3690 => Robidoux Sharp filter. +// B = 0.36, C = 0.28 => My best config for ringing elimination in pixel art (Hyllian). + + +// For more info, see: http://www.imagemagick.org/Usage/img_diagrams/cubic_survey.gif + +// Change these params to configure the horizontal filter. +const float B = 0.0; +const float C = 0.5; + +const mat4 invX = mat4( (-B - 6.0*C)/6.0, (12.0 - 9.0*B - 6.0*C)/6.0, -(12.0 - 9.0*B - 6.0*C)/6.0, (B + 6.0*C)/6.0, + (3.0*B + 12.0*C)/6.0, (-18.0 + 12.0*B + 6.0*C)/6.0, (18.0 - 15.0*B - 12.0*C)/6.0, -C, + (-3.0*B - 6.0*C)/6.0, 0.0, (3.0*B + 6.0*C)/6.0, 0.0, + B/6.0, (6.0 - 2.0*B)/6.0, B/6.0, 0.0); + +struct inputdata +{ + vec2 video_size; + vec2 texture_size; + vec2 output_size; + float frame_count; + float frame_direction; + float frame_rotation; +}; + +varying vec2 v_texCoord; +uniform sampler2D Sample; +uniform inputdata IN; + +void main() +{ + vec2 TextureSize = vec2(SHARPNESS*IN.texture_size.x, IN.texture_size.y); +// vec2 TextureSize = vec2(SHARPNESS*1024.0, 512.0); + + vec3 color; + vec2 dx = vec2(1.0/TextureSize.x, 0.0); + vec2 dy = vec2(0.0, 1.0/TextureSize.y); + vec2 pix_coord = v_texCoord*TextureSize+vec2(-0.5,0.5); + + vec2 tc = (floor(pix_coord)+vec2(0.5,0.5))/TextureSize; + + vec2 fp = fract(pix_coord); + + vec4 c00 = vec4(GAMMA_IN(texture2D(Sample, tc - dx - dy).xyz),1.0); + vec4 c01 = vec4(GAMMA_IN(texture2D(Sample, tc - dy).xyz),1.0); + vec4 c02 = vec4(GAMMA_IN(texture2D(Sample, tc + dx - dy).xyz),1.0); + vec4 c03 = vec4(GAMMA_IN(texture2D(Sample, tc + 2.0*dx - dy).xyz),1.0); + vec4 c10 = vec4(GAMMA_IN(texture2D(Sample, tc - dx).xyz),1.0); + vec4 c11 = vec4(GAMMA_IN(texture2D(Sample, tc ).xyz),1.0); + vec4 c12 = vec4(GAMMA_IN(texture2D(Sample, tc + dx).xyz),1.0); + vec4 c13 = vec4(GAMMA_IN(texture2D(Sample, tc + 2.0*dx).xyz),1.0); + + + // Get min/max samples + vec4 min_sample = min(min(c01,c11), min(c02,c12)); + vec4 max_sample = max(max(c01,c11), max(c02,c12)); + + mat4 color_matrix0 = mat4(c00, c01, c02, c03); + mat4 color_matrix1 = mat4(c10, c11, c12, c13); + + vec4 lobes = vec4(fp.x*fp.x*fp.x, fp.x*fp.x, fp.x, 1.0); + + vec4 invX_Px = invX * lobes; + vec4 color0 = color_matrix0 * invX_Px; + vec4 color1 = color_matrix1 * invX_Px; + + // Anti-ringing + vec4 aux = color0; + color0 = clamp(color0, min_sample, max_sample); + color0 = mix(aux, color0, CRT_ANTI_RINGING); + aux = color1; + color1 = clamp(color1, min_sample, max_sample); + color1 = mix(aux, color1, CRT_ANTI_RINGING); + + float pos0 = fp.y; + float pos1 = 1.0 - fp.y; + + vec3 color0x = color0.rgb; + vec3 color1x = color1.rgb; + + vec3 lum0 = mix(vec3(BEAM_MIN_WIDTH), vec3(BEAM_MAX_WIDTH), color0x); + vec3 lum1 = mix(vec3(BEAM_MIN_WIDTH), vec3(BEAM_MAX_WIDTH), color1x); + + vec3 d0 = clamp(pos0/(lum0+0.0000001), 0.0, 1.0); + vec3 d1 = clamp(pos1/(lum1+0.0000001), 0.0, 1.0); + + d0 = exp(-10.0*SCANLINES_STRENGTH*d0*d0); + d1 = exp(-10.0*SCANLINES_STRENGTH*d1*d1); + + color = clamp(color0x*d0+color1x*d1, 0.0, 1.0); + + color *= COLOR_BOOST*vec3(RED_BOOST, GREEN_BOOST, BLUE_BOOST); + + float mod_factor = v_texCoord.x * IN.output_size.x * IN.texture_size.x / IN.video_size.x; + + vec3 dotMaskWeights = mix( + vec3(1.0, 0.7, 1.0), + vec3(0.7, 1.0, 0.7), + floor(mod(mod_factor, 2.0)) + ); + + color.rgb *= mix(vec3(1.0,1.0,1.0), dotMaskWeights, PHOSPHOR); + + color = GAMMA_OUT(color); + + gl_FragColor = vec4(color, 1.0); +} diff --git a/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slv b/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slv new file mode 100644 index 00000000..3d052ebb --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slv @@ -0,0 +1,15 @@ +#ifdef GL_ES +precision mediump float; +#endif + +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + + v_texCoord = a_texCoord; +} + diff --git a/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.ini b/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.ini new file mode 100644 index 00000000..d4d09eb5 --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.ini @@ -0,0 +1,4 @@ +name=CRT Lottes +version=1 +license=Public Domain +copyright=Lottes diff --git a/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slf b/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slf new file mode 100644 index 00000000..bc96b505 --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slf @@ -0,0 +1,160 @@ +// +// PUBLIC DOMAIN CRT STYLED SCAN-LINE SHADER +// +// by Timothy Lottes +// +// This is more along the style of a really good CGA arcade monitor. +// With RGB inputs instead of NTSC. +// The shadow mask example has the mask rotated 90 degrees for less chromatic aberration. +// +// Left it unoptimized to show the theory behind the algorithm. +// +// It is an example what I personally would want as a display option for pixel art games. +// Please take and use, change, or whatever. +// + +#ifdef GL_ES +precision mediump float; +#endif + +#define hardScan -8.0 +#define hardPix -3.0 +#define warpX 0.031 +#define warpY 0.041 +#define maskDark 0.5 +#define maskLight 1.5 +#define scaleInLinearGamma 1 +#define shadowMask 1.0 +#define brightboost 1.0 + +struct inputdata +{ + vec2 video_size; + vec2 texture_size; + vec2 output_size; + float frame_count; + float frame_direction; + float frame_rotation; +}; + +uniform sampler2D Sample; +varying vec2 v_texCoord; +uniform inputdata IN; + +#define warp vec2(warpX,warpY) + +//------------------------------------------------------------------------ + +// sRGB to Linear. +// Assuing using sRGB typed textures this should not be needed. +float ToLinear1(float c) +{ + if (scaleInLinearGamma==0) return c; + return(c<=0.04045)?c/12.92:pow((c+0.055)/1.055,2.4); +} +vec3 ToLinear(vec3 c) +{ + if (scaleInLinearGamma==0) return c; + return vec3(ToLinear1(c.r),ToLinear1(c.g),ToLinear1(c.b)); +} + +// Linear to sRGB. +// Assuing using sRGB typed textures this should not be needed. +float ToSrgb1(float c) +{ + if (scaleInLinearGamma==0) return c; + return(c<0.0031308?c*12.92:1.055*pow(c,0.41666)-0.055); +} + +vec3 ToSrgb(vec3 c) +{ + if (scaleInLinearGamma==0) return c; + return vec3(ToSrgb1(c.r),ToSrgb1(c.g),ToSrgb1(c.b)); +} + +// Nearest emulated sample given floating point position and texel offset. +// Also zero's off screen. +vec3 Fetch(vec2 pos,vec2 off){ + pos=(floor(pos*IN.texture_size.xy+off)+vec2(0.5,0.5))/IN.texture_size.xy; + return ToLinear(brightboost * texture2D(Sample,pos.xy).rgb); +} + +// Distance in emulated pixels to nearest texel. +vec2 Dist(vec2 pos){pos=pos*IN.texture_size.xy;return -((pos-floor(pos))-vec2(0.5));} + +// 1D Gaussian. +float Gaus(float pos,float scale){return exp2(scale*pos*pos);} + +// 3-tap Gaussian filter along horz line. +vec3 Horz3(vec2 pos,float off){ + vec3 b=Fetch(pos,vec2(-1.0,off)); + vec3 c=Fetch(pos,vec2( 0.0,off)); + vec3 d=Fetch(pos,vec2( 1.0,off)); + float dst=Dist(pos).x; + // Convert distance to weight. + float scale=hardPix; + float wb=Gaus(dst-1.0,scale); + float wc=Gaus(dst+0.0,scale); + float wd=Gaus(dst+1.0,scale); + // Return filtered sample. + return (b*wb+c*wc+d*wd)/(wb+wc+wd);} + +// 5-tap Gaussian filter along horz line. +vec3 Horz5(vec2 pos,float off){ + vec3 a=Fetch(pos,vec2(-2.0,off)); + vec3 b=Fetch(pos,vec2(-1.0,off)); + vec3 c=Fetch(pos,vec2( 0.0,off)); + vec3 d=Fetch(pos,vec2( 1.0,off)); + vec3 e=Fetch(pos,vec2( 2.0,off)); + float dst=Dist(pos).x; + // Convert distance to weight. + float scale=hardPix; + float wa=Gaus(dst-2.0,scale); + float wb=Gaus(dst-1.0,scale); + float wc=Gaus(dst+0.0,scale); + float wd=Gaus(dst+1.0,scale); + float we=Gaus(dst+2.0,scale); + // Return filtered sample. + return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);} + +// Return scanline weight. +float Scan(vec2 pos,float off){ + float dst=Dist(pos).y; + return Gaus(dst+off,hardScan);} + +// Allow nearest three lines to effect pixel. +vec3 Tri(vec2 pos){ + vec3 a=Horz3(pos,-1.0); + vec3 b=Horz5(pos, 0.0); + vec3 c=Horz3(pos, 1.0); + float wa=Scan(pos,-1.0); + float wb=Scan(pos, 0.0); + float wc=Scan(pos, 1.0); + return a*wa+b*wb+c*wc;} + +// Distortion of scanlines, and end of screen alpha. +vec2 Warp(vec2 pos){ + pos=pos*2.0-1.0; + pos*=vec2(1.0+(pos.y*pos.y)*warp.x,1.0+(pos.x*pos.x)*warp.y); + return pos*0.5+0.5;} + +// Shadow mask. +vec3 Mask(vec2 pos){ + pos.x+=pos.y*3.0; + vec3 mask=vec3(maskDark,maskDark,maskDark); + pos.x=fract(pos.x/6.0); + if(pos.x<0.333)mask.r=maskLight; + else if(pos.x<0.666)mask.g=maskLight; + else mask.b=maskLight; + return mask;} + +void main() +{ + vec2 pos=Warp(v_texCoord.xy*(IN.texture_size.xy/IN.video_size.xy))*(IN.video_size.xy/IN.texture_size.xy); + vec3 outColor = Tri(pos); + + if(shadowMask != 0.0) + outColor.rgb*=Mask(floor(v_texCoord.xy*(IN.texture_size.xy/IN.video_size.xy)*IN.output_size.xy)+vec2(0.5,0.5)); + + gl_FragColor = vec4(ToSrgb(outColor.rgb),1.0); +} diff --git a/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slv b/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slv new file mode 100644 index 00000000..7c1d3e72 --- /dev/null +++ b/bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slv @@ -0,0 +1,9 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + v_texCoord = a_texCoord; +} diff --git a/bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slf b/bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slf new file mode 100644 index 00000000..bf622128 --- /dev/null +++ b/bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slf @@ -0,0 +1,43 @@ +// Cartoon shader II +// by guest(r) +// license: GNU-GPL + +#ifdef GL_ES +precision mediump float; +#endif + +const float th = 0.15; // outlines sensitivity, recommended from 0.00...0.50 +const float bb = 1.50; // outlines strength, recommended from 0.50...4.00 +const float pp = 1.55; // outlines blackening, recommended from 0.25...2.00 +const float cl = 7.00; // color levels, recommended form 2.00...10.0 + +uniform sampler2D Sample; +varying vec4 TexCoord[8]; + +void main() + +{ + + vec3 uy = texture2D(Sample, TexCoord[1].xy).xyz; + vec3 lx = texture2D(Sample, TexCoord[4].xy).xyz; + vec3 rx = texture2D(Sample, TexCoord[5].xy).xyz; + vec3 dy = texture2D(Sample, TexCoord[2].xy).xyz; + vec3 ct = texture2D(Sample, TexCoord[0].xy).xyz; + vec3 dt = vec3(1.0,1.0,1.0); + + float d1 = 2.5*dot(abs(lx-rx),dt)/(dot(lx+rx,dt)+0.50); + float d2 = 2.5*dot(abs(uy-dy),dt)/(dot(uy+dy,dt)+0.50); + float d = d1 + d2; + + float l = cl*length(ct)/1.73; + float p = floor(l); + float v = fract(l); + + float t = 0.33; + if (p==0.0) t = 0.6; + + v = 0.6*(max(v-1.0+t,0.0))/t; + v = 1.73*(p+v)/cl + 0.05; + + gl_FragColor.xyz =(1.12-bb*pow(max(d-th,0.0),pp))*v*normalize(ct); +} diff --git a/bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slv b/bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slv new file mode 100644 index 00000000..7f0dea07 --- /dev/null +++ b/bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slv @@ -0,0 +1,31 @@ +#ifdef GL_ES +precision mediump float; +#endif + +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec4 TexCoord[8]; + +void main() +{ + gl_Position = a_position; + + //float x = (OGL2Size.x/2048.0)*OGL2Param.x; + //float y = (OGL2Size.y/1024.0)*OGL2Param.y; + float x = a_texCoord.x/1024.0; + float y = a_texCoord.y/512.0; + vec2 dg1 = vec2( x,y); + vec2 dg2 = vec2(-x,y); + vec2 dx = vec2(x,0.0); + vec2 dy = vec2(0.0,y); + TexCoord[0].xy = a_texCoord; + TexCoord[1].xy = TexCoord[0].xy; + TexCoord[2].xy = TexCoord[0].xy; + TexCoord[4].xy = TexCoord[0].xy; + TexCoord[5].xy = TexCoord[0].xy; + TexCoord[1].y -=y; + TexCoord[2].y +=y; + TexCoord[4].x -=x; + TexCoord[5].x +=x; +} + diff --git a/bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slf b/bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slf new file mode 100644 index 00000000..a30204bf --- /dev/null +++ b/bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slf @@ -0,0 +1,74 @@ +#ifdef GL_ES +precision mediump float; +precision mediump int; +#endif + +uniform sampler2D Frame; +uniform vec2 texcoordOffset; +varying vec2 v_texCoord; + +const mat3 RGBtoYIQ = mat3(0.299, 0.596, 0.212, + 0.587,-0.275,-0.523, + 0.114,-0.321, 0.311); + +const mat3 YIQtoRGB = mat3(1.0, 1.0, 1.0, + 0.95568806036115671171,-0.27158179694405859326,-1.1081773266826619523, + 0.61985809445637075388,-0.64687381613840131330, 1.7050645599191817149); + +const vec3 val00 = vec3( 1.2, 1.2, 1.2); + +void main() { + // The parameters are hardcoded for now, but could be + // made into uniforms to control fromt he program. + float FXAA_SPAN_MAX = 8.0; + float FXAA_REDUCE_MUL = 1.0/8.0; + float FXAA_REDUCE_MIN = (1.0/128.0); + + vec3 rgbNW = texture2D(Frame, v_texCoord.xy + (vec2(-1.0, -1.0) * texcoordOffset)).xyz; + vec3 rgbNE = texture2D(Frame, v_texCoord.xy + (vec2(+1.0, -1.0) * texcoordOffset)).xyz; + vec3 rgbSW = texture2D(Frame, v_texCoord.xy + (vec2(-1.0, +1.0) * texcoordOffset)).xyz; + vec3 rgbSE = texture2D(Frame, v_texCoord.xy + (vec2(+1.0, +1.0) * texcoordOffset)).xyz; + vec3 rgbM = texture2D(Frame, v_texCoord.xy).xyz; + + vec3 luma = vec3(0.299, 0.587, 0.114); + float lumaNW = dot(rgbNW, luma); + float lumaNE = dot(rgbNE, luma); + float lumaSW = dot(rgbSW, luma); + float lumaSE = dot(rgbSE, luma); + float lumaM = dot(rgbM, luma); + + float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE))); + float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE))); + + vec2 dir; + dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE)); + dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE)); + + float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN); + + float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce); + + dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX), + max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), dir * rcpDirMin)) * texcoordOffset; + + vec3 rgbA = (1.0/2.0) * ( + texture2D(Frame, v_texCoord.xy + dir * (1.0/3.0 - 0.5)).xyz + + texture2D(Frame, v_texCoord.xy + dir * (2.0/3.0 - 0.5)).xyz); + vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * ( + texture2D(Frame, v_texCoord.xy + dir * (0.0/3.0 - 0.5)).xyz + + texture2D(Frame, v_texCoord.xy + dir * (3.0/3.0 - 0.5)).xyz); + float lumaB = dot(rgbB, luma); + + if((lumaB < lumaMin) || (lumaB > lumaMax)) + { + rgbM = RGBtoYIQ*rgbA; + rgbM = vec3(pow(rgbM.x,val00.x),rgbM.yz*val00.yz); + gl_FragColor.xyz=YIQtoRGB*rgbM; + + } else { + rgbM = RGBtoYIQ*rgbB; + rgbM = vec3(pow(rgbM.x,val00.x),rgbM.yz*val00.yz); + gl_FragColor.xyz=YIQtoRGB*rgbM; + } + gl_FragColor.a = 1.0; +} diff --git a/bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slv b/bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slv new file mode 100644 index 00000000..1d5c6a6c --- /dev/null +++ b/bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slv @@ -0,0 +1,11 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + + v_texCoord = a_texCoord; +} + diff --git a/bios/Other/epsxe/shaders/Grayscale/gpuCore.slf b/bios/Other/epsxe/shaders/Grayscale/gpuCore.slf new file mode 100644 index 00000000..fc1113c0 --- /dev/null +++ b/bios/Other/epsxe/shaders/Grayscale/gpuCore.slf @@ -0,0 +1,14 @@ +#ifdef GL_ES +precision mediump float; +#endif +varying vec2 v_texCoord; +uniform sampler2D Frame; + +void main() +{ +vec4 fragColor = texture2D(Frame, v_texCoord); +float FragColor = dot(fragColor, vec4( 0.299, 0.587, 0.114, 0.0 )); +gl_FragColor = vec4(FragColor); +} + + diff --git a/bios/Other/epsxe/shaders/Grayscale/gpuCore.slv b/bios/Other/epsxe/shaders/Grayscale/gpuCore.slv new file mode 100644 index 00000000..7c1d3e72 --- /dev/null +++ b/bios/Other/epsxe/shaders/Grayscale/gpuCore.slv @@ -0,0 +1,9 @@ +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = a_position; + v_texCoord = a_texCoord; +} diff --git a/bios/Other/epsxe/shaders/gpuPeteOGL2.fp b/bios/Other/epsxe/shaders/gpuPeteOGL2.fp new file mode 100644 index 00000000..d26365c3 --- /dev/null +++ b/bios/Other/epsxe/shaders/gpuPeteOGL2.fp @@ -0,0 +1,64 @@ +!!ARBfp1.0 + +PARAM val00 = 1.2; +PARAM RGBtoY = { 0.299, 0.587, 0.114, 0}; +PARAM RGBtoI = { 0.596,-0.275,-0.321, 0}; +PARAM RGBtoQ = { 0.212,-0.523, 0.311, 0}; +PARAM YIQtoR = { 1, 0.95568806036115671171, 0.61985809445637075388, 0}; +PARAM YIQtoG = { 1,-0.27158179694405859326,-0.64687381613840131330, 0}; +PARAM YIQtoB = { 1,-1.10817732668266195230, 1.70506455991918171490, 0}; + +TEMP c0, c1; + +TEX c0, fragment.texcoord[0], texture[0], 2D; + +TEX c1, fragment.texcoord[0].zyzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[0].xwzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[0].zwzw, texture[0], 2D; +MAD c0, c1, 0.125, c0; + +TEX c1, fragment.texcoord[1], texture[0], 2D; +ADD c0, c1, c0; +TEX c1, fragment.texcoord[1].zyzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[1].xwzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[1].zwzw, texture[0], 2D; +MAD c0, c1, 0.125, c0; + +TEX c1, fragment.texcoord[2], texture[0], 2D; +ADD c0, c1, c0; +TEX c1, fragment.texcoord[2].zyzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[2].xwzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[2].zwzw, texture[0], 2D; +MAD c0, c1, 0.125, c0; + +TEX c1, fragment.texcoord[3], texture[0], 2D; +ADD c0, c1, c0; +TEX c1, fragment.texcoord[3].zyzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[3].xwzw, texture[0], 2D; +MAD c0, c1, 0.25, c0; +TEX c1, fragment.texcoord[3].zwzw, texture[0], 2D; +MAD c0, c1, 0.125, c0; + +MUL c0, c0, 0.153846153846; + +DP3 c1.x, c0, RGBtoY; +DP3 c1.y, c0, RGBtoI; +DP3 c1.z, c0, RGBtoQ; + +POW c1.x, c1.x, val00.x; +MUL c1.yz, c1, val00; + +DP3 c0.x, c1, YIQtoR; +DP3 c0.y, c1, YIQtoG; +DP3 c0.z, c1, YIQtoB; + +MOV result.color, c0; + +END diff --git a/bios/Other/epsxe/shaders/gpuPeteOGL2.slf b/bios/Other/epsxe/shaders/gpuPeteOGL2.slf new file mode 100644 index 00000000..c9c63d1a --- /dev/null +++ b/bios/Other/epsxe/shaders/gpuPeteOGL2.slf @@ -0,0 +1,35 @@ +// ColoredStorybook shader +// by guest(r) +// License: GNU-GPL + +uniform sampler2D OGL2Texture; +uniform sampler2D OGL2TMU1; + +void main() +{ + vec3 paper = texture2D(OGL2TMU1, gl_TexCoord[6].zw).xyz; + vec3 c00 = texture2D(OGL2Texture, gl_TexCoord[5].xy).xyz; + vec3 c10 = texture2D(OGL2Texture, gl_TexCoord[1].xy).xyz; + vec3 c20 = texture2D(OGL2Texture, gl_TexCoord[2].zw).xyz; + vec3 c01 = texture2D(OGL2Texture, gl_TexCoord[3].xy).xyz; + vec3 c11 = texture2D(OGL2Texture, gl_TexCoord[0].xy).xyz; + vec3 c21 = texture2D(OGL2Texture, gl_TexCoord[4].xy).xyz; + vec3 c02 = texture2D(OGL2Texture, gl_TexCoord[1].zw).xyz; + vec3 c12 = texture2D(OGL2Texture, gl_TexCoord[2].xy).xyz; + vec3 c22 = texture2D(OGL2Texture, gl_TexCoord[6].xy).xyz; + vec3 dt = vec3(1.0,1.0,1.0); + + c11 = 0.25*(c11+0.5*(c10+c01+c12+c21)+0.25*(c02+c20+c00+c22)); + + float d1=dot(abs(c00-c22),dt); + float d2=dot(abs(c20-c02),dt); + float hl=dot(abs(c01-c21),dt); + float vl=dot(abs(c10-c12),dt); + + float d = 0.60*(d1+d2+hl+vl)/(dot(c11,dt)+0.5); + + d = 0.5*pow(d,0.5) + d; + c11 = (1.0-0.6*d)*c11; + + gl_FragColor.xyz = mix(paper, c11, pow(max(min(d,1.1)-0.1,0.0),0.5)); +} diff --git a/bios/Other/epsxe/shaders/gpuPeteOGL2.slv b/bios/Other/epsxe/shaders/gpuPeteOGL2.slv new file mode 100644 index 00000000..4f5f44eb --- /dev/null +++ b/bios/Other/epsxe/shaders/gpuPeteOGL2.slv @@ -0,0 +1,26 @@ +// by guest(r) - guest.r@gmail.com +// license: GNU-GPL + +uniform vec4 OGL2Param; +uniform vec4 OGL2Size; + +void main() +{ + float x = (OGL2Size.x/2048.0)*OGL2Param.x; + float y = (OGL2Size.y/1024.0)*OGL2Param.y; + vec2 dg1 = vec2( x,y); + vec2 dg2 = vec2(-x,y); + vec2 dx = vec2(x,0.0); + vec2 dy = vec2(0.0,y); + gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; + gl_TexCoord[0] = gl_MultiTexCoord0; + gl_TexCoord[6].zw= gl_MultiTexCoord1.xy; + gl_TexCoord[1].xy = gl_TexCoord[0].xy - dy; + gl_TexCoord[2].xy = gl_TexCoord[0].xy + dy; + gl_TexCoord[3].xy = gl_TexCoord[0].xy - dx; + gl_TexCoord[4].xy = gl_TexCoord[0].xy + dx; + gl_TexCoord[5].xy = gl_TexCoord[0].xy - dg1; + gl_TexCoord[6].xy = gl_TexCoord[0].xy + dg1; + gl_TexCoord[1].zw = gl_TexCoord[0].xy - dg2; + gl_TexCoord[2].zw = gl_TexCoord[0].xy + dg2; +} diff --git a/bios/Other/epsxe/shaders/gpuPeteOGL2.vp b/bios/Other/epsxe/shaders/gpuPeteOGL2.vp new file mode 100644 index 00000000..a0bf2a12 --- /dev/null +++ b/bios/Other/epsxe/shaders/gpuPeteOGL2.vp @@ -0,0 +1,12 @@ +!!ARBvp1.0 + +OPTION ARB_position_invariant; + +PARAM offset = program.env[1]; + +MAD result.texcoord[ 0 ], offset.xyxy, {-0.5,-0.5,-1.5,-1.5}, vertex.texcoord[0].xyxy; +MAD result.texcoord[ 1 ], offset.xyxy, { 0.5,-0.5, 1.5,-1.5}, vertex.texcoord[0].xyxy; +MAD result.texcoord[ 2 ], offset.xyxy, {-0.5, 0.5,-1.5, 1.5}, vertex.texcoord[0].xyxy; +MAD result.texcoord[ 3 ], offset.xyxy, { 0.5, 0.5, 1.5, 1.5}, vertex.texcoord[0].xyxy; + +END \ No newline at end of file diff --git a/bios/Other/epsxe/shaders/gpucore/delete.me b/bios/Other/epsxe/shaders/gpucore/delete.me new file mode 100644 index 00000000..2d030d7b --- /dev/null +++ b/bios/Other/epsxe/shaders/gpucore/delete.me @@ -0,0 +1 @@ +delete me diff --git a/bios/Other/epsxe/shaders/ogl2/erase.me b/bios/Other/epsxe/shaders/ogl2/erase.me new file mode 100644 index 00000000..4e314dee --- /dev/null +++ b/bios/Other/epsxe/shaders/ogl2/erase.me @@ -0,0 +1 @@ +erase me diff --git a/bios/Other/epsxe/shaders/super-eagle/gpuCore.ini b/bios/Other/epsxe/shaders/super-eagle/gpuCore.ini new file mode 100644 index 00000000..26cea955 --- /dev/null +++ b/bios/Other/epsxe/shaders/super-eagle/gpuCore.ini @@ -0,0 +1,5 @@ +name=Super Eagle +version=1 +license=GPLv2 +copyright=Unknown +filter_linear=0 diff --git a/bios/Other/epsxe/shaders/super-eagle/gpuCore.slf b/bios/Other/epsxe/shaders/super-eagle/gpuCore.slf new file mode 100644 index 00000000..196b3c07 --- /dev/null +++ b/bios/Other/epsxe/shaders/super-eagle/gpuCore.slf @@ -0,0 +1,147 @@ + /* COMPATIBILITY + - HLSL compilers + - Cg compilers +*/ + +#ifdef GL_ES +precision mediump float; +precision mediump int; +#endif + +const vec3 dtt = vec3(65536,255,1); + +float reduce(vec3 color) +{ + return dot(color, dtt); +} + +struct inputdata +{ + vec2 video_size; + vec2 texture_size; + vec2 output_size; + float frame_count; + float frame_direction; + float frame_rotation; +}; + +uniform sampler2D Sample; +uniform inputdata IN; +varying vec4 TexCoord[8]; +varying vec2 v_texCoord; + +/* GET_RESULT function */ +/* Copyright (c) 1999-2001 by Derek Liauw Kie Fa */ +/* License: GNU-GPL */ +int GET_RESULT(float A, float B, float C, float D) +{ + int x = 0; int y = 0; int r = 0; + if (A == C) x+=1; else if (B == C) y+=1; + if (A == D) x+=1; else if (B == D) y+=1; + if (x <= 1) r+=1; + if (y <= 1) r-=1; + return r; +} + +void main() +{ + vec2 fp = fract(v_texCoord*IN.texture_size); + + // Reading the texels + + vec3 C0 = texture2D(Sample,TexCoord[0].xy).xyz; + vec3 C1 = texture2D(Sample,TexCoord[0].zw).xyz; + vec3 C2 = texture2D(Sample,TexCoord[1].xy).xyz; + vec3 D3 = texture2D(Sample,TexCoord[1].zw).xyz; + vec3 C3 = texture2D(Sample,TexCoord[2].xy).xyz; + vec3 C4 = texture2D(Sample,v_texCoord).xyz; + vec3 C5 = texture2D(Sample,TexCoord[2].zw).xyz; + vec3 D4 = texture2D(Sample,TexCoord[3].xy).xyz; + vec3 C6 = texture2D(Sample,TexCoord[3].zw).xyz; + vec3 C7 = texture2D(Sample,TexCoord[4].xy).xyz; + vec3 C8 = texture2D(Sample,TexCoord[4].zw).xyz; + vec3 D5 = texture2D(Sample,TexCoord[5].xy).xyz; + vec3 D0 = texture2D(Sample,TexCoord[5].zw).xyz; + vec3 D1 = texture2D(Sample,TexCoord[6].xy).xyz; + vec3 D2 = texture2D(Sample,TexCoord[6].zw).xyz; + vec3 D6 = texture2D(Sample,TexCoord[7].xy).xyz; + + vec3 p00,p10,p01,p11; + + // reducing vec3 to float + float c0 = reduce(C0);float c1 = reduce(C1); + float c2 = reduce(C2);float c3 = reduce(C3); + float c4 = reduce(C4);float c5 = reduce(C5); + float c6 = reduce(C6);float c7 = reduce(C7); + float c8 = reduce(C8);float d0 = reduce(D0); + float d1 = reduce(D1);float d2 = reduce(D2); + float d3 = reduce(D3);float d4 = reduce(D4); + float d5 = reduce(D5);float d6 = reduce(D6); + + /* SuperEagle code */ + /* Copied from the Dosbox source code */ + /* Copyright (C) 2002-2007 The DOSBox Team */ + /* License: GNU-GPL */ + /* Adapted by guest(r) on 16.4.2007 */ + if (c4 != c8) { + if (c7 == c5) { + p01 = p10 = C7; + if ((c6 == c7) || (c5 == c2)) { + p00 = 0.25*(3.0*C7+C4); + } else { + p00 = 0.5*(C4+C5); + } + + if ((c5 == d4) || (c7 == d1)) { + p11 = 0.25*(3.0*C7+C8); + } else { + p11 = 0.5*(C7+C8); + } + } else { + p11 = 0.125*(6.0*C8+C7+C5); + p00 = 0.125*(6.0*C4+C7+C5); + + p10 = 0.125*(6.0*C7+C4+C8); + p01 = 0.125*(6.0*C5+C4+C8); + } + } else { + if (c7 != c5) { + p11 = p00 = C4; + + if ((c1 == c4) || (c8 == d5)) { + p01 = 0.25*(3.0*C4+C5); + } else { + p01 = 0.5*(C4+C5); + } + + if ((c8 == d2) || (c3 == c4)) { + p10 = 0.25*(3.0*C4+C7); + } else { + p10 = 0.5*(C7+C8); + } + } else { + int r = 0; + r += GET_RESULT(c5,c4,c6,d1); + r += GET_RESULT(c5,c4,c3,c1); + r += GET_RESULT(c5,c4,d2,d5); + r += GET_RESULT(c5,c4,c2,d4); + + if (r > 0) { + p01 = p10 = C7; + p00 = p11 = 0.5*(C4+C5); + } else if (r < 0) { + p11 = p00 = C4; + p01 = p10 = 0.5*(C4+C5); + } else { + p11 = p00 = C4; + p01 = p10 = C7; + } + } + } + + // Distributing the four products + p10 = (fp.x < 0.50) ? (fp.y < 0.50 ? p00 : p10) : (fp.y < 0.50 ? p01: p11); + + // OUTPUT + gl_FragColor = vec4(p10, 1); +} diff --git a/bios/Other/epsxe/shaders/super-eagle/gpuCore.slv b/bios/Other/epsxe/shaders/super-eagle/gpuCore.slv new file mode 100644 index 00000000..921622e7 --- /dev/null +++ b/bios/Other/epsxe/shaders/super-eagle/gpuCore.slv @@ -0,0 +1,44 @@ + +struct inputdata +{ + vec2 video_size; + vec2 texture_size; + vec2 output_size; + float frame_count; + float frame_direction; + float frame_rotation; +}; + + +attribute vec4 a_position; +attribute vec2 a_texCoord; +varying vec4 TexCoord[8]; +varying vec2 v_texCoord; +uniform inputdata IN; + +void main() +{ + gl_Position = a_position; + + vec2 ps = vec2(1.0/IN.texture_size.x, 1.0/IN.texture_size.y); + float dx = ps.x; + float dy = ps.y; + + v_texCoord = a_texCoord; + TexCoord[0].xy = a_texCoord + vec2(-dx,-dy); + TexCoord[0].zw = a_texCoord + vec2(-dx, 0); + TexCoord[1].xy = a_texCoord + vec2(+dx,-dy); + TexCoord[1].zw = a_texCoord + vec2(+dx+dx,-dy); + TexCoord[2].xy = a_texCoord + vec2(-dx, 0); + TexCoord[2].zw = a_texCoord + vec2(+dx, 0); + TexCoord[3].xy = a_texCoord + vec2(+dx+dx, 0); + TexCoord[3].zw = a_texCoord + vec2(-dx,+dy); + TexCoord[4].xy = a_texCoord + vec2( 0,+dy); + TexCoord[4].zw = a_texCoord + vec2(+dx,+dy); + TexCoord[5].xy = a_texCoord + vec2(+dx+dx,+dy); + TexCoord[5].zw = a_texCoord + vec2(-dx,+dy+dy); + TexCoord[6].xy = a_texCoord + vec2( 0,+dy+dy); + TexCoord[6].zw = a_texCoord + vec2(+dx,+dy+dy); + TexCoord[7].xy = a_texCoord + vec2(+dx+dx,+dy+dy); +} + diff --git a/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.ini b/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.ini new file mode 100644 index 00000000..53528281 --- /dev/null +++ b/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.ini @@ -0,0 +1,5 @@ +name=xBR-LV2-3D +version=1 +license=Free +copyright=Hyllian +filter_linear=0 diff --git a/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slf b/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slf new file mode 100644 index 00000000..76fb03dd --- /dev/null +++ b/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slf @@ -0,0 +1,266 @@ +/* + Hyllian's xBR-lv2-3D Shader + + Copyright (C) 2011-2016 Hyllian - sergiogdb@gmail.com + + 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. + + Incorporates some of the ideas from SABR shader. Thanks to Joshua Street. +*/ + +#ifdef GL_ES +precision mediump float; +#endif + +#define XBR_RES 2.0 + +#define TEX_SIZEX (1024.0*XBR_RES) +#define TEX_SIZEY (512.0*XBR_RES) + + +// Uncomment just one of the three params below to choose the corner detection +//#define CORNER_A +//#define CORNER_B +#define CORNER_C +//#define CORNER_D + +#ifndef CORNER_A + #define SMOOTH_TIPS +#endif + +#define XBR_SCALE 3.0 +#define XBR_Y_WEIGHT 48.0 +#define XBR_EQ_THRESHOLD 15.0 +#define XBR_LV2_COEFFICIENT 2.0 + +#define lv2_cf XBR_LV2_COEFFICIENT + +const float coef = 2.0; +const vec3 rgbw = vec3(14.352, 28.176, 5.472); +const vec4 eq_threshold = vec4(15.0, 15.0, 15.0, 15.0); + +const vec4 delta = vec4(1.0/XBR_SCALE, 1.0/XBR_SCALE, 1.0/XBR_SCALE, 1.0/XBR_SCALE); +const vec4 delta_l = vec4(0.5/XBR_SCALE, 1.0/XBR_SCALE, 0.5/XBR_SCALE, 1.0/XBR_SCALE); +const vec4 delta_u = delta_l.yxwz; + +const vec2 OGLSize = vec2( 1024.0, 512.0); +const vec2 OGLInvSize = 1.0/OGLSize; + +const vec2 dx = vec2( XBR_RES/TEX_SIZEX, 0.0); +const vec2 dy = vec2( 0.0, XBR_RES/TEX_SIZEY); + +const vec4 Ao = vec4( 1.0, -1.0, -1.0, 1.0 ); +const vec4 Bo = vec4( 1.0, 1.0, -1.0,-1.0 ); +const vec4 Co = vec4( 1.5, 0.5, -0.5, 0.5 ); +const vec4 Ax = vec4( 1.0, -1.0, -1.0, 1.0 ); +const vec4 Bx = vec4( 0.5, 2.0, -0.5,-2.0 ); +const vec4 Cx = vec4( 1.0, 1.0, -0.5, 0.0 ); +const vec4 Ay = vec4( 1.0, -1.0, -1.0, 1.0 ); +const vec4 By = vec4( 2.0, 0.5, -2.0,-0.5 ); +const vec4 Cy = vec4( 2.0, 0.0, -1.0, 0.5 ); +const vec4 Ci = vec4(0.25, 0.25, 0.25, 0.25); + + +// Difference between vector components. +vec4 df(vec4 A, vec4 B) +{ + return vec4(abs(A-B)); +} + +// Compare two vectors and return their components are different. +vec4 diff(vec4 A, vec4 B) +{ + return vec4(notEqual(A, B)); +} + +// Determine if two vector components are equal based on a threshold. +vec4 eq(vec4 A, vec4 B) +{ + return (step(df(A, B), vec4(XBR_EQ_THRESHOLD))); +} + +// Determine if two vector components are NOT equal based on a threshold. +vec4 neq(vec4 A, vec4 B) +{ + return (vec4(1.0, 1.0, 1.0, 1.0) - eq(A, B)); +} + +// Weighted distance. +vec4 wd(vec4 a, vec4 b, vec4 c, vec4 d, vec4 e, vec4 f, vec4 g, vec4 h) +{ + return (df(a,b) + df(a,c) + df(d,e) + df(d,f) + 4.0*df(g,h)); +} + +float c_df(vec3 c1, vec3 c2) +{ + vec3 df = abs(c1 - c2); + return df.r + df.g + df.b; +} + +uniform sampler2D Sample; +varying vec4 TexCoord[8]; + +void main() +{ + vec4 edri, edr, edr_l, edr_u, px; // px = pixel, edr = edge detection rule + vec4 irlv0, irlv1, irlv2l, irlv2u, block_3d; + vec4 fx, fx_l, fx_u; // inequations of straight lines. + + vec2 fp = fract(TexCoord[0].xy*OGLSize); + vec2 TexCoord_0 = TexCoord[0].xy; + vec2 tex = (floor(TexCoord_0*OGLSize) + vec2(0.5, 0.5))/OGLSize; + + + vec3 A1 = texture2D(Sample, TexCoord[1].xw ).xyz; + vec3 B1 = texture2D(Sample, TexCoord[1].yw ).xyz; + vec3 C1 = texture2D(Sample, TexCoord[1].zw ).xyz; + vec3 A = texture2D(Sample, TexCoord[2].xw ).xyz; + vec3 B = texture2D(Sample, TexCoord[2].yw ).xyz; + vec3 C = texture2D(Sample, TexCoord[2].zw ).xyz; + vec3 D = texture2D(Sample, TexCoord[3].xw ).xyz; + vec3 E = texture2D(Sample, TexCoord[3].yw ).xyz; + vec3 F = texture2D(Sample, TexCoord[3].zw ).xyz; + vec3 G = texture2D(Sample, TexCoord[4].xw ).xyz; + vec3 H = texture2D(Sample, TexCoord[4].yw ).xyz; + vec3 I = texture2D(Sample, TexCoord[4].zw ).xyz; + vec3 G5 = texture2D(Sample, TexCoord[5].xw ).xyz; + vec3 H5 = texture2D(Sample, TexCoord[5].yw ).xyz; + vec3 I5 = texture2D(Sample, TexCoord[5].zw ).xyz; + vec3 A0 = texture2D(Sample, TexCoord[6].xy ).xyz; + vec3 D0 = texture2D(Sample, TexCoord[6].xz ).xyz; + vec3 G0 = texture2D(Sample, TexCoord[6].xw ).xyz; + vec3 C4 = texture2D(Sample, TexCoord[7].xy ).xyz; + vec3 F4 = texture2D(Sample, TexCoord[7].xz ).xyz; + vec3 I4 = texture2D(Sample, TexCoord[7].xw ).xyz; + + vec3 E6 = texture2D(Sample, tex +0.25*dx +0.25*dy).xyz; + vec3 E7 = texture2D(Sample, tex +0.25*dx -0.25*dy).xyz; + vec3 E8 = texture2D(Sample, tex -0.25*dx -0.25*dy).xyz; + vec3 E9 = texture2D(Sample, tex -0.25*dx +0.25*dy).xyz; + + vec3 F6 = texture2D(Sample, tex +dx+0.25*dx +0.25*dy).xyz; + vec3 F7 = texture2D(Sample, tex +dx+0.25*dx -0.25*dy).xyz; + vec3 F8 = texture2D(Sample, tex +dx-0.25*dx -0.25*dy).xyz; + vec3 F9 = texture2D(Sample, tex +dx-0.25*dx +0.25*dy).xyz; + + vec3 B6 = texture2D(Sample, tex +0.25*dx +0.25*dy-dy).xyz; + vec3 B7 = texture2D(Sample, tex +0.25*dx -0.25*dy-dy).xyz; + vec3 B8 = texture2D(Sample, tex -0.25*dx -0.25*dy-dy).xyz; + vec3 B9 = texture2D(Sample, tex -0.25*dx +0.25*dy-dy).xyz; + + vec3 D6 = texture2D(Sample, tex -dx+0.25*dx +0.25*dy).xyz; + vec3 D7 = texture2D(Sample, tex -dx+0.25*dx -0.25*dy).xyz; + vec3 D8 = texture2D(Sample, tex -dx-0.25*dx -0.25*dy).xyz; + vec3 D9 = texture2D(Sample, tex -dx-0.25*dx +0.25*dy).xyz; + + vec3 H6 = texture2D(Sample, tex +0.25*dx +0.25*dy+dy).xyz; + vec3 H7 = texture2D(Sample, tex +0.25*dx -0.25*dy+dy).xyz; + vec3 H8 = texture2D(Sample, tex -0.25*dx -0.25*dy+dy).xyz; + vec3 H9 = texture2D(Sample, tex -0.25*dx +0.25*dy+dy).xyz; + + + vec4 b = vec4(dot(B ,rgbw), dot(D ,rgbw), dot(H ,rgbw), dot(F ,rgbw)); + vec4 c = vec4(dot(C ,rgbw), dot(A ,rgbw), dot(G ,rgbw), dot(I ,rgbw)); + vec4 d = b.yzwx; + vec4 e = vec4(dot(E,rgbw)); + vec4 f = b.wxyz; + vec4 g = c.zwxy; + vec4 h = b.zwxy; + vec4 i = c.wxyz; + vec4 i4 = vec4(dot(I4,rgbw), dot(C1,rgbw), dot(A0,rgbw), dot(G5,rgbw)); + vec4 i5 = vec4(dot(I5,rgbw), dot(C4,rgbw), dot(A1,rgbw), dot(G0,rgbw)); + vec4 h5 = vec4(dot(H5,rgbw), dot(F4,rgbw), dot(B1,rgbw), dot(D0,rgbw)); + vec4 f4 = h5.yzwx; + + vec4 f0 = vec4(dot(F6,rgbw), dot(B6,rgbw), dot(D6,rgbw), dot(H6,rgbw)); + vec4 f1 = vec4(dot(F7,rgbw), dot(B7,rgbw), dot(D7,rgbw), dot(H7,rgbw)); + vec4 f2 = vec4(dot(F8,rgbw), dot(B8,rgbw), dot(D8,rgbw), dot(H8,rgbw)); + vec4 f3 = vec4(dot(F9,rgbw), dot(B9,rgbw), dot(D9,rgbw), dot(H9,rgbw)); + + vec4 h0 = f0.wxyz; + vec4 h1 = f1.wxyz; + vec4 h2 = f2.wxyz; + vec4 h3 = f3.wxyz; + + vec4 e0 = vec4(dot(E6,rgbw), dot(E7,rgbw), dot(E8,rgbw), dot(E9,rgbw)); + + // These inequations define the line below which interpolation occurs. + fx = (Ao*fp.y+Bo*fp.x); + fx_l = (Ax*fp.y+Bx*fp.x); + fx_u = (Ay*fp.y+By*fp.x); + + block_3d = vec4(equal(f0,f1))*vec4(equal(f1,f2))*vec4(equal(f2,f3))*vec4(equal(h0,h1))*vec4(equal(h1,h2))*vec4(equal(h2,h3)); + + irlv1 = irlv0 = block_3d * diff(e,f) * diff(e,h); + +#ifdef CORNER_B + irlv1 = (irlv0 * ( neq(f,b) * neq(h,d) + eq(e,i) * neq(f,i4) * neq(h,i5) + eq(e,g) + eq(e,c) ) ); +#endif +#ifdef CORNER_D + vec4 c1 = i4.yzwx; + vec4 g0 = i5.wxyz; + irlv1 = (irlv0 * ( neq(f,b) * neq(h,d) + eq(e,i) * neq(f,i4) * neq(h,i5) + eq(e,g) + eq(e,c) ) * (diff(f,f4) * diff(f,i) + diff(h,h5) * diff(h,i) + diff(h,g) + diff(f,c) + eq(b,c1) * eq(d,g0))); +#endif +#ifdef CORNER_C + irlv1 = (irlv0 * ( neq(f,b) * neq(f,c) + neq(h,d) * neq(h,g) + eq(e,i) * (neq(f,f4) * neq(f,i4) + neq(h,h5) * neq(h,i5)) + eq(e,g) + eq(e,c)) ); +#endif + + irlv2l = diff(e,g) * diff(d,g); + irlv2u = diff(e,c) * diff(b,c); + + vec4 fx45i = clamp((fx + delta -Co - Ci)/(2.0*delta ), 0.0, 1.0); + vec4 fx45 = clamp((fx + delta -Co )/(2.0*delta ), 0.0, 1.0); + vec4 fx30 = clamp((fx_l + delta_l -Cx )/(2.0*delta_l), 0.0, 1.0); + vec4 fx60 = clamp((fx_u + delta_u -Cy )/(2.0*delta_u), 0.0, 1.0); + + vec4 wd1 = wd( e, c, g, i, h5, f4, h, f); + vec4 wd2 = wd( h, d, i5, f, i4, b, e, i); + + edri = step(wd1, wd2) * irlv0; + edr = step(wd1 + vec4(0.1, 0.1, 0.1, 0.1), wd2) * step(vec4(0.5, 0.5, 0.5, 0.5), irlv1); + edr_l = step( lv2_cf*df(f,g), df(h,c) ) * irlv2l * edr; + edr_u = step( lv2_cf*df(h,c), df(f,g) ) * irlv2u * edr; + + fx45 = edr * fx45; + fx30 = edr_l * fx30; + fx60 = edr_u * fx60; + fx45i = edri * fx45i; + + px = step(df(e,f), df(e,h)); + +#ifdef SMOOTH_TIPS + vec4 maximos = max(max(fx30, fx60), max(fx45, fx45i)); +#endif +#ifndef SMOOTH_TIPS + vec4 maximos = max(max(fx30, fx60), fx45); +#endif + + vec3 res1 = E; + res1 = mix(res1, mix(H, F, px.x), maximos.x); + res1 = mix(res1, mix(B, D, px.z), maximos.z); + + vec3 res2 = E; + res2 = mix(res2, mix(F, B, px.y), maximos.y); + res2 = mix(res2, mix(D, H, px.w), maximos.w); + + vec3 res = mix(res1, res2, step(c_df(E, res1), c_df(E, res2))); + + gl_FragColor.xyz = res; +} + diff --git a/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slv b/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slv new file mode 100644 index 00000000..15d0821c --- /dev/null +++ b/bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slv @@ -0,0 +1,32 @@ +struct inputdata +{ + vec2 video_size; + vec2 texture_size; + vec2 output_size; + float frame_count; + float frame_direction; + float frame_rotation; +}; + +attribute vec4 a_position; +attribute vec2 a_texCoord; +uniform inputdata IN; +varying vec4 TexCoord[8]; + +void main() +{ +const vec2 OGLSize = vec2( 1024.0, 512.0); +vec2 OGLInvSize = 1.0/OGLSize; +float dx = OGLInvSize.x; +float dy = OGLInvSize.y; + +gl_Position = a_position; +TexCoord[0].xy = a_texCoord; +TexCoord[1] = TexCoord[0].xxxy + vec4( -dx, 0, dx,-2.0*dy); // A1 B1 C1 +TexCoord[2] = TexCoord[0].xxxy + vec4( -dx, 0, dx, -dy); // A B C +TexCoord[3] = TexCoord[0].xxxy + vec4( -dx, 0, dx, 0); // D E F +TexCoord[4] = TexCoord[0].xxxy + vec4( -dx, 0, dx, dy); // G H I +TexCoord[5] = TexCoord[0].xxxy + vec4( -dx, 0, dx, 2.0*dy); // G5 H5 I5 +TexCoord[6] = TexCoord[0].xyyy + vec4(-2.0*dx,-dy, 0, dy); // A0 D0 G0 +TexCoord[7] = TexCoord[0].xyyy + vec4( 2.0*dx,-dy, 0, dy); // C4 F4 I4 +} diff --git a/database.json b/database.json index 63dee0d2..f1f85e42 100644 --- a/database.json +++ b/database.json @@ -1,8 +1,8 @@ { "schema_version": 1, - "generated_at": "2026-08-11T17:14:33Z", - "total_files": 8655, - "total_size": 11147355425, + "generated_at": "2026-08-11T17:20:13Z", + "total_files": 8685, + "total_size": 11147432390, "files": { "520d3d1b5897800af47f92efd2444a26b7a7dead": { "path": "bios/3DO Company/3DO/3do_arcade_saot.bin", @@ -49917,6 +49917,306 @@ "crc32": "69dc25d7", "adler32": "9f4b472e" }, + "5f589f6b1845927141dac09f6c2b050624ef2d03": { + "path": "bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.ini", + "name": "gpuCore.ini", + "size": 83, + "sha1": "5f589f6b1845927141dac09f6c2b050624ef2d03", + "md5": "ff44a27f0cf1148cfa87ba17545180cc", + "sha256": "d1ef814cb6314357d43089f67a6808df563577604b598da7fc4697cfbe08df50", + "crc32": "dc249b13", + "adler32": "ae4c1d07" + }, + "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01": { + "path": "bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slf", + "name": "gpuCore.slf", + "size": 20868, + "sha1": "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01", + "md5": "49ac87eb7a9260da61f836bde9c46c0e", + "sha256": "0a7a10c278ec13ae37192d15484bacc646bca67e2aae64fab39cd78dda1547cc", + "crc32": "e24efa44", + "adler32": "121066ae" + }, + "073a34b093054d217029f7314a2b8142e1dac6b7": { + "path": "bios/Other/epsxe/shaders/5xBR-v3.7c/gpuCore.slv", + "name": "gpuCore.slv", + "size": 153, + "sha1": "073a34b093054d217029f7314a2b8142e1dac6b7", + "md5": "2479682ae26ccb07b37835db0f65fa63", + "sha256": "92f06e873b6ca0affd4029ba646c58ae60a47471f7123047c08b2fe3ad45fc41", + "crc32": "e454f02d", + "adler32": "6f9e34f1" + }, + "54644d6ec012bcbf9030b369a2fb4dfbedfa511f": { + "path": "bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slf", + "name": "gpuCore.slf", + "size": 2360, + "sha1": "54644d6ec012bcbf9030b369a2fb4dfbedfa511f", + "md5": "9ec7c9b77a9cbb2181ab7d6ec904b1e0", + "sha256": "70b69879b7583ee3bbcfdddc106a59e5ed66581914bfa2ad1f82285654c5f2a0", + "crc32": "a509c794", + "adler32": "088e9c68" + }, + "dcd9f24f47443ec8421e48fef7e37fd8a52c4782": { + "path": "bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slv", + "name": "gpuCore.slv", + "size": 762, + "sha1": "dcd9f24f47443ec8421e48fef7e37fd8a52c4782", + "md5": "c1896b87729b76ba2a4a289125466e82", + "sha256": "23ecd34d71b69e2d41b71ca66220792310c26e6799db9351e26cdae287a2f406", + "crc32": "6b725715", + "adler32": "3841e51f" + }, + "10de0e6e7f616b67f7aced4fa51a55af9d9fb046": { + "path": "bios/Other/epsxe/shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slf", + "name": "gpuCore.slf", + "size": 5295, + "sha1": "10de0e6e7f616b67f7aced4fa51a55af9d9fb046", + "md5": "3a1874705e39880bc5556261d6e71744", + "sha256": "56f2d9af2060f2f0fd6c2acdccbe57f77a0609a2cfb3f2e324b3c3a4fe704e49", + "crc32": "04e29286", + "adler32": "d692ac82" + }, + "c966a738bffbe6f5017684318b26f66899e620f4": { + "path": "bios/Other/epsxe/shaders/Brightness/gpuCore.ini", + "name": "gpuCore.ini", + "size": 59, + "sha1": "c966a738bffbe6f5017684318b26f66899e620f4", + "md5": "b037a7f8e506108db89a9111766e897e", + "sha256": "06fac91ea6fe36e3e41780da7d631a575893c9dfb56f1369dc639a97c2fc9270", + "crc32": "579d5d7c", + "adler32": "8c74150f" + }, + "036e58e46d7264e2d6b08f48bde8b2d83361a661": { + "path": "bios/Other/epsxe/shaders/Brightness/gpuCore.slf", + "name": "gpuCore.slf", + "size": 3089, + "sha1": "036e58e46d7264e2d6b08f48bde8b2d83361a661", + "md5": "1b37c6b0835d045c86a062267c843e2f", + "sha256": "a184f3e62cf87caa00d1e9c044587cb5244567369a5edab5c1dbec43edba3ff3", + "crc32": "5ebc2ad4", + "adler32": "42784330" + }, + "687540a168728baf3babaf2dedf74b5f1d2f56b4": { + "path": "bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.ini", + "name": "gpuCore.ini", + "size": 74, + "sha1": "687540a168728baf3babaf2dedf74b5f1d2f56b4", + "md5": "f91347f046724ad7d0d4f4315a8378a1", + "sha256": "32db4e009959b5606e3d3153d9cd4c0e1a84312bf07848b595eaec0190ea6b9b", + "crc32": "b01d11f1", + "adler32": "e68d1ab5" + }, + "f0e3d77db14b4dd11aa7cc71613097600d3e5da3": { + "path": "bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slf", + "name": "gpuCore.slf", + "size": 6021, + "sha1": "f0e3d77db14b4dd11aa7cc71613097600d3e5da3", + "md5": "b3ec1b57cf72c14f0e945cd054d44d11", + "sha256": "8b39bd12aae661165fc35eb2627c1ea4d7cc26fef179fe2e772abb412bf94e5b", + "crc32": "e0c2acb6", + "adler32": "5da07f7b" + }, + "cda44c87be8b01c7ba23e2ad09a516d1747dee9b": { + "path": "bios/Other/epsxe/shaders/CRT-Hyllian/gpuCore.slv", + "name": "gpuCore.slv", + "size": 201, + "sha1": "cda44c87be8b01c7ba23e2ad09a516d1747dee9b", + "md5": "1184808df8031b080289ccdb5b17ba6b", + "sha256": "9f63333b425c697048c6804d7f30f9a653570143eb897758c7c9fb9d3d8e119c", + "crc32": "41169e0a", + "adler32": "98f8446f" + }, + "56ad43fc57833eefb116af581c9ad034c53778ee": { + "path": "bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.ini", + "name": "gpuCore.ini", + "size": 70, + "sha1": "56ad43fc57833eefb116af581c9ad034c53778ee", + "md5": "b6b4e84b236221b2ece84dc5c1e4f154", + "sha256": "939ac6a08f181b926ed074f83342ff4043ec7237267652ff163650f23852de61", + "crc32": "7d4623fc", + "adler32": "5ea218ca" + }, + "a582843e7dac4735392fe82fdf3e6fef88f7ff66": { + "path": "bios/Other/epsxe/shaders/CRT-Hyllian-3D/gpuCore.slf", + "name": "gpuCore.slf", + "size": 10438, + "sha1": "a582843e7dac4735392fe82fdf3e6fef88f7ff66", + "md5": "72ac4fd9b61c086d9836486c2f750be2", + "sha256": "32e45e1a9cd471bdcf7c0f1b77a425cdda265726e58e2c5a703c27bb343a52ec", + "crc32": "9c4acf63", + "adler32": "c192c0f0" + }, + "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd": { + "path": "bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.ini", + "name": "gpuCore.ini", + "size": 65, + "sha1": "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd", + "md5": "f58606c167af7d2b961a06bab8632bd0", + "sha256": "bb046bc18f6e1e78713e5d6f5a5c58a5b4969fe1488f41df6ef9ee0c1f82dcaf", + "crc32": "9aea70ac", + "adler32": "ff951787" + }, + "c06f5745e3ecc0b33e802877b46352d8304b81bc": { + "path": "bios/Other/epsxe/shaders/CRT-Lottes/gpuCore.slf", + "name": "gpuCore.slf", + "size": 4400, + "sha1": "c06f5745e3ecc0b33e802877b46352d8304b81bc", + "md5": "c6fc241947fcc671b0ed1fc2dd3baa99", + "sha256": "db1955fb12093a469f62f30ae4995663436707149a0bd0212494840b2f52c383", + "crc32": "1979f565", + "adler32": "55c27219" + }, + "501c31d7614583f6b1f25eb57f67d35343e6dff8": { + "path": "bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slf", + "name": "gpuCore.slf", + "size": 1171, + "sha1": "501c31d7614583f6b1f25eb57f67d35343e6dff8", + "md5": "e97109bf49fd31e3f60e2081baf73f5f", + "sha256": "adc966ee2b7e1d61515f49890ddd67cebf6335fe0e8cfb6f6fc6fa2a69a9db11", + "crc32": "dbade009", + "adler32": "96ba5c12" + }, + "339af29d54a62a8d6ddea059d01a1c71dceb741f": { + "path": "bios/Other/epsxe/shaders/Cartoon_shader_II/gpuCore.slv", + "name": "gpuCore.slv", + "size": 707, + "sha1": "339af29d54a62a8d6ddea059d01a1c71dceb741f", + "md5": "c0406730f8e7e0048ab29df2b55aea8b", + "sha256": "8205995b3aea42b98adbe8ad99e28a5edfdbc711e74a5e33da045bfa1da4428c", + "crc32": "e7e004f8", + "adler32": "1838d52f" + }, + "b7165607add6023abb9291e3ae80053865ab4a15": { + "path": "bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slf", + "name": "gpuCore.slf", + "size": 2763, + "sha1": "b7165607add6023abb9291e3ae80053865ab4a15", + "md5": "d9e9b284f38ac79e8e52ed8673a704b0", + "sha256": "a175f11b2188b4001c51bb548763d92a052211fb7b84cc82e2f492956d9623ec", + "crc32": "bdca044b", + "adler32": "79dd02db" + }, + "d0d06fca34ac14d021175be133af413bdbecdf9c": { + "path": "bios/Other/epsxe/shaders/FXAA_natural_vision/gpuCore.slv", + "name": "gpuCore.slv", + "size": 155, + "sha1": "d0d06fca34ac14d021175be133af413bdbecdf9c", + "md5": "31c8eac7f0eff22599ec31852a151865", + "sha256": "7160ce15161d0a36f8dc5168b8368a0fc8e2238d40635a3c7be8cccfa884746f", + "crc32": "872429df", + "adler32": "d0fc3505" + }, + "efa8ae5ed06eba9d4020ff81dc612bf934261803": { + "path": "bios/Other/epsxe/shaders/Grayscale/gpuCore.slf", + "name": "gpuCore.slf", + "size": 261, + "sha1": "efa8ae5ed06eba9d4020ff81dc612bf934261803", + "md5": "0d10522eadd5aea406edc29da9d5a6ee", + "sha256": "5e4bfe61cbf89579716b32559d8b92ac733623a414dd0c405894a36ab9457a0f", + "crc32": "81621cda", + "adler32": "123e5384" + }, + "f69915f13de626f3c35bc67c8069720a9a0ea853": { + "path": "bios/Other/epsxe/shaders/gpuPeteOGL2.slf", + "name": "gpuPeteOGL2.slf", + "size": 1136, + "sha1": "f69915f13de626f3c35bc67c8069720a9a0ea853", + "md5": "cc93bcc8c516e0196f2652b8d9b9eeb5", + "sha256": "46cd5cf17654fb5730f1f557a4f864b1cc4d89031906ed5848b21468a5fb5c74", + "crc32": "65ba738e", + "adler32": "cfee53b5" + }, + "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2": { + "path": "bios/Other/epsxe/shaders/gpuPeteOGL2.slv", + "name": "gpuPeteOGL2.slv", + "size": 806, + "sha1": "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2", + "md5": "a4b16b09d8bce6714a919325ffc9a43f", + "sha256": "c113ff0790ba6454089035036f448c261dc4742a3c28bc42f756beddaa8ff3fb", + "crc32": "ed4adc00", + "adler32": "da5cfeff" + }, + "61f09b64c64964cacfec0833f04968a08f7da464": { + "path": "bios/Other/epsxe/shaders/gpucore/delete.me", + "name": "delete.me", + "size": 10, + "sha1": "61f09b64c64964cacfec0833f04968a08f7da464", + "md5": "2e7d76c347da6740e153d154b9064f33", + "sha256": "e33dbd20d732ad6d5c1f8228c36213c9385547f29b4746940bdaccfd52852a21", + "crc32": "aabbe87a", + "adler32": "14ee0370" + }, + "a36992809f946cba845dbe4a8cdc4ee79e413bc0": { + "path": "bios/Other/epsxe/shaders/ogl2/erase.me", + "name": "erase.me", + "size": 9, + "sha1": "a36992809f946cba845dbe4a8cdc4ee79e413bc0", + "md5": "9bc925ed58fe4063cb885b9f8752dcb5", + "sha256": "efe376ead6f70831db442679dcbd211a1d34065617f9cfae75bee791765088ff", + "crc32": "f74f071a", + "adler32": "1113030d" + }, + "339d7581e1a70f8fb287e5a572f6388f5bc00534": { + "path": "bios/Other/epsxe/shaders/super-eagle/gpuCore.ini", + "name": "gpuCore.ini", + "size": 75, + "sha1": "339d7581e1a70f8fb287e5a572f6388f5bc00534", + "md5": "342787edcff4c9bca0725377030b739a", + "sha256": "86c90b07233a952df257ca1eb6b54539bca5d4320d649c8088ad0f41085dcc63", + "crc32": "afc20232", + "adler32": "06c41b10" + }, + "b757316e1cd39bad4e5045480350b7e44903efc8": { + "path": "bios/Other/epsxe/shaders/super-eagle/gpuCore.slf", + "name": "gpuCore.slf", + "size": 3977, + "sha1": "b757316e1cd39bad4e5045480350b7e44903efc8", + "md5": "63346f9c4d4c71f6d592988e024d810d", + "sha256": "3ee27e57524c2cbad894d6c8c2508b8459eee236555ed1272dcb83e1f390f7f6", + "crc32": "e23a78d7", + "adler32": "369f0225" + }, + "ab6dc8c5ba131d3cc827063081b3bd29f650ba90": { + "path": "bios/Other/epsxe/shaders/super-eagle/gpuCore.slv", + "name": "gpuCore.slv", + "size": 1214, + "sha1": "ab6dc8c5ba131d3cc827063081b3bd29f650ba90", + "md5": "5f4bd62ead81e179f200d8c61e223d31", + "sha256": "8868a3c4d98538d0869537c4f6c1b27cd14cad06978e3acbef695c0ececd79e4", + "crc32": "a27ddd49", + "adler32": "f7b47df6" + }, + "a9b9ed5fab307250a69a12ebce4bc44786b8b453": { + "path": "bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.ini", + "name": "gpuCore.ini", + "size": 73, + "sha1": "a9b9ed5fab307250a69a12ebce4bc44786b8b453", + "md5": "fda0237b2046adf21d66b7fb5ac441ae", + "sha256": "db84ab7b4cc327c1ac4513a982e8b2c39bd5ddf64f15d70178f6a94ffdcdef48", + "crc32": "eff8698a", + "adler32": "9c92198c" + }, + "90943fbcd3c23104fcdf7aed70df1e7752f39271": { + "path": "bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slf", + "name": "gpuCore.slf", + "size": 9708, + "sha1": "90943fbcd3c23104fcdf7aed70df1e7752f39271", + "md5": "ec51495fc1c0606a9e2f57bca6602f5a", + "sha256": "a9d7bfddd60c805878707f115e753e494e27ffaa879190dc045ef2eeb120f647", + "crc32": "4a2a86d7", + "adler32": "6966ce2c" + }, + "7eea41770e156b05ddde4195954b5a468f163cdd": { + "path": "bios/Other/epsxe/shaders/xBR-LV2-3D/gpuCore.slv", + "name": "gpuCore.slv", + "size": 962, + "sha1": "7eea41770e156b05ddde4195954b5a468f163cdd", + "md5": "ac7ab73a8c909c61551b2c82f906921e", + "sha256": "89e80f1cb14de9a185ed46f9f4777649d0d8f19a4ac3d2cfe5157f427188f2fd", + "crc32": "50c5f498", + "adler32": "d9b822e7" + }, "84d422b53547271e3a07342704a05ef481db3f99": { "path": "bios/Other/fbneo/136032.101.e3", "name": "136032.101.e3", @@ -96302,6 +96602,36 @@ "8fbeeb5c09477bcaf614087003df61a4": "808b7b46bfb033c7fe4d94d0dbf5a271de30dedc", "b0bdec53b1c50873ba45539565f1327c": "a848aad1840c7d85bfcdd552521a7181b00331cc", "ec6b58f723279afe732b7f9660acf27d": "9b2704655a893ff1675d28df4bd9ffc9e15d3dd5", + "ff44a27f0cf1148cfa87ba17545180cc": "5f589f6b1845927141dac09f6c2b050624ef2d03", + "49ac87eb7a9260da61f836bde9c46c0e": "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01", + "2479682ae26ccb07b37835db0f65fa63": "073a34b093054d217029f7314a2b8142e1dac6b7", + "9ec7c9b77a9cbb2181ab7d6ec904b1e0": "54644d6ec012bcbf9030b369a2fb4dfbedfa511f", + "c1896b87729b76ba2a4a289125466e82": "dcd9f24f47443ec8421e48fef7e37fd8a52c4782", + "3a1874705e39880bc5556261d6e71744": "10de0e6e7f616b67f7aced4fa51a55af9d9fb046", + "b037a7f8e506108db89a9111766e897e": "c966a738bffbe6f5017684318b26f66899e620f4", + "1b37c6b0835d045c86a062267c843e2f": "036e58e46d7264e2d6b08f48bde8b2d83361a661", + "f91347f046724ad7d0d4f4315a8378a1": "687540a168728baf3babaf2dedf74b5f1d2f56b4", + "b3ec1b57cf72c14f0e945cd054d44d11": "f0e3d77db14b4dd11aa7cc71613097600d3e5da3", + "1184808df8031b080289ccdb5b17ba6b": "cda44c87be8b01c7ba23e2ad09a516d1747dee9b", + "b6b4e84b236221b2ece84dc5c1e4f154": "56ad43fc57833eefb116af581c9ad034c53778ee", + "72ac4fd9b61c086d9836486c2f750be2": "a582843e7dac4735392fe82fdf3e6fef88f7ff66", + "f58606c167af7d2b961a06bab8632bd0": "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd", + "c6fc241947fcc671b0ed1fc2dd3baa99": "c06f5745e3ecc0b33e802877b46352d8304b81bc", + "e97109bf49fd31e3f60e2081baf73f5f": "501c31d7614583f6b1f25eb57f67d35343e6dff8", + "c0406730f8e7e0048ab29df2b55aea8b": "339af29d54a62a8d6ddea059d01a1c71dceb741f", + "d9e9b284f38ac79e8e52ed8673a704b0": "b7165607add6023abb9291e3ae80053865ab4a15", + "31c8eac7f0eff22599ec31852a151865": "d0d06fca34ac14d021175be133af413bdbecdf9c", + "0d10522eadd5aea406edc29da9d5a6ee": "efa8ae5ed06eba9d4020ff81dc612bf934261803", + "cc93bcc8c516e0196f2652b8d9b9eeb5": "f69915f13de626f3c35bc67c8069720a9a0ea853", + "a4b16b09d8bce6714a919325ffc9a43f": "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2", + "2e7d76c347da6740e153d154b9064f33": "61f09b64c64964cacfec0833f04968a08f7da464", + "9bc925ed58fe4063cb885b9f8752dcb5": "a36992809f946cba845dbe4a8cdc4ee79e413bc0", + "342787edcff4c9bca0725377030b739a": "339d7581e1a70f8fb287e5a572f6388f5bc00534", + "63346f9c4d4c71f6d592988e024d810d": "b757316e1cd39bad4e5045480350b7e44903efc8", + "5f4bd62ead81e179f200d8c61e223d31": "ab6dc8c5ba131d3cc827063081b3bd29f650ba90", + "fda0237b2046adf21d66b7fb5ac441ae": "a9b9ed5fab307250a69a12ebce4bc44786b8b453", + "ec51495fc1c0606a9e2f57bca6602f5a": "90943fbcd3c23104fcdf7aed70df1e7752f39271", + "ac7ab73a8c909c61551b2c82f906921e": "7eea41770e156b05ddde4195954b5a468f163cdd", "dc1aa189468255e644e44b99ad7da49c": "84d422b53547271e3a07342704a05ef481db3f99", "fc90330915e7c494898615eb58689d68": "2d327e78832edd67ca3909c25b8c8c839637a1ed", "c4abdbe2a64c2ef06b6b659f32ea883f": "0a42a4816c89447b16e1f3245409591efea98a4a", @@ -113628,6 +113958,50 @@ "games.db": [ "0e2ee74d1f9ebc3a6faf9dbaebbacc2ff053f4df" ], + "gpuCore.ini": [ + "5f589f6b1845927141dac09f6c2b050624ef2d03", + "c966a738bffbe6f5017684318b26f66899e620f4", + "687540a168728baf3babaf2dedf74b5f1d2f56b4", + "56ad43fc57833eefb116af581c9ad034c53778ee", + "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd", + "339d7581e1a70f8fb287e5a572f6388f5bc00534", + "a9b9ed5fab307250a69a12ebce4bc44786b8b453" + ], + "gpuCore.slf": [ + "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01", + "54644d6ec012bcbf9030b369a2fb4dfbedfa511f", + "10de0e6e7f616b67f7aced4fa51a55af9d9fb046", + "036e58e46d7264e2d6b08f48bde8b2d83361a661", + "f0e3d77db14b4dd11aa7cc71613097600d3e5da3", + "a582843e7dac4735392fe82fdf3e6fef88f7ff66", + "c06f5745e3ecc0b33e802877b46352d8304b81bc", + "501c31d7614583f6b1f25eb57f67d35343e6dff8", + "b7165607add6023abb9291e3ae80053865ab4a15", + "efa8ae5ed06eba9d4020ff81dc612bf934261803", + "b757316e1cd39bad4e5045480350b7e44903efc8", + "90943fbcd3c23104fcdf7aed70df1e7752f39271" + ], + "gpuCore.slv": [ + "073a34b093054d217029f7314a2b8142e1dac6b7", + "dcd9f24f47443ec8421e48fef7e37fd8a52c4782", + "cda44c87be8b01c7ba23e2ad09a516d1747dee9b", + "339af29d54a62a8d6ddea059d01a1c71dceb741f", + "d0d06fca34ac14d021175be133af413bdbecdf9c", + "ab6dc8c5ba131d3cc827063081b3bd29f650ba90", + "7eea41770e156b05ddde4195954b5a468f163cdd" + ], + "gpuPeteOGL2.slf": [ + "f69915f13de626f3c35bc67c8069720a9a0ea853" + ], + "gpuPeteOGL2.slv": [ + "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2" + ], + "delete.me": [ + "61f09b64c64964cacfec0833f04968a08f7da464" + ], + "erase.me": [ + "a36992809f946cba845dbe4a8cdc4ee79e413bc0" + ], "136032.101.e3": [ "84d422b53547271e3a07342704a05ef481db3f99" ], @@ -132838,6 +133212,36 @@ "51cef730": "808b7b46bfb033c7fe4d94d0dbf5a271de30dedc", "50fb46e4": "a848aad1840c7d85bfcdd552521a7181b00331cc", "69dc25d7": "9b2704655a893ff1675d28df4bd9ffc9e15d3dd5", + "dc249b13": "5f589f6b1845927141dac09f6c2b050624ef2d03", + "e24efa44": "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01", + "e454f02d": "073a34b093054d217029f7314a2b8142e1dac6b7", + "a509c794": "54644d6ec012bcbf9030b369a2fb4dfbedfa511f", + "6b725715": "dcd9f24f47443ec8421e48fef7e37fd8a52c4782", + "04e29286": "10de0e6e7f616b67f7aced4fa51a55af9d9fb046", + "579d5d7c": "c966a738bffbe6f5017684318b26f66899e620f4", + "5ebc2ad4": "036e58e46d7264e2d6b08f48bde8b2d83361a661", + "b01d11f1": "687540a168728baf3babaf2dedf74b5f1d2f56b4", + "e0c2acb6": "f0e3d77db14b4dd11aa7cc71613097600d3e5da3", + "41169e0a": "cda44c87be8b01c7ba23e2ad09a516d1747dee9b", + "7d4623fc": "56ad43fc57833eefb116af581c9ad034c53778ee", + "9c4acf63": "a582843e7dac4735392fe82fdf3e6fef88f7ff66", + "9aea70ac": "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd", + "1979f565": "c06f5745e3ecc0b33e802877b46352d8304b81bc", + "dbade009": "501c31d7614583f6b1f25eb57f67d35343e6dff8", + "e7e004f8": "339af29d54a62a8d6ddea059d01a1c71dceb741f", + "bdca044b": "b7165607add6023abb9291e3ae80053865ab4a15", + "872429df": "d0d06fca34ac14d021175be133af413bdbecdf9c", + "81621cda": "efa8ae5ed06eba9d4020ff81dc612bf934261803", + "65ba738e": "f69915f13de626f3c35bc67c8069720a9a0ea853", + "ed4adc00": "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2", + "aabbe87a": "61f09b64c64964cacfec0833f04968a08f7da464", + "f74f071a": "a36992809f946cba845dbe4a8cdc4ee79e413bc0", + "afc20232": "339d7581e1a70f8fb287e5a572f6388f5bc00534", + "e23a78d7": "b757316e1cd39bad4e5045480350b7e44903efc8", + "a27ddd49": "ab6dc8c5ba131d3cc827063081b3bd29f650ba90", + "eff8698a": "a9b9ed5fab307250a69a12ebce4bc44786b8b453", + "4a2a86d7": "90943fbcd3c23104fcdf7aed70df1e7752f39271", + "50c5f498": "7eea41770e156b05ddde4195954b5a468f163cdd", "7e84972a": "84d422b53547271e3a07342704a05ef481db3f99", "ebf1e0ae": "2d327e78832edd67ca3909c25b8c8c839637a1ed", "92d6a0b4": "0a42a4816c89447b16e1f3245409591efea98a4a", @@ -141495,6 +141899,36 @@ "2e6883d4304c5de25c464a9fd97fcd2f642d8d2af2db9c2b13882e67f0f35b93": "808b7b46bfb033c7fe4d94d0dbf5a271de30dedc", "2db47ffca9510468e37717266838576f96dccd9ed6b7f00c0a721c9868338b19": "a848aad1840c7d85bfcdd552521a7181b00331cc", "27ab08e76e08fa8a1023b076f3e6c23bc6841732658942f30cea634394f40729": "9b2704655a893ff1675d28df4bd9ffc9e15d3dd5", + "d1ef814cb6314357d43089f67a6808df563577604b598da7fc4697cfbe08df50": "5f589f6b1845927141dac09f6c2b050624ef2d03", + "0a7a10c278ec13ae37192d15484bacc646bca67e2aae64fab39cd78dda1547cc": "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01", + "92f06e873b6ca0affd4029ba646c58ae60a47471f7123047c08b2fe3ad45fc41": "073a34b093054d217029f7314a2b8142e1dac6b7", + "70b69879b7583ee3bbcfdddc106a59e5ed66581914bfa2ad1f82285654c5f2a0": "54644d6ec012bcbf9030b369a2fb4dfbedfa511f", + "23ecd34d71b69e2d41b71ca66220792310c26e6799db9351e26cdae287a2f406": "dcd9f24f47443ec8421e48fef7e37fd8a52c4782", + "56f2d9af2060f2f0fd6c2acdccbe57f77a0609a2cfb3f2e324b3c3a4fe704e49": "10de0e6e7f616b67f7aced4fa51a55af9d9fb046", + "06fac91ea6fe36e3e41780da7d631a575893c9dfb56f1369dc639a97c2fc9270": "c966a738bffbe6f5017684318b26f66899e620f4", + "a184f3e62cf87caa00d1e9c044587cb5244567369a5edab5c1dbec43edba3ff3": "036e58e46d7264e2d6b08f48bde8b2d83361a661", + "32db4e009959b5606e3d3153d9cd4c0e1a84312bf07848b595eaec0190ea6b9b": "687540a168728baf3babaf2dedf74b5f1d2f56b4", + "8b39bd12aae661165fc35eb2627c1ea4d7cc26fef179fe2e772abb412bf94e5b": "f0e3d77db14b4dd11aa7cc71613097600d3e5da3", + "9f63333b425c697048c6804d7f30f9a653570143eb897758c7c9fb9d3d8e119c": "cda44c87be8b01c7ba23e2ad09a516d1747dee9b", + "939ac6a08f181b926ed074f83342ff4043ec7237267652ff163650f23852de61": "56ad43fc57833eefb116af581c9ad034c53778ee", + "32e45e1a9cd471bdcf7c0f1b77a425cdda265726e58e2c5a703c27bb343a52ec": "a582843e7dac4735392fe82fdf3e6fef88f7ff66", + "bb046bc18f6e1e78713e5d6f5a5c58a5b4969fe1488f41df6ef9ee0c1f82dcaf": "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd", + "db1955fb12093a469f62f30ae4995663436707149a0bd0212494840b2f52c383": "c06f5745e3ecc0b33e802877b46352d8304b81bc", + "adc966ee2b7e1d61515f49890ddd67cebf6335fe0e8cfb6f6fc6fa2a69a9db11": "501c31d7614583f6b1f25eb57f67d35343e6dff8", + "8205995b3aea42b98adbe8ad99e28a5edfdbc711e74a5e33da045bfa1da4428c": "339af29d54a62a8d6ddea059d01a1c71dceb741f", + "a175f11b2188b4001c51bb548763d92a052211fb7b84cc82e2f492956d9623ec": "b7165607add6023abb9291e3ae80053865ab4a15", + "7160ce15161d0a36f8dc5168b8368a0fc8e2238d40635a3c7be8cccfa884746f": "d0d06fca34ac14d021175be133af413bdbecdf9c", + "5e4bfe61cbf89579716b32559d8b92ac733623a414dd0c405894a36ab9457a0f": "efa8ae5ed06eba9d4020ff81dc612bf934261803", + "46cd5cf17654fb5730f1f557a4f864b1cc4d89031906ed5848b21468a5fb5c74": "f69915f13de626f3c35bc67c8069720a9a0ea853", + "c113ff0790ba6454089035036f448c261dc4742a3c28bc42f756beddaa8ff3fb": "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2", + "e33dbd20d732ad6d5c1f8228c36213c9385547f29b4746940bdaccfd52852a21": "61f09b64c64964cacfec0833f04968a08f7da464", + "efe376ead6f70831db442679dcbd211a1d34065617f9cfae75bee791765088ff": "a36992809f946cba845dbe4a8cdc4ee79e413bc0", + "86c90b07233a952df257ca1eb6b54539bca5d4320d649c8088ad0f41085dcc63": "339d7581e1a70f8fb287e5a572f6388f5bc00534", + "3ee27e57524c2cbad894d6c8c2508b8459eee236555ed1272dcb83e1f390f7f6": "b757316e1cd39bad4e5045480350b7e44903efc8", + "8868a3c4d98538d0869537c4f6c1b27cd14cad06978e3acbef695c0ececd79e4": "ab6dc8c5ba131d3cc827063081b3bd29f650ba90", + "db84ab7b4cc327c1ac4513a982e8b2c39bd5ddf64f15d70178f6a94ffdcdef48": "a9b9ed5fab307250a69a12ebce4bc44786b8b453", + "a9d7bfddd60c805878707f115e753e494e27ffaa879190dc045ef2eeb120f647": "90943fbcd3c23104fcdf7aed70df1e7752f39271", + "89e80f1cb14de9a185ed46f9f4777649d0d8f19a4ac3d2cfe5157f427188f2fd": "7eea41770e156b05ddde4195954b5a468f163cdd", "d7626affff7dfc0a8782e0894770258ea572d0f2d9859690efbc8ce018cb36bc": "84d422b53547271e3a07342704a05ef481db3f99", "81fb611f7dc9d531720836f31e5aff1cc5466013d0afb7ab7f947cb5b7520504": "2d327e78832edd67ca3909c25b8c8c839637a1ed", "c770a3ae305c3420292516dbd86373f67798983c74754d2cc988de6ddf6ec51f": "0a42a4816c89447b16e1f3245409591efea98a4a", @@ -151561,6 +151995,96 @@ "resources/shaders/vulkan/shadeboost.glsl": [ "9b2704655a893ff1675d28df4bd9ffc9e15d3dd5" ], + "shaders/5xBR-v3.7c/gpuCore.ini": [ + "5f589f6b1845927141dac09f6c2b050624ef2d03" + ], + "shaders/5xBR-v3.7c/gpuCore.slf": [ + "a5c69c5c3fde3f6fd5cce8e79efa3ef96a6add01" + ], + "shaders/5xBR-v3.7c/gpuCore.slv": [ + "073a34b093054d217029f7314a2b8142e1dac6b7" + ], + "shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slf": [ + "54644d6ec012bcbf9030b369a2fb4dfbedfa511f" + ], + "shaders/AA_Shader_v2.0_w_Natural_Vision/gpuCore.slv": [ + "dcd9f24f47443ec8421e48fef7e37fd8a52c4782" + ], + "shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slf": [ + "10de0e6e7f616b67f7aced4fa51a55af9d9fb046" + ], + "shaders/Brightness/gpuCore.ini": [ + "c966a738bffbe6f5017684318b26f66899e620f4" + ], + "shaders/Brightness/gpuCore.slf": [ + "036e58e46d7264e2d6b08f48bde8b2d83361a661" + ], + "shaders/CRT-Hyllian/gpuCore.ini": [ + "687540a168728baf3babaf2dedf74b5f1d2f56b4" + ], + "shaders/CRT-Hyllian/gpuCore.slf": [ + "f0e3d77db14b4dd11aa7cc71613097600d3e5da3" + ], + "shaders/CRT-Hyllian/gpuCore.slv": [ + "cda44c87be8b01c7ba23e2ad09a516d1747dee9b" + ], + "shaders/CRT-Hyllian-3D/gpuCore.ini": [ + "56ad43fc57833eefb116af581c9ad034c53778ee" + ], + "shaders/CRT-Hyllian-3D/gpuCore.slf": [ + "a582843e7dac4735392fe82fdf3e6fef88f7ff66" + ], + "shaders/CRT-Lottes/gpuCore.ini": [ + "0f6b69ace5bcd59ba3641bb4d833e120e93eb8dd" + ], + "shaders/CRT-Lottes/gpuCore.slf": [ + "c06f5745e3ecc0b33e802877b46352d8304b81bc" + ], + "shaders/Cartoon_shader_II/gpuCore.slf": [ + "501c31d7614583f6b1f25eb57f67d35343e6dff8" + ], + "shaders/Cartoon_shader_II/gpuCore.slv": [ + "339af29d54a62a8d6ddea059d01a1c71dceb741f" + ], + "shaders/FXAA_natural_vision/gpuCore.slf": [ + "b7165607add6023abb9291e3ae80053865ab4a15" + ], + "shaders/FXAA_natural_vision/gpuCore.slv": [ + "d0d06fca34ac14d021175be133af413bdbecdf9c" + ], + "shaders/Grayscale/gpuCore.slf": [ + "efa8ae5ed06eba9d4020ff81dc612bf934261803" + ], + "shaders/gpuPeteOGL2.slf": [ + "f69915f13de626f3c35bc67c8069720a9a0ea853" + ], + "shaders/gpuPeteOGL2.slv": [ + "fbb4cd76cee5ce70539da8cd24df370bfac1b8a2" + ], + "shaders/gpucore/delete.me": [ + "61f09b64c64964cacfec0833f04968a08f7da464" + ], + "shaders/ogl2/erase.me": [ + "a36992809f946cba845dbe4a8cdc4ee79e413bc0" + ], + "shaders/super-eagle/gpuCore.ini": [ + "339d7581e1a70f8fb287e5a572f6388f5bc00534" + ], + "shaders/super-eagle/gpuCore.slf": [ + "b757316e1cd39bad4e5045480350b7e44903efc8" + ], + "shaders/super-eagle/gpuCore.slv": [ + "ab6dc8c5ba131d3cc827063081b3bd29f650ba90" + ], + "shaders/xBR-LV2-3D/gpuCore.ini": [ + "a9b9ed5fab307250a69a12ebce4bc44786b8b453" + ], + "shaders/xBR-LV2-3D/gpuCore.slf": [ + "90943fbcd3c23104fcdf7aed70df1e7752f39271" + ], + "shaders/xBR-LV2-3D/gpuCore.slv": [ + "7eea41770e156b05ddde4195954b5a468f163cdd" + ], "Feeds/fpLatestTables.xml": [ "bd9de21def48b65b5382c403971a9062928b9345" ], @@ -160979,6 +161503,21 @@ "resources/shaders/vulkan/cas.glsl": [ "005cecf1a5e20b05407d55d0aad22cf81ad66c31" ], + "shaders/AA_Shader_v2.0_w_Natural_Vision_Brightness/gpuCore.slv": [ + "dcd9f24f47443ec8421e48fef7e37fd8a52c4782" + ], + "shaders/Brightness/gpuCore.slv": [ + "073a34b093054d217029f7314a2b8142e1dac6b7" + ], + "shaders/CRT-Lottes/gpuCore.slv": [ + "073a34b093054d217029f7314a2b8142e1dac6b7" + ], + "shaders/Grayscale/gpuCore.slv": [ + "073a34b093054d217029f7314a2b8142e1dac6b7" + ], + "shaders/CRT-Hyllian-3D/gpuCore.slv": [ + "cda44c87be8b01c7ba23e2ad09a516d1747dee9b" + ], "DefaultSounds/20pSlide.wav": [ "f92d854f017d154c9ae0a2351629876515ba48d7" ],