├── ad.html
├── bios
├── arcade.7z
├── gba.zip
├── shader.zip
└── zc210.zip
├── content.html
├── cores
├── 32x-wasm.7z
├── 3do-wasm.7z
├── 3do.json
├── a2600-wasm.7z
├── a5200-wasm.7z
├── a7800-wasm.7z
├── amiga-wasm.7z
├── amiga.json
├── arcade-wasm.7z
├── arcade.json
├── atari2600.json
├── atari5200.json
├── atari7800.json
├── beetle-psx-wasm.7z
├── beetle-psx.json
├── bsnes-wasm.7z
├── bsnes.json
├── fbneo-wasm.7z
├── fbneo.json
├── gb-wasm.7z
├── gb.json
├── gba-wasm.7z
├── gba.json
├── gbc.json
├── jaguar-wasm.7z
├── jaguar.json
├── lynx-wasm.7z
├── lynx.json
├── mame-1-wasm.7z
├── mame-2-wasm.7z
├── mame-3-wasm.7z
├── mame-4-wasm.7z
├── mame-5-wasm.7z
├── mame-6-wasm.7z
├── mame0.193.json
├── mame0.243-1-wasm.7z
├── mame0.243-2-wasm.7z
├── mame0.243-3-wasm.7z
├── mame0.243-4-wasm.7z
├── mame0.243-5-wasm.7z
├── mame0.243-6-wasm.7z
├── mame0.243-7-wasm.7z
├── mame0.243.json
├── mame2003-wasm.7z
├── mame2003.json
├── mesen-wasm.7z
├── mesen.json
├── msx-wasm.7z
├── msx.json
├── n64-wasm.7z
├── n64.json
├── nds-wasm.7z
├── nds.json
├── nes-wasm.7z
├── nes.json
├── ngp-wasm.7z
├── ngp.json
├── openbor-wasm.7z
├── openbor.json
├── pce-wasm.7z
├── pce.json
├── pcfx-wasm.7z
├── pcfx.json
├── psx-wasm.7z
├── psx.json
├── sega-wasm.7z
├── sega32x.json
├── segaCD.json
├── segaGG.json
├── segaMD.json
├── segaMS.json
├── segaSaturn.json
├── segacd-wasm.7z
├── snes-wasm.7z
├── snes.json
├── snes2002-wasm.7z
├── snes2002.json
├── snes2005-wasm.7z
├── snes2005.json
├── snes2010-wasm.7z
├── snes2010.json
├── vb-wasm.7z
├── vb.json
├── vbanext-wasm.7z
├── vbanext.json
├── ws-wasm.7z
├── ws.json
├── zc210-wasm.7z
└── zc210.json
├── emulator.js
├── emulatorjs.css
├── extractor-new.js
├── extractor-new.wasm
├── game.html
├── index.html
├── load.html
├── old
├── NengeDisk.js
├── arcade.html
├── common.js
├── emu_058.js
├── emu_decode_058.js
├── gamepad.js
├── gb.html
├── gba.html
├── lib
│ ├── extract7z.zip
│ ├── extractzip.zip
│ ├── libunrar.min.zip
│ ├── spark-md5.min.zip
│ └── zip.min.js
├── nipplejs.js
├── psx.html
├── run
│ ├── arcade.js
│ ├── gb-test.zip
│ ├── gb.js
│ ├── gba.js
│ ├── other.js
│ └── psx.js
└── test_5_8_0.html
├── readme.md
├── readme.txt
└── shaders
├── 2xScaleHQ.glsl
├── 2xScaleHQ.glslp
├── 4xScaleHQ.glsl
├── 4xScaleHQ.glslp
├── 5xbrz.glsl
├── 5xbrz.glslp
├── 6xbrz.glsl
├── 6xbrz.glslp
├── crt-aperture.glsl
├── crt-aperture.glslp
├── crt-easymode.glsl
├── crt-easymode.glslp
├── crt-geom.glsl
├── crt-geom.glslp
├── crt-mattias.glsl
├── crt-mattias.glslp
├── sgenpt-mix.glsl
└── sgenpt-mix.glslp
/ad.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/ad.html
--------------------------------------------------------------------------------
/bios/arcade.7z:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/bios/arcade.7z
--------------------------------------------------------------------------------
/bios/gba.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/bios/gba.zip
--------------------------------------------------------------------------------
/bios/shader.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/bios/shader.zip
--------------------------------------------------------------------------------
/bios/zc210.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/bios/zc210.zip
--------------------------------------------------------------------------------
/content.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | EmulatorJS
9 |
10 |
11 |
80 |
81 |
82 |
83 |
84 |
86 |
91 |
93 |
95 |
96 |
Select Disc
97 |
98 |
99 |
100 |
24 |
25 |
61 |
62 |
63 |
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | Test
9 |
10 |
11 |
14 |
15 |
26 |
27 |
--------------------------------------------------------------------------------
/load.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | EmulatorJS
7 |
8 |
9 |
10 |
16 |
17 |
18 |
--------------------------------------------------------------------------------
/old/arcade.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Document
8 |
9 |
10 |
16 |
17 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/old/gb.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Document
8 |
9 |
10 |
16 |
17 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/old/gba.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Document
8 |
9 |
10 |
16 |
17 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/old/lib/extract7z.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/old/lib/extract7z.zip
--------------------------------------------------------------------------------
/old/lib/extractzip.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/old/lib/extractzip.zip
--------------------------------------------------------------------------------
/old/lib/libunrar.min.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/old/lib/libunrar.min.zip
--------------------------------------------------------------------------------
/old/lib/spark-md5.min.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/old/lib/spark-md5.min.zip
--------------------------------------------------------------------------------
/old/psx.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Document
8 |
9 |
10 |
16 |
17 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/old/run/arcade.js:
--------------------------------------------------------------------------------
1 | var T= Nenge,I=T.I,F=T.F;
2 | var Module = {};
3 | (async function(){
4 |
5 | let files = await T.FetchItem({
6 | url:'cores/arcade-wasm.7z?'+T.time,
7 | unpack:!0
8 | });
9 | let games = await T.FetchItem({
10 | url:'/xiunoII/game/kof97.zip',
11 | });
12 | let bios = await T.FetchItem({
13 | url:'bios/arcade.7z',
14 | unpack:!0
15 | });
16 | console.log(files,games,game);
17 | files['retroarch.js'] = I.decode(files['retroarch.js']).replace(/function\s*_gettimeofday\(ptr\)\s*\{\n?\s*?var\s*now\s*=\s*/,'function _gettimeofday(ptr) {var now = 1690674045574;').replace(/function\s*callMain\(args\)\s*{/,'function callMain(args) {if(typeof args==="string"){args = ["-v",args,"c37f5e84f377fb892c851b364c55251132d57c66d2f3ea56d2af90bef14773f0"];}console.log(args);');
18 | await T.addJS(files['retroarch.js']);
19 | //await T.addJS('./gb.js?'+T.time);
20 | Module = {
21 | wasmBinary : files['retroarch.wasm'],
22 | canvas:T.$('canvas'),
23 | hash:'2b35cacf70aef5cbb3f38c0bb20e488cc8ad0c350400499a0',
24 | onRuntimeInitialized(){
25 | let args = 'kof97.zip';
26 | I.toArr(bios,v=>this.writeFile(v[0],v[1]));
27 | this.writeFile(args,games);
28 | if(this.specialHTMLTargets){
29 | I[1].assign(this.specialHTMLTargets,{
30 | '#canvas':this.canvas,
31 | '#canvas-input':T.$('#ejs-input'),
32 | '#canvas-mouse':T.$('#game')
33 | });
34 | }
35 | /*
36 | if(this._get_content_crc){
37 | T.$('iframe').src = 'https://www.emulatorjs.com/embed/load.html';
38 | T.once(window,'message',e=>{
39 | console.log(e.data);
40 | if(e.data.key)args[2] = e.data.key;
41 | });
42 | }
43 | */
44 | this.mkdir('/etc');
45 | this.mkdir('/home');
46 | this.mkdir('/shader');
47 | this.mkdir('/saves');
48 | this.mkdir('/home/web_user/.config');
49 | this.mkdir('/home/web_user/retroarch/userdata');
50 | //this.mkdir('/home/web_user/retroarch/userdata/config/remaps/mGBA');
51 | //this.writeFile('/etc/Gambatte/Gambatte.cfg','gambatte_gb_bootloader = "enabled"\ngambatte_gb_colorization = GBA\ngambatte_gb_hwmode = GBA')
52 | this.writeFile('/etc/retroarch.cfg', 'savefile_directory = "/saves"' +
53 | '\nsystem_directory = "/"\n' +
54 | '\nsavestate_directory = "/saves"' +
55 | '\nvideo_vsync = true' +
56 | '\nscreenshot_directory = "/"' +
57 | '\nvideo_shader = "/shader/shader.glslp"' +
58 | '\nvideo_shader_enable = true' +
59 | '\nvideo_font_enable = false' +
60 | '\nvideo_scale = 1.0' +
61 | '\nvideo_gpu_screenshot = false' +
62 | '\ncamera_allow = "false"' +
63 | '\ncamera_driver = "null"' +
64 | '\ncamera_device = "null"'+
65 | '\n');
66 | T.once(T.$('canvas'),'click',async e=>{
67 | //let headers = (await T.FetchItem({url:'https://www.emulatorjs.com/api/v?name=gb',type:'head'}));
68 | //a75d7994cbfc3bfd7f61c328e42a064d7d4c43e0f2069d6c85ff2c6517f6403f
69 | //console.log(headers);
70 | //if(headers.key)args[2] = headers.key;
71 | if(Module._get_content_crc){
72 | args[2] = 'c8b683b2e3b8417696ca6026b160c7a332d57c66d2f3ea56d2af90bef14773f0';
73 | //54f99f60901cd32e55c5ef323c27d0e2 32d57c66d2f3ea56d2af90bef14773f0
74 | //54f99f60901cd32e55c5ef323c27d0e232d57c66d2f3ea56d2af90bef14773f0
75 | }
76 | Module.callMain(args);
77 | console.log('click',args,Module.getCore());
78 |
79 | })
80 | console.log('ok');
81 | },
82 | 'TOTAL_MEMORY': 0x10000000,
83 | 'noInitialRun': !0x0,
84 | 'arguments': [],
85 | 'preRun': [],
86 | 'postRun': [],
87 | 'totalDependencies': 0x0,
88 | print(e){
89 | console.log(e);
90 | },
91 | printErr(e){
92 | console.log(e);
93 | },
94 | inputValue(...a){
95 | return this['cwrap']('simulate_input', 'null', ['number', 'number', 'number'])(...a);
96 | },
97 | setVariable(...a){
98 | return this['cwrap']('set_variable', 'null', ['string', 'string']).apply(this,a);
99 | },
100 | getCore(){
101 | let data = this['cwrap']('get_core_options', 'string', [])();
102 | if(data){
103 | let list = data.split('\n');
104 | return Object.fromEntries(
105 | list.map(v=>{
106 | let s = v.split(';');
107 | return [s[0],s[1]&&s[1].trim().split('|').map(v=>v.trim())];
108 | }));
109 | }
110 | },
111 | readFile(name){
112 | return I.decode(this.FS.readFile(name))
113 | },
114 | mkdir(path){
115 | let FS = this.FS;
116 | if(!FS.analyzePath(path).exists){
117 | let p = path.split('/');
118 | let name = p.pop();
119 | let newpath = p.join('/');
120 | this.mkdir(newpath);
121 | FS.createPath(newpath, name, !0x0, !0x0);
122 | }
123 | },
124 | writeFile(path,data){
125 | let newpath = path.split('/').slice(0,-1).join('/');
126 | newpath&&this.mkdir(newpath);
127 | this.FS.writeFile(path,data);
128 |
129 |
130 | },
131 | };
132 | EmulatorJS_(Module);
133 | })()
--------------------------------------------------------------------------------
/old/run/gb-test.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nenge123/emulatorjs/bfca5cbbd7f8009ef61d71746e410f5a3641c8e8/old/run/gb-test.zip
--------------------------------------------------------------------------------
/old/run/gb.js:
--------------------------------------------------------------------------------
1 | var T= Nenge,I=T.I,F=T.F;
2 | var Module = {};
3 | (async function(){
4 |
5 | let files = await T.FetchItem({
6 | url:'cores/gb-wasm.7z?'+T.time,
7 | unpack:!0
8 | });
9 | let games = await T.FetchItem({
10 | url:'run/gb-test.zip',
11 | unpack:!0
12 | });
13 | /*
14 | let bios = await T.FetchItem({
15 | url:'bios/gba.zip',
16 | unpack:!0
17 | });
18 | */
19 | console.log(files,games,game);
20 |
21 | files['retroarch.js'] = I.decode(files['retroarch.js']).replace(/function\s*_gettimeofday\(ptr\)\s*\{\n?\s*?var\s*now\s*=\s*/,'function _gettimeofday(ptr) {var now = 1690674045574;').replace(/function\s*callMain\(args\)\s*{/,'function callMain(args) {if(typeof args==="string"){args = ["-v",args,"c37f5e84f377fb892c851b364c55251132d57c66d2f3ea56d2af90bef14773f0"];}console.log(args);');
22 | await T.addJS(files['retroarch.js']);
23 | //await T.addJS('./gb.js?'+T.time);
24 | Module = {
25 | wasmBinary : files['retroarch.wasm'],
26 | canvas:T.$('canvas'),
27 | hash:'2b35cacf70aef5cbb3f38c0bb20e488cc8ad0c350400499a0',
28 | onRuntimeInitialized(){
29 | let args = 'test.gbc';
30 | this.writeFile(args,games['test.gb']);
31 | if(this.specialHTMLTargets){
32 | I[1].assign(this.specialHTMLTargets,{
33 | '#canvas':this.canvas,
34 | '#canvas-input':T.$('#ejs-input'),
35 | '#canvas-mouse':T.$('#game')
36 | });
37 | }
38 | /*
39 | if(this._get_content_crc){
40 | T.$('iframe').src = 'https://www.emulatorjs.com/embed/load.html';
41 | T.once(window,'message',e=>{
42 | console.log(e.data);
43 | if(e.data.key)args[2] = e.data.key;
44 | });
45 | }
46 | */
47 | this.mkdir('/etc');
48 | this.mkdir('/home');
49 | this.mkdir('/shader');
50 | this.mkdir('/saves');
51 | this.mkdir('/home/web_user/.config');
52 | this.mkdir('/home/web_user/retroarch/userdata');
53 | //this.mkdir('/home/web_user/retroarch/userdata/config/remaps/mGBA');
54 | this.writeFile('/etc/Gambatte/Gambatte.cfg','gambatte_gb_bootloader = "enabled"\ngambatte_gb_colorization = GBA\ngambatte_gb_hwmode = GBA')
55 | this.writeFile('/etc/retroarch.cfg', 'savefile_directory = "/saves"' +
56 | '\nsystem_directory = "/"\n' +
57 | '\nsavestate_directory = "/saves"' +
58 | '\nvideo_vsync = true' +
59 | '\nscreenshot_directory = "/"' +
60 | '\nvideo_shader = "/shader/shader.glslp"' +
61 | '\nvideo_shader_enable = true' +
62 | '\nvideo_font_enable = false' +
63 | '\nvideo_scale = 1.0' +
64 | '\nvideo_gpu_screenshot = false' +
65 | '\ncamera_allow = "false"' +
66 | '\ncamera_driver = "null"' +
67 | '\ncamera_device = "null"'+
68 | '\n');
69 | T.once(T.$('canvas'),'click',async e=>{
70 | //let headers = (await T.FetchItem({url:'https://www.emulatorjs.com/api/v?name=gb',type:'head'}));
71 | //a75d7994cbfc3bfd7f61c328e42a064d7d4c43e0f2069d6c85ff2c6517f6403f
72 | //console.log(headers);
73 | //if(headers.key)args[2] = headers.key;
74 | await T.loadLibjs('spark-md5.min.zip');
75 | if(Module._get_content_crc){
76 | let k = SparkMD5.hash((T.time/100000).toFixed(0));
77 | args[2] = SparkMD5.hash(k)+'32d57c66d2f3ea56d2af90bef14773f0';
78 | //args[2] = '961a64459508e2435a5ef45e1fc816d232d57c66d2f3ea56d2af90bef14773f0';
79 | }
80 | Module.callMain(args);
81 | console.log('click',args,Module.getCore());
82 |
83 | })
84 | console.log('ok');
85 | },
86 | 'TOTAL_MEMORY': 0x10000000,
87 | 'noInitialRun': !0x0,
88 | 'arguments': [],
89 | 'preRun': [],
90 | 'postRun': [],
91 | 'totalDependencies': 0x0,
92 | print(e){
93 | console.log(e);
94 | },
95 | printErr(e){
96 | console.log(e);
97 | },
98 | inputValue(...a){
99 | return this['cwrap']('simulate_input', 'null', ['number', 'number', 'number'])(...a);
100 | },
101 | setVariable(...a){
102 | return this['cwrap']('set_variable', 'null', ['string', 'string'])(...a);
103 | },
104 | getCore(){
105 | let data = this['cwrap']('get_core_options', 'string', [])();
106 | if(data){
107 | let list = data.split('\n');
108 | return Object.fromEntries(
109 | list.map(v=>{
110 | let s = v.split(';');
111 | return [s[0],s[1]&&s[1].trim().split('|').map(v=>v.trim())];
112 | }));
113 | }
114 | },
115 | readFile(name){
116 | return I.decode(this.FS.readFile(name))
117 | },
118 | mkdir(path){
119 | let FS = this.FS;
120 | if(!FS.analyzePath(path).exists){
121 | let p = path.split('/');
122 | let name = p.pop();
123 | let newpath = p.join('/');
124 | this.mkdir(newpath);
125 | FS.createPath(newpath, name, !0x0, !0x0);
126 | }
127 | },
128 | writeFile(path,data){
129 | let newpath = path.split('/').slice(0,-1).join('/');
130 | newpath&&this.mkdir(newpath);
131 | this.FS.writeFile(path,data);
132 |
133 |
134 | },
135 | };
136 | EmulatorJS_(Module);
137 | })()
--------------------------------------------------------------------------------
/old/run/gba.js:
--------------------------------------------------------------------------------
1 | var T= Nenge,I=T.I,F=T.F;
2 | var Module = {};
3 | (async function(){
4 |
5 | let files = await T.FetchItem({
6 | url:'cores/gba-wasm.7z',
7 | unpack:!0
8 | });
9 | let games = await T.FetchItem({
10 | url:'run/gb-test.zip',
11 | unpack:!0
12 | });
13 | let bios = await T.FetchItem({
14 | url:'bios/gba.zip',
15 | unpack:!0
16 | });
17 | console.log(files,games);files['retroarch.js'] = I.decode(files['retroarch.js']).replace(/function\s*_gettimeofday\(ptr\)\s*\{\n?\s*?var\s*now\s*=\s*/,'function _gettimeofday(ptr) {var now = 1690674045574;').replace(/function\s*callMain\(args\)\s*{/,'function callMain(args) {if(typeof args==="string"){args = ["-v",args,"c37f5e84f377fb892c851b364c55251132d57c66d2f3ea56d2af90bef14773f0"];}console.log(args);');
18 | await T.addJS(files['retroarch.js']);
19 | //await T.addJS('./emu_gba.js?'+T.time);
20 | Module = {
21 | wasmBinary : files['retroarch.wasm'],
22 | canvas:T.$('canvas'),
23 | hash:'2b35cacf70aef5cbb3f38c0bb20e488cc8ad0c350400499a0',
24 | 'TOTAL_MEMORY': 0x10000000,
25 | 'noInitialRun': !0x0,
26 | 'arguments': [],
27 | 'preRun': [],
28 | 'postRun': [],
29 | 'totalDependencies': 0x0,
30 | onRuntimeInitialized(){
31 | let args = 'test.gb';
32 | if(Module.specialHTMLTargets){
33 | I[1].assign(Module.specialHTMLTargets,{
34 | '#canvas':Module.canvas,
35 | '#canvas-input':T.$('#ejs-input'),
36 | '#canvas-mouse':T.$('#game')
37 | });
38 | }
39 | let FS = Module.FS;
40 | this.mkdir('/home/web_user/.config');
41 | this.mkdir('/home/web_user/retroarch/userdata/config/remaps/mGBA');
42 | this.mkdir('/etc/mGBA');
43 | this.mkdir('/shader');
44 | this.mkdir('/saves');
45 | FS.writeFile(args,games['test.gb']);
46 | I.toArr(bios,v=>Module.writeFile(v[0],v[1]));
47 | this.writeFile('/etc/retroarch-core-options.cfg', 'mgba_gb_model = "Game Boy Advance";\nmgba_use_bios = "ON";\nmgba_skip_bios = "OFF"\nmgba_gb_colors = "Grayscale"\nmgba_gb_colors_preset = "3"\nmgba_sgb_borders = "OFF"\nmgba_color_correction = "OFF"\nmgba_interframe_blending = "OFF"\nmgba_audio_low_pass_filter = "enabled"\nmgba_audio_low_pass_range = "60"\nmgba_allow_opposing_directions = "no"\nmgba_solar_sensor_level = "0"\nmgba_force_gbp = "OFF"\nmgba_idle_optimization = ""\nmgba_frameskip = "disabled"\nmgba_frameskip_threshold = ""\nmgba_frameskip_interval = "0"\n');
48 | this.writeFile('/etc/retroarch.cfg', 'savefile_directory = "/saves"' +
49 | '\nsystem_directory = "/"\n' +
50 | '\nsavestate_directory = "/saves"' +
51 | '\nvideo_vsync = true' +
52 | '\nscreenshot_directory = "/"' +
53 | '\nvideo_shader = "/shader/shader.glslp"' +
54 | '\nvideo_shader_enable = true' +
55 | '\nvideo_font_enable = false' +
56 | '\nvideo_scale = 1.0' +
57 | '\nvideo_gpu_screenshot = false' +
58 | '\ncamera_allow = "false"' +
59 | '\ncamera_driver = "null"' +
60 | '\ncamera_device = "null"'+
61 | '\nvideo_smooth = false'+
62 | '\n');
63 | //savefile_directory = /data/saves/gba\nsystem_directory = /\nvideo_vsync = true\nscreenshot_directory = /\nvideo_shader = /shader/shader.glslp\nvideo_shader_enable = true\nvideo_font_enable = false\nvideo_scale = 1.0\nvideo_gpu_screenshot = false\nvideo_smooth = false\n
64 | T.once(T.$('canvas'),'click',async e=>{
65 | Module.callMain(args);
66 | console.log('click',args,Module.getCore());
67 |
68 | })
69 | console.log('ok');
70 | },
71 | print(e){
72 | console.log(e);
73 | },
74 | printErr(e){
75 | console.log(e);
76 | },
77 | inputValue(...a){
78 | return this['cwrap']('simulate_input', 'null', ['number', 'number', 'number'])(...a);
79 | },
80 | setVariable(...a){
81 | return this['cwrap']('set_variable', 'null', ['string', 'string']).apply(this,a);
82 | },
83 | getCore(){
84 | let data = this['cwrap']('get_core_options', 'string', [])();
85 | if(data){
86 | let list = data.split('\n');
87 | return Object.fromEntries(
88 | list.map(v=>{
89 | let s = v.split(';');
90 | return [s[0],s[1]&&s[1].trim().split('|').map(v=>v.trim())];
91 | }));
92 | }
93 | },
94 | readFile(name){
95 | return I.decode(this.FS.readFile(name))
96 | },
97 | mkdir(path){
98 | let FS = this.FS;
99 | if(!FS.analyzePath(path).exists){
100 | let p = path.split('/');
101 | let name = p.pop();
102 | let newpath = p.join('/');
103 | this.mkdir(newpath);
104 | FS.createPath(newpath, name, !0x0, !0x0);
105 | }
106 | },
107 | writeFile(path,data){
108 | let newpath = path.split('/').slice(0,-1).join('/');
109 | newpath&&this.mkdir(newpath);
110 | this.FS.writeFile(path,data);
111 |
112 |
113 | },
114 | };
115 | EmulatorJS_(Module);
116 | })()
--------------------------------------------------------------------------------
/old/run/other.js:
--------------------------------------------------------------------------------
1 | (function (){})()
--------------------------------------------------------------------------------
/old/run/psx.js:
--------------------------------------------------------------------------------
1 | var T= Nenge,I=T.I,F=T.F;
2 | var Module = {};
3 | (async function(){
4 |
5 | let files = await T.FetchItem({
6 | url:'cores/psx-wasm.7z?'+T.time,
7 | unpack:!0
8 | });
9 | let games = await T.FetchItem({
10 | url:'/xiunoII/game/Dragon Quest Monsters 1 & 2.img',
11 | });
12 | /*
13 | let bios = await T.FetchItem({
14 | url:'bios/gba.zip',
15 | unpack:!0
16 | });
17 | */
18 | console.log(files,games,game);
19 | files['retroarch.js'] = I.decode(files['retroarch.js']).replace(/function\s*_gettimeofday\(ptr\)\s*\{\n?\s*?var\s*now\s*=\s*/,'function _gettimeofday(ptr) {var now = 1690674045574;').replace(/function\s*callMain\(args\)\s*{/,'function callMain(args) {if(typeof args==="string"){args = ["-v",args,"c37f5e84f377fb892c851b364c55251132d57c66d2f3ea56d2af90bef14773f0"];}console.log(args);');
20 | await T.addJS(files['retroarch.js']);
21 | //await T.addJS('./gb.js?'+T.time);
22 | Module = {
23 | wasmBinary : files['retroarch.wasm'],
24 | canvas:T.$('canvas'),
25 | hash:'2b35cacf70aef5cbb3f38c0bb20e488cc8ad0c350400499a0',
26 | onRuntimeInitialized(){
27 | let args = 'test.img';
28 | this.writeFile(args,games);
29 | if(this.specialHTMLTargets){
30 | I[1].assign(this.specialHTMLTargets,{
31 | '#canvas':this.canvas,
32 | '#canvas-input':T.$('#ejs-input'),
33 | '#canvas-mouse':T.$('#game')
34 | });
35 | }
36 | /*
37 | if(this._get_content_crc){
38 | T.$('iframe').src = 'https://www.emulatorjs.com/embed/load.html';
39 | T.once(window,'message',e=>{
40 | console.log(e.data);
41 | if(e.data.key)args[2] = e.data.key;
42 | });
43 | }
44 | */
45 | this.mkdir('/etc');
46 | this.mkdir('/home');
47 | this.mkdir('/shader');
48 | this.mkdir('/saves');
49 | this.mkdir('/home/web_user/.config');
50 | this.mkdir('/home/web_user/retroarch/userdata');
51 | //this.mkdir('/home/web_user/retroarch/userdata/config/remaps/mGBA');
52 | this.writeFile('/etc/Gambatte/Gambatte.cfg','gambatte_gb_bootloader = "enabled"\ngambatte_gb_colorization = GBA\ngambatte_gb_hwmode = GBA')
53 | this.writeFile('/etc/retroarch.cfg', 'savefile_directory = "/saves"' +
54 | '\nsystem_directory = "/"\n' +
55 | '\nsavestate_directory = "/saves"' +
56 | '\nvideo_vsync = true' +
57 | '\nscreenshot_directory = "/"' +
58 | '\nvideo_shader = "/shader/shader.glslp"' +
59 | '\nvideo_shader_enable = true' +
60 | '\nvideo_font_enable = false' +
61 | '\nvideo_scale = 1.0' +
62 | '\nvideo_gpu_screenshot = false' +
63 | '\ncamera_allow = "false"' +
64 | '\ncamera_driver = "null"' +
65 | '\ncamera_device = "null"'+
66 | '\n');
67 | T.once(T.$('canvas'),'click',async e=>{
68 | //let headers = (await T.FetchItem({url:'https://www.emulatorjs.com/api/v?name=gb',type:'head'}));
69 | //a75d7994cbfc3bfd7f61c328e42a064d7d4c43e0f2069d6c85ff2c6517f6403f
70 | //console.log(headers);
71 | //if(headers.key)args[2] = headers.key;
72 | if(Module._get_content_crc){
73 | args[2] = 'c8b683b2e3b8417696ca6026b160c7a332d57c66d2f3ea56d2af90bef14773f0';
74 | //f9b93b6662691698b27adbe3b3b6443cf9c6ad468509a5ad8c7b12fd16e65984
75 | }
76 | Module.callMain(args);
77 | console.log('click',args,Module.getCore());
78 |
79 | })
80 | console.log('ok');
81 | },
82 | 'TOTAL_MEMORY': 0x10000000,
83 | 'noInitialRun': !0x0,
84 | 'arguments': [],
85 | 'preRun': [],
86 | 'postRun': [],
87 | 'totalDependencies': 0x0,
88 | print(e){
89 | console.log(e);
90 | },
91 | printErr(e){
92 | console.log(e);
93 | },
94 | inputValue(...a){
95 | return this['cwrap']('simulate_input', 'null', ['number', 'number', 'number'])(...a);
96 | },
97 | setVariable(...a){
98 | return this['cwrap']('set_variable', 'null', ['string', 'string']).apply(this,a);
99 | },
100 | getCore(){
101 | let data = this['cwrap']('get_core_options', 'string', [])();
102 | if(data){
103 | let list = data.split('\n');
104 | return Object.fromEntries(
105 | list.map(v=>{
106 | let s = v.split(';');
107 | return [s[0],s[1]&&s[1].trim().split('|').map(v=>v.trim())];
108 | }));
109 | }
110 | },
111 | readFile(name){
112 | return I.decode(this.FS.readFile(name))
113 | },
114 | mkdir(path){
115 | let FS = this.FS;
116 | if(!FS.analyzePath(path).exists){
117 | let p = path.split('/');
118 | let name = p.pop();
119 | let newpath = p.join('/');
120 | this.mkdir(newpath);
121 | FS.createPath(newpath, name, !0x0, !0x0);
122 | }
123 | },
124 | writeFile(path,data){
125 | let newpath = path.split('/').slice(0,-1).join('/');
126 | newpath&&this.mkdir(newpath);
127 | this.FS.writeFile(path,data);
128 |
129 |
130 | },
131 | };
132 | EmulatorJS_(Module);
133 | })()
--------------------------------------------------------------------------------
/old/test_5_8_0.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | Test
9 |
10 |
11 |
14 |
15 |
16 |
17 |
18 |
19 |
30 |
31 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 |
2 | - [x] no longer fetch new version form emulatorjs.com,I love steamdeck
3 |
4 | - how to work
5 | ```html
6 |
9 |
10 |
21 | ```
22 | - hash key fix
23 | - retroarch.js
24 | ```javascript
25 | function _gettimeofday(ptr) {
26 | var now = Date.now();
27 | HEAP32[ptr >> 2] = now / 1e3 | 0;
28 | HEAP32[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0;
29 | return 0
30 | }
31 | //make the now = 1690674045574
32 | //c37f5e84f377fb892c851b364c55251132d57c66d2f3ea56d2af90bef14773f0
33 | //demo fix
34 | files['retroarch.js'] = I.decode(
35 | files['retroarch.js']
36 | ).replace(
37 | /function\s*_gettimeofday\(ptr\)\s*\{\n?\s*?var\s*now\s*=\s*/,
38 | 'function _gettimeofday(ptr) {var now = 1690674045574;'
39 | );
40 | /* ... */
41 | Module.callMain(['test.gb','c37f5e84f377fb892c851b364c55251132d57c66d2f3ea56d2af90bef14773f0']);
42 | ```
--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
1 | cores and bios folder in
2 |
3 | branches tag: 0.5.8 !
--------------------------------------------------------------------------------
/shaders/2xScaleHQ.glsl:
--------------------------------------------------------------------------------
1 | /*
2 | 2xGLSLHqFilter shader
3 |
4 | Copyright (C) 2005 guest(r) - guest.r@gmail.com
5 |
6 | This program is free software; you can redistribute it and/or
7 | modify it under the terms of the GNU General Public License
8 | as published by the Free Software Foundation; either version 2
9 | of the License, or (at your option) any later version.
10 |
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 | GNU General Public License for more details.
15 |
16 | You should have received a copy of the GNU General Public License
17 | along with this program; if not, write to the Free Software
18 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 | */
20 |
21 | #if defined(VERTEX)
22 |
23 | #if __VERSION__ >= 130
24 | #define COMPAT_VARYING out
25 | #define COMPAT_ATTRIBUTE in
26 | #define COMPAT_TEXTURE texture
27 | #else
28 | #define COMPAT_VARYING varying
29 | #define COMPAT_ATTRIBUTE attribute
30 | #define COMPAT_TEXTURE texture2D
31 | #endif
32 |
33 | #ifdef GL_ES
34 | #define COMPAT_PRECISION mediump
35 | #else
36 | #define COMPAT_PRECISION
37 | #endif
38 |
39 | COMPAT_ATTRIBUTE vec4 VertexCoord;
40 | COMPAT_ATTRIBUTE vec4 COLOR;
41 | COMPAT_ATTRIBUTE vec4 TexCoord;
42 | COMPAT_VARYING vec4 COL0;
43 | COMPAT_VARYING vec4 TEX0;
44 | COMPAT_VARYING vec4 t1;
45 | COMPAT_VARYING vec4 t2;
46 | COMPAT_VARYING vec4 t3;
47 | COMPAT_VARYING vec4 t4;
48 |
49 | vec4 _oPosition1;
50 | uniform mat4 MVPMatrix;
51 | uniform COMPAT_PRECISION int FrameDirection;
52 | uniform COMPAT_PRECISION int FrameCount;
53 | uniform COMPAT_PRECISION vec2 OutputSize;
54 | uniform COMPAT_PRECISION vec2 TextureSize;
55 | uniform COMPAT_PRECISION vec2 InputSize;
56 |
57 | // compatibility #defines
58 | #define vTexCoord TEX0.xy
59 | #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
60 | #define OutSize vec4(OutputSize, 1.0 / OutputSize)
61 |
62 | void main()
63 | {
64 | gl_Position = MVPMatrix * VertexCoord;
65 | TEX0.xy = TexCoord.xy;
66 | float x = 0.5 * SourceSize.z;
67 | float y = 0.5 * SourceSize.w;
68 | vec2 dg1 = vec2( x, y);
69 | vec2 dg2 = vec2(-x, y);
70 | vec2 dx = vec2(x, 0.0);
71 | vec2 dy = vec2(0.0, y);
72 | t1 = vec4(vTexCoord - dg1, vTexCoord - dy);
73 | t2 = vec4(vTexCoord - dg2, vTexCoord + dx);
74 | t3 = vec4(vTexCoord + dg1, vTexCoord + dy);
75 | t4 = vec4(vTexCoord + dg2, vTexCoord - dx);
76 | }
77 |
78 | #elif defined(FRAGMENT)
79 |
80 | #if __VERSION__ >= 130
81 | #define COMPAT_VARYING in
82 | #define COMPAT_TEXTURE texture
83 | out vec4 FragColor;
84 | #else
85 | #define COMPAT_VARYING varying
86 | #define FragColor gl_FragColor
87 | #define COMPAT_TEXTURE texture2D
88 | #endif
89 |
90 | #ifdef GL_ES
91 | #ifdef GL_FRAGMENT_PRECISION_HIGH
92 | precision highp float;
93 | #else
94 | precision mediump float;
95 | #endif
96 | #define COMPAT_PRECISION mediump
97 | #else
98 | #define COMPAT_PRECISION
99 | #endif
100 |
101 | uniform COMPAT_PRECISION int FrameDirection;
102 | uniform COMPAT_PRECISION int FrameCount;
103 | uniform COMPAT_PRECISION vec2 OutputSize;
104 | uniform COMPAT_PRECISION vec2 TextureSize;
105 | uniform COMPAT_PRECISION vec2 InputSize;
106 | uniform sampler2D Texture;
107 | COMPAT_VARYING vec4 TEX0;
108 | COMPAT_VARYING vec4 t1;
109 | COMPAT_VARYING vec4 t2;
110 | COMPAT_VARYING vec4 t3;
111 | COMPAT_VARYING vec4 t4;
112 |
113 | // compatibility #defines
114 | #define Source Texture
115 | #define vTexCoord TEX0.xy
116 |
117 | #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
118 | #define OutSize vec4(OutputSize, 1.0 / OutputSize)
119 |
120 | float mx = 0.325; // start smoothing wt.
121 | float k = -0.250; // wt. decrease factor
122 | float max_w = 0.25; // max filter weight
123 | float min_w =-0.05; // min filter weight
124 | float lum_add = 0.25; // affects smoothing
125 | vec3 dt = vec3(1.0);
126 |
127 | void main()
128 | {
129 | vec3 c00 = COMPAT_TEXTURE(Source, t1.xy).xyz;
130 | vec3 c10 = COMPAT_TEXTURE(Source, t1.zw).xyz;
131 | vec3 c20 = COMPAT_TEXTURE(Source, t2.xy).xyz;
132 | vec3 c01 = COMPAT_TEXTURE(Source, t4.zw).xyz;
133 | vec3 c11 = COMPAT_TEXTURE(Source, vTexCoord).xyz;
134 | vec3 c21 = COMPAT_TEXTURE(Source, t2.zw).xyz;
135 | vec3 c02 = COMPAT_TEXTURE(Source, t4.xy).xyz;
136 | vec3 c12 = COMPAT_TEXTURE(Source, t3.zw).xyz;
137 | vec3 c22 = COMPAT_TEXTURE(Source, t3.xy).xyz;
138 |
139 | float md1 = dot(abs(c00 - c22), dt);
140 | float md2 = dot(abs(c02 - c20), dt);
141 |
142 | float w1 = dot(abs(c22 - c11), dt) * md2;
143 | float w2 = dot(abs(c02 - c11), dt) * md1;
144 | float w3 = dot(abs(c00 - c11), dt) * md2;
145 | float w4 = dot(abs(c20 - c11), dt) * md1;
146 |
147 | float t1 = w1 + w3;
148 | float t2 = w2 + w4;
149 | float ww = max(t1, t2) + 0.0001;
150 |
151 | c11 = (w1 * c00 + w2 * c20 + w3 * c22 + w4 * c02 + ww * c11) / (t1 + t2 + ww);
152 |
153 | float lc1 = k / (0.12 * dot(c10 + c12 + c11, dt) + lum_add);
154 | float lc2 = k / (0.12 * dot(c01 + c21 + c11, dt) + lum_add);
155 |
156 | w1 = clamp(lc1 * dot(abs(c11 - c10), dt) + mx, min_w, max_w);
157 | w2 = clamp(lc2 * dot(abs(c11 - c21), dt) + mx, min_w, max_w);
158 | w3 = clamp(lc1 * dot(abs(c11 - c12), dt) + mx, min_w, max_w);
159 | w4 = clamp(lc2 * dot(abs(c11 - c01), dt) + mx, min_w, max_w);
160 | FragColor = vec4(w1 * c10 + w2 * c21 + w3 * c12 + w4 * c01 + (1.0 - w1 - w2 - w3 - w4) * c11, 1.0);
161 | }
162 | #endif
163 |
--------------------------------------------------------------------------------
/shaders/2xScaleHQ.glslp:
--------------------------------------------------------------------------------
1 | shaders = 1
2 |
3 | shader0 = "2xScaleHQ.glsl"
4 | filter_linear0 = false
5 | scale_type_0 = source
6 |
--------------------------------------------------------------------------------
/shaders/4xScaleHQ.glsl:
--------------------------------------------------------------------------------
1 | /*
2 | 4xGLSLHqFilter shader
3 |
4 | Copyright (C) 2005 guest(r) - guest.r@gmail.com
5 |
6 | This program is free software; you can redistribute it and/or
7 | modify it under the terms of the GNU General Public License
8 | as published by the Free Software Foundation; either version 2
9 | of the License, or (at your option) any later version.
10 |
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 | GNU General Public License for more details.
15 |
16 | You should have received a copy of the GNU General Public License
17 | along with this program; if not, write to the Free Software
18 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 | */
20 |
21 | #if defined(VERTEX)
22 |
23 | #if __VERSION__ >= 130
24 | #define COMPAT_VARYING out
25 | #define COMPAT_ATTRIBUTE in
26 | #define COMPAT_TEXTURE texture
27 | #else
28 | #define COMPAT_VARYING varying
29 | #define COMPAT_ATTRIBUTE attribute
30 | #define COMPAT_TEXTURE texture2D
31 | #endif
32 |
33 | #ifdef GL_ES
34 | #define COMPAT_PRECISION mediump
35 | #else
36 | #define COMPAT_PRECISION
37 | #endif
38 |
39 | COMPAT_ATTRIBUTE vec4 VertexCoord;
40 | COMPAT_ATTRIBUTE vec4 COLOR;
41 | COMPAT_ATTRIBUTE vec4 TexCoord;
42 | COMPAT_VARYING vec4 COL0;
43 | COMPAT_VARYING vec4 TEX0;
44 | COMPAT_VARYING vec4 t1;
45 | COMPAT_VARYING vec4 t2;
46 | COMPAT_VARYING vec4 t3;
47 | COMPAT_VARYING vec4 t4;
48 | COMPAT_VARYING vec4 t5;
49 | COMPAT_VARYING vec4 t6;
50 |
51 | vec4 _oPosition1;
52 | uniform mat4 MVPMatrix;
53 | uniform COMPAT_PRECISION int FrameDirection;
54 | uniform COMPAT_PRECISION int FrameCount;
55 | uniform COMPAT_PRECISION vec2 OutputSize;
56 | uniform COMPAT_PRECISION vec2 TextureSize;
57 | uniform COMPAT_PRECISION vec2 InputSize;
58 |
59 | // compatibility #defines
60 | #define vTexCoord TEX0.xy
61 | #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
62 | #define OutSize vec4(OutputSize, 1.0 / OutputSize)
63 |
64 | void main()
65 | {
66 | gl_Position = MVPMatrix * VertexCoord;
67 | TEX0.xy = TexCoord.xy;
68 | float x = 0.5 * SourceSize.z;
69 | float y = 0.5 * SourceSize.w;
70 | vec2 dg1 = vec2( x, y);
71 | vec2 dg2 = vec2(-x, y);
72 | vec2 sd1 = dg1 * 0.5;
73 | vec2 sd2 = dg2 * 0.5;
74 | vec2 ddx = vec2(x, 0.0);
75 | vec2 ddy = vec2(0.0, y);
76 | t1 = vec4(vTexCoord - sd1, vTexCoord - ddy);
77 | t2 = vec4(vTexCoord - sd2, vTexCoord + ddx);
78 | t3 = vec4(vTexCoord + sd1, vTexCoord + ddy);
79 | t4 = vec4(vTexCoord + sd2, vTexCoord - ddx);
80 | t5 = vec4(vTexCoord - dg1, vTexCoord - dg2);
81 | t6 = vec4(vTexCoord + dg1, vTexCoord + dg2);
82 | }
83 |
84 | #elif defined(FRAGMENT)
85 |
86 | #if __VERSION__ >= 130
87 | #define COMPAT_VARYING in
88 | #define COMPAT_TEXTURE texture
89 | out vec4 FragColor;
90 | #else
91 | #define COMPAT_VARYING varying
92 | #define FragColor gl_FragColor
93 | #define COMPAT_TEXTURE texture2D
94 | #endif
95 |
96 | #ifdef GL_ES
97 | #ifdef GL_FRAGMENT_PRECISION_HIGH
98 | precision highp float;
99 | #else
100 | precision mediump float;
101 | #endif
102 | #define COMPAT_PRECISION mediump
103 | #else
104 | #define COMPAT_PRECISION
105 | #endif
106 |
107 | uniform COMPAT_PRECISION int FrameDirection;
108 | uniform COMPAT_PRECISION int FrameCount;
109 | uniform COMPAT_PRECISION vec2 OutputSize;
110 | uniform COMPAT_PRECISION vec2 TextureSize;
111 | uniform COMPAT_PRECISION vec2 InputSize;
112 | uniform sampler2D Texture;
113 | COMPAT_VARYING vec4 TEX0;
114 | COMPAT_VARYING vec4 t1;
115 | COMPAT_VARYING vec4 t2;
116 | COMPAT_VARYING vec4 t3;
117 | COMPAT_VARYING vec4 t4;
118 | COMPAT_VARYING vec4 t5;
119 | COMPAT_VARYING vec4 t6;
120 |
121 | // compatibility #defines
122 | #define Source Texture
123 | #define vTexCoord TEX0.xy
124 |
125 | #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
126 | #define OutSize vec4(OutputSize, 1.0 / OutputSize)
127 |
128 | float mx = 1.0; // start smoothing wt.
129 | float k = -1.10; // wt. decrease factor
130 | float max_w = 0.75; // max filter weight
131 | float min_w = 0.03; // min filter weight
132 | float lum_add = 0.33; // affects smoothing
133 | vec3 dt = vec3(1.0);
134 |
135 | void main()
136 | {
137 | vec3 c = COMPAT_TEXTURE(Source, vTexCoord).xyz;
138 | vec3 i1 = COMPAT_TEXTURE(Source, t1.xy).xyz;
139 | vec3 i2 = COMPAT_TEXTURE(Source, t2.xy).xyz;
140 | vec3 i3 = COMPAT_TEXTURE(Source, t3.xy).xyz;
141 | vec3 i4 = COMPAT_TEXTURE(Source, t4.xy).xyz;
142 | vec3 o1 = COMPAT_TEXTURE(Source, t5.xy).xyz;
143 | vec3 o3 = COMPAT_TEXTURE(Source, t6.xy).xyz;
144 | vec3 o2 = COMPAT_TEXTURE(Source, t5.zw).xyz;
145 | vec3 o4 = COMPAT_TEXTURE(Source, t6.zw).xyz;
146 | vec3 s1 = COMPAT_TEXTURE(Source, t1.zw).xyz;
147 | vec3 s2 = COMPAT_TEXTURE(Source, t2.zw).xyz;
148 | vec3 s3 = COMPAT_TEXTURE(Source, t3.zw).xyz;
149 | vec3 s4 = COMPAT_TEXTURE(Source, t4.zw).xyz;
150 |
151 | float ko1=dot(abs(o1-c),dt);
152 | float ko2=dot(abs(o2-c),dt);
153 | float ko3=dot(abs(o3-c),dt);
154 | float ko4=dot(abs(o4-c),dt);
155 |
156 | float k1=min(dot(abs(i1-i3),dt),max(ko1,ko3));
157 | float k2=min(dot(abs(i2-i4),dt),max(ko2,ko4));
158 |
159 | float w1 = k2; if(ko3= 130
28 | #define OUT out
29 | #define IN in
30 | #define tex2D texture
31 | #else
32 | #define OUT varying
33 | #define IN attribute
34 | #define tex2D texture2D
35 | #endif
36 |
37 | #ifdef GL_ES
38 | #define PRECISION mediump
39 | #else
40 | #define PRECISION
41 | #endif
42 |
43 | IN vec4 VertexCoord;
44 | IN vec4 Color;
45 | IN vec2 TexCoord;
46 | OUT vec4 color;
47 | OUT vec2 Coord;
48 |
49 | uniform mat4 MVPMatrix;
50 | uniform PRECISION int FrameDirection;
51 | uniform PRECISION int FrameCount;
52 | uniform PRECISION vec2 OutputSize;
53 | uniform PRECISION vec2 TextureSize;
54 | uniform PRECISION vec2 InputSize;
55 |
56 | void main()
57 | {
58 | gl_Position = MVPMatrix * VertexCoord;
59 | color = Color;
60 | Coord = TexCoord;
61 | }
62 |
63 | #elif defined(FRAGMENT)
64 |
65 | #if __VERSION__ >= 130
66 | #define IN in
67 | #define tex2D texture
68 | out vec4 FragColor;
69 | #else
70 | #define IN varying
71 | #define FragColor gl_FragColor
72 | #define tex2D texture2D
73 | #endif
74 |
75 | #ifdef GL_ES
76 | #ifdef GL_FRAGMENT_PRECISION_HIGH
77 | precision highp float;
78 | #else
79 | precision mediump float;
80 | #endif
81 | #define PRECISION mediump
82 | #else
83 | #define PRECISION
84 | #endif
85 |
86 | uniform PRECISION int FrameDirection;
87 | uniform PRECISION int FrameCount;
88 | uniform PRECISION vec2 OutputSize;
89 | uniform PRECISION vec2 TextureSize;
90 | uniform PRECISION vec2 InputSize;
91 | uniform sampler2D Texture;
92 | IN vec2 Coord;
93 |
94 | #ifdef PARAMETER_UNIFORM
95 | uniform PRECISION float SHARPNESS_IMAGE;
96 | uniform PRECISION float SHARPNESS_EDGES;
97 | uniform PRECISION float GLOW_WIDTH;
98 | uniform PRECISION float GLOW_HEIGHT;
99 | uniform PRECISION float GLOW_HALATION;
100 | uniform PRECISION float GLOW_DIFFUSION;
101 | uniform PRECISION float MASK_COLORS;
102 | uniform PRECISION float MASK_STRENGTH;
103 | uniform PRECISION float MASK_SIZE;
104 | uniform PRECISION float SCANLINE_SIZE_MIN;
105 | uniform PRECISION float SCANLINE_SIZE_MAX;
106 | uniform PRECISION float GAMMA_INPUT;
107 | uniform PRECISION float GAMMA_OUTPUT;
108 | uniform PRECISION float BRIGHTNESS;
109 | #else
110 | #define SHARPNESS_IMAGE 1.0
111 | #define SHARPNESS_EDGES 3.0
112 | #define GLOW_WIDTH 0.5
113 | #define GLOW_HEIGHT 0.5
114 | #define GLOW_HALATION 0.1
115 | #define GLOW_DIFFUSION 0.05
116 | #define MASK_COLORS 2.0
117 | #define MASK_STRENGTH 0.3
118 | #define MASK_SIZE 1.0
119 | #define SCANLINE_SIZE_MIN 0.5
120 | #define SCANLINE_SIZE_MAX 1.5
121 | #define GAMMA_INPUT 2.4
122 | #define GAMMA_OUTPUT 2.4
123 | #define BRIGHTNESS 1.5
124 | #endif
125 |
126 | #define FIX(c) max(abs(c), 1e-5)
127 | #define PI 3.141592653589
128 | #define saturate(c) clamp(c, 0.0, 1.0)
129 | #define TEX2D(c) pow(tex2D(tex, c).rgb, vec3(GAMMA_INPUT))
130 |
131 | mat3 get_color_matrix(sampler2D tex, vec2 co, vec2 dx)
132 | {
133 | return mat3(TEX2D(co - dx), TEX2D(co), TEX2D(co + dx));
134 | }
135 |
136 | vec3 blur(mat3 m, float dist, float rad)
137 | {
138 | vec3 x = vec3(dist - 1.0, dist, dist + 1.0) / rad;
139 | vec3 w = exp2(x * x * -1.0);
140 |
141 | return (m[0] * w.x + m[1] * w.y + m[2] * w.z) / (w.x + w.y + w.z);
142 | }
143 |
144 | vec3 filter_gaussian(sampler2D tex, vec2 co, vec2 tex_size)
145 | {
146 | vec2 dx = vec2(1.0 / tex_size.x, 0.0);
147 | vec2 dy = vec2(0.0, 1.0 / tex_size.y);
148 | vec2 pix_co = co * tex_size;
149 | vec2 tex_co = (floor(pix_co) + 0.5) / tex_size;
150 | vec2 dist = (fract(pix_co) - 0.5) * -1.0;
151 |
152 | mat3 line0 = get_color_matrix(tex, tex_co - dy, dx);
153 | mat3 line1 = get_color_matrix(tex, tex_co, dx);
154 | mat3 line2 = get_color_matrix(tex, tex_co + dy, dx);
155 | mat3 column = mat3(blur(line0, dist.x, GLOW_WIDTH),
156 | blur(line1, dist.x, GLOW_WIDTH),
157 | blur(line2, dist.x, GLOW_WIDTH));
158 |
159 | return blur(column, dist.y, GLOW_HEIGHT);
160 | }
161 |
162 | vec3 filter_lanczos(sampler2D tex, vec2 co, vec2 tex_size, float sharp)
163 | {
164 | tex_size.x *= sharp;
165 |
166 | vec2 dx = vec2(1.0 / tex_size.x, 0.0);
167 | vec2 pix_co = co * tex_size - vec2(0.5, 0.0);
168 | vec2 tex_co = (floor(pix_co) + vec2(0.5, 0.0)) / tex_size;
169 | vec2 dist = fract(pix_co);
170 | vec4 coef = PI * vec4(dist.x + 1.0, dist.x, dist.x - 1.0, dist.x - 2.0);
171 |
172 | coef = FIX(coef);
173 | coef = 2.0 * sin(coef) * sin(coef / 2.0) / (coef * coef);
174 | coef /= dot(coef, vec4(1.0));
175 |
176 | vec4 col1 = vec4(TEX2D(tex_co), 1.0);
177 | vec4 col2 = vec4(TEX2D(tex_co + dx), 1.0);
178 |
179 | return (mat4(col1, col1, col2, col2) * coef).rgb;
180 | }
181 |
182 | vec3 get_scanline_weight(float x, vec3 col)
183 | {
184 | vec3 beam = mix(vec3(SCANLINE_SIZE_MIN), vec3(SCANLINE_SIZE_MAX), col);
185 | vec3 x_mul = 2.0 / beam;
186 | vec3 x_offset = x_mul * 0.5;
187 |
188 | return smoothstep(0.0, 1.0, 1.0 - abs(x * x_mul - x_offset)) * x_offset;
189 | }
190 |
191 | vec3 get_mask_weight(float x)
192 | {
193 | float i = mod(floor(x * OutputSize.x * TextureSize.x / (InputSize.x * MASK_SIZE)), MASK_COLORS);
194 |
195 | if (i == 0.0) return mix(vec3(1.0, 0.0, 1.0), vec3(1.0, 0.0, 0.0), MASK_COLORS - 2.0);
196 | else if (i == 1.0) return vec3(0.0, 1.0, 0.0);
197 | else return vec3(0.0, 0.0, 1.0);
198 | }
199 |
200 | void main()
201 | {
202 | vec3 col_glow = filter_gaussian(Texture, Coord, TextureSize);
203 | vec3 col_soft = filter_lanczos(Texture, Coord, TextureSize, SHARPNESS_IMAGE);
204 | vec3 col_sharp = filter_lanczos(Texture, Coord, TextureSize, SHARPNESS_EDGES);
205 | vec3 col = sqrt(col_sharp * col_soft);
206 |
207 | col *= get_scanline_weight(fract(Coord.y * TextureSize.y), col_soft);
208 | col_glow = saturate(col_glow - col);
209 | col += col_glow * col_glow * GLOW_HALATION;
210 | col = mix(col, col * get_mask_weight(Coord.x) * MASK_COLORS, MASK_STRENGTH);
211 | col += col_glow * GLOW_DIFFUSION;
212 | col = pow(col * BRIGHTNESS, vec3(1.0 / GAMMA_OUTPUT));
213 |
214 | FragColor = vec4(col, 1.0);
215 | }
216 |
217 | #endif
218 |
--------------------------------------------------------------------------------
/shaders/crt-aperture.glslp:
--------------------------------------------------------------------------------
1 | shaders = 1
2 |
3 | shader0 = crt-aperture.glsl
4 | filter_linear0 = false
5 |
--------------------------------------------------------------------------------
/shaders/crt-easymode.glsl:
--------------------------------------------------------------------------------
1 | #if defined(VERTEX)
2 |
3 | #if __VERSION__ >= 130
4 | #define COMPAT_VARYING out
5 | #define COMPAT_ATTRIBUTE in
6 | #define COMPAT_TEXTURE texture
7 | #else
8 | #define COMPAT_VARYING varying
9 | #define COMPAT_ATTRIBUTE attribute
10 | #define COMPAT_TEXTURE texture2D
11 | #endif
12 |
13 | #ifdef GL_ES
14 | #define COMPAT_PRECISION mediump
15 | #else
16 | #define COMPAT_PRECISION
17 | #endif
18 | COMPAT_VARYING float _frame_rotation;
19 | struct input_dummy {
20 | vec2 _video_size;
21 | vec2 _texture_size;
22 | vec2 _output_dummy_size;
23 | float _frame_count;
24 | float _frame_direction;
25 | float _frame_rotation;
26 | };
27 | vec4 _oPosition1;
28 | vec4 _r0005;
29 | COMPAT_ATTRIBUTE vec4 VertexCoord;
30 | COMPAT_ATTRIBUTE vec4 TexCoord;
31 | COMPAT_VARYING vec4 TEX0;
32 |
33 | uniform mat4 MVPMatrix;
34 | uniform int FrameDirection;
35 | uniform int FrameCount;
36 | uniform COMPAT_PRECISION vec2 OutputSize;
37 | uniform COMPAT_PRECISION vec2 TextureSize;
38 | uniform COMPAT_PRECISION vec2 InputSize;
39 | void main()
40 | {
41 | vec2 _oTex;
42 | _r0005 = VertexCoord.x*MVPMatrix[0];
43 | _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1];
44 | _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2];
45 | _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3];
46 | _oPosition1 = _r0005;
47 | _oTex = TexCoord.xy;
48 | gl_Position = _r0005;
49 | TEX0.xy = TexCoord.xy;
50 | }
51 | #elif defined(FRAGMENT)
52 |
53 | #if __VERSION__ >= 130
54 | #define COMPAT_VARYING in
55 | #define COMPAT_TEXTURE texture
56 | out vec4 FragColor;
57 | #else
58 | #define COMPAT_VARYING varying
59 | #define FragColor gl_FragColor
60 | #define COMPAT_TEXTURE texture2D
61 | #endif
62 |
63 | #ifdef GL_ES
64 | #ifdef GL_FRAGMENT_PRECISION_HIGH
65 | precision highp float;
66 | #else
67 | precision mediump float;
68 | #endif
69 | #define COMPAT_PRECISION mediump
70 | #else
71 | #define COMPAT_PRECISION
72 | #endif
73 | COMPAT_VARYING float _frame_rotation;
74 | struct input_dummy {
75 | vec2 _video_size;
76 | vec2 _texture_size;
77 | vec2 _output_dummy_size;
78 | float _frame_count;
79 | float _frame_direction;
80 | float _frame_rotation;
81 | };
82 | vec4 _ret_0;
83 | float _TMP30;
84 | float _TMP29;
85 | float _TMP28;
86 | float _TMP13;
87 | float _TMP32;
88 | float _TMP11;
89 | float _TMP10;
90 | float _TMP31;
91 | float _TMP9;
92 | float _TMP8;
93 | float _TMP15;
94 | float _TMP14;
95 | float _TMP33;
96 | vec4 _TMP34;
97 | vec4 _TMP27;
98 | vec4 _TMP25;
99 | vec4 _TMP23;
100 | vec4 _TMP21;
101 | vec4 _TMP26;
102 | vec4 _TMP24;
103 | vec4 _TMP22;
104 | vec4 _TMP20;
105 | float _TMP4;
106 | vec4 _TMP3;
107 | vec4 _TMP2;
108 | float _TMP19;
109 | float _TMP18;
110 | float _TMP17;
111 | float _TMP16;
112 | vec4 _TMP1;
113 | vec2 _TMP0;
114 | uniform sampler2D Texture;
115 | input_dummy _IN1;
116 | float _TMP43;
117 | float _x_step0044;
118 | float _curve0044;
119 | float _a0048;
120 | float _val0052;
121 | float _a0052;
122 | vec4 _TMP57;
123 | vec4 _x0072;
124 | vec2 _c0086;
125 | vec4 _x0088;
126 | vec4 _x0094;
127 | vec2 _c0098;
128 | vec4 _x0100;
129 | vec2 _c0104;
130 | vec4 _x0106;
131 | vec4 _sample_min0110;
132 | vec4 _sample_max0110;
133 | vec4 _r0112;
134 | vec4 _TMP117;
135 | vec2 _co0124;
136 | vec2 _c0126;
137 | vec4 _x0128;
138 | vec4 _x0134;
139 | vec2 _c0138;
140 | vec4 _x0140;
141 | vec2 _c0144;
142 | vec4 _x0146;
143 | vec4 _sample_min0150;
144 | vec4 _sample_max0150;
145 | vec4 _r0152;
146 | vec4 _TMP157;
147 | float _TMP163;
148 | float _x_step0164;
149 | float _curve0164;
150 | float _a0168;
151 | float _val0172;
152 | float _a0172;
153 | float _TMP183;
154 | float _TMP189;
155 | float _x0190;
156 | float _a0196;
157 | float _x0198;
158 | vec2 _x0200;
159 | float _x0208;
160 | COMPAT_VARYING vec4 TEX0;
161 |
162 | uniform COMPAT_PRECISION vec2 OutputSize;
163 | uniform COMPAT_PRECISION vec2 TextureSize;
164 | uniform COMPAT_PRECISION vec2 InputSize;
165 | void main()
166 | {
167 | vec2 _dx1;
168 | vec2 _dy;
169 | vec2 _pix_co;
170 | vec2 _tex_co;
171 | vec2 _dist;
172 | vec3 _col2;
173 | vec3 _col21;
174 | vec4 _coeffs1;
175 | float _luma;
176 | float _bright;
177 | float _scan_weight;
178 | vec2 _mod_fac;
179 | int _dot_no;
180 | vec3 _mask_weight;
181 | vec3 _TMP37;
182 | _dx1 = vec2(1.00000000E+00/TextureSize.x, 0.00000000E+00);
183 | _dy = vec2(0.00000000E+00, 1.00000000E+00/TextureSize.y);
184 | _pix_co = TEX0.xy*TextureSize - vec2( 5.00000000E-01, 5.00000000E-01);
185 | _TMP0 = floor(_pix_co);
186 | _tex_co = (_TMP0 + vec2( 5.00000000E-01, 5.00000000E-01))/TextureSize;
187 | _dist = fract(_pix_co);
188 | _x_step0044 = float((_dist.x >= 5.00000000E-01));
189 | _a0048 = 2.50000000E-01 - (_dist.x - _x_step0044)*(_dist.x - _x_step0044);
190 | _TMP33 = inversesqrt(_a0048);
191 | _TMP14 = 1.00000000E+00/_TMP33;
192 | _a0052 = 5.00000000E-01 - _dist.x;
193 | _val0052 = float((_a0052 > 0.00000000E+00));
194 | _TMP15 = _val0052 - float((_a0052 < 0.00000000E+00));
195 | _curve0044 = 5.00000000E-01 - _TMP14*_TMP15;
196 | _TMP43 = _dist.x + 2.50000000E-01*(_curve0044 - _dist.x);
197 | _coeffs1 = 3.14159274E+00*vec4(1.00000000E+00 + _TMP43, _TMP43, 1.00000000E+00 - _TMP43, 2.00000000E+00 - _TMP43);
198 | _TMP1 = abs(_coeffs1);
199 | _TMP57 = max(_TMP1, vec4( 9.99999975E-06, 9.99999975E-06, 9.99999975E-06, 9.99999975E-06));
200 | _TMP16 = sin(_TMP57.x);
201 | _TMP17 = sin(_TMP57.y);
202 | _TMP18 = sin(_TMP57.z);
203 | _TMP19 = sin(_TMP57.w);
204 | _TMP2 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);
205 | _x0072 = _TMP57/2.00000000E+00;
206 | _TMP16 = sin(_x0072.x);
207 | _TMP17 = sin(_x0072.y);
208 | _TMP18 = sin(_x0072.z);
209 | _TMP19 = sin(_x0072.w);
210 | _TMP3 = vec4(_TMP16, _TMP17, _TMP18, _TMP19);
211 | _coeffs1 = ((2.00000000E+00*_TMP2)*_TMP3)/(_TMP57*_TMP57);
212 | _TMP4 = dot(_coeffs1, vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
213 | _coeffs1 = _coeffs1/_TMP4;
214 | _c0086 = _tex_co - _dx1;
215 | _TMP20 = COMPAT_TEXTURE(Texture, _c0086);
216 | _x0088 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP20 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
217 | _TMP21 = _TMP20*_x0088;
218 | _TMP22 = COMPAT_TEXTURE(Texture, _tex_co);
219 | _x0094 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP22 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
220 | _TMP23 = _TMP22*_x0094;
221 | _c0098 = _tex_co + _dx1;
222 | _TMP24 = COMPAT_TEXTURE(Texture, _c0098);
223 | _x0100 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP24 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
224 | _TMP25 = _TMP24*_x0100;
225 | _c0104 = _tex_co + 2.00000000E+00*_dx1;
226 | _TMP26 = COMPAT_TEXTURE(Texture, _c0104);
227 | _x0106 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP26 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
228 | _TMP27 = _TMP26*_x0106;
229 | _r0112 = _coeffs1.x*_TMP21;
230 | _r0112 = _r0112 + _coeffs1.y*_TMP23;
231 | _r0112 = _r0112 + _coeffs1.z*_TMP25;
232 | _r0112 = _r0112 + _coeffs1.w*_TMP27;
233 | _sample_min0110 = min(_TMP23, _TMP25);
234 | _sample_max0110 = max(_TMP23, _TMP25);
235 | _TMP34 = min(_sample_max0110, _r0112);
236 | _TMP117 = max(_sample_min0110, _TMP34);
237 | _co0124 = _tex_co + _dy;
238 | _c0126 = _co0124 - _dx1;
239 | _TMP20 = COMPAT_TEXTURE(Texture, _c0126);
240 | _x0128 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP20 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
241 | _TMP21 = _TMP20*_x0128;
242 | _TMP22 = COMPAT_TEXTURE(Texture, _co0124);
243 | _x0134 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP22 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
244 | _TMP23 = _TMP22*_x0134;
245 | _c0138 = _co0124 + _dx1;
246 | _TMP24 = COMPAT_TEXTURE(Texture, _c0138);
247 | _x0140 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP24 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
248 | _TMP25 = _TMP24*_x0140;
249 | _c0144 = _co0124 + 2.00000000E+00*_dx1;
250 | _TMP26 = COMPAT_TEXTURE(Texture, _c0144);
251 | _x0146 = vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00) + (_TMP26 - vec4( 1.00000000E+00, 1.00000000E+00, 1.00000000E+00, 1.00000000E+00));
252 | _TMP27 = _TMP26*_x0146;
253 | _r0152 = _coeffs1.x*_TMP21;
254 | _r0152 = _r0152 + _coeffs1.y*_TMP23;
255 | _r0152 = _r0152 + _coeffs1.z*_TMP25;
256 | _r0152 = _r0152 + _coeffs1.w*_TMP27;
257 | _sample_min0150 = min(_TMP23, _TMP25);
258 | _sample_max0150 = max(_TMP23, _TMP25);
259 | _TMP34 = min(_sample_max0150, _r0152);
260 | _TMP157 = max(_sample_min0150, _TMP34);
261 | _x_step0164 = float((_dist.y >= 5.00000000E-01));
262 | _a0168 = 2.50000000E-01 - (_dist.y - _x_step0164)*(_dist.y - _x_step0164);
263 | _TMP33 = inversesqrt(_a0168);
264 | _TMP14 = 1.00000000E+00/_TMP33;
265 | _a0172 = 5.00000000E-01 - _dist.y;
266 | _val0172 = float((_a0172 > 0.00000000E+00));
267 | _TMP15 = _val0172 - float((_a0172 < 0.00000000E+00));
268 | _curve0164 = 5.00000000E-01 - _TMP14*_TMP15;
269 | _TMP163 = _dist.y + (_curve0164 - _dist.y);
270 | _col2 = _TMP117.xyz + _TMP163*(_TMP157.xyz - _TMP117.xyz);
271 | _luma = dot(vec3( 2.12599993E-01, 7.15200007E-01, 7.22000003E-02), _col2);
272 | _TMP8 = max(_col2.y, _col2.z);
273 | _TMP9 = max(_col2.x, _TMP8);
274 | _bright = (_TMP9 + _luma)/2.00000000E+00;
275 | _TMP31 = min(6.49999976E-01, _bright);
276 | _TMP183 = max(3.49999994E-01, _TMP31);
277 | _x0190 = _bright*1.50000000E+00;
278 | _TMP31 = min(1.50000000E+00, _x0190);
279 | _TMP189 = max(1.50000000E+00, _TMP31);
280 | _a0196 = TEX0.y*2.00000000E+00*3.14159274E+00*TextureSize.y;
281 | _TMP10 = cos(_a0196);
282 | _x0198 = _TMP10*5.00000000E-01 + 5.00000000E-01;
283 | _TMP11 = pow(_x0198, _TMP189);
284 | _scan_weight = 1.00000000E+00 - _TMP11;
285 | _x0200 = (TEX0.xy*OutputSize*TextureSize)/InputSize;
286 | _mod_fac = floor(_x0200);
287 | _x0208 = _mod_fac.x/3.00000000E+00;
288 | _TMP32 = floor(_x0208);
289 | _TMP13 = _mod_fac.x - 3.00000000E+00*_TMP32;
290 | _dot_no = int(_TMP13);
291 | if (_dot_no == 0) {
292 | _mask_weight = vec3( 1.00000000E+00, 6.99999988E-01, 6.99999988E-01);
293 | } else {
294 | if (_dot_no == 1) {
295 | _mask_weight = vec3( 6.99999988E-01, 1.00000000E+00, 6.99999988E-01);
296 | } else {
297 | _mask_weight = vec3( 6.99999988E-01, 6.99999988E-01, 1.00000000E+00);
298 | }
299 | }
300 | if (InputSize.y >= 4.00000000E+02) {
301 | _scan_weight = 1.00000000E+00;
302 | }
303 | _col21 = _col2.xyz;
304 | _col2 = _col2*vec3(_scan_weight, _scan_weight, _scan_weight);
305 | _col2 = _col2 + _TMP183*(_col21 - _col2);
306 | _col2 = _col2*_mask_weight;
307 | _TMP28 = pow(_col2.x, 5.55555582E-01);
308 | _TMP29 = pow(_col2.y, 5.55555582E-01);
309 | _TMP30 = pow(_col2.z, 5.55555582E-01);
310 | _col2 = vec3(_TMP28, _TMP29, _TMP30);
311 | _TMP37 = _col2*1.20000005E+00;
312 | _ret_0 = vec4(_TMP37.x, _TMP37.y, _TMP37.z, 1.00000000E+00);
313 | FragColor = _ret_0;
314 | return;
315 | }
316 | #endif
317 |
--------------------------------------------------------------------------------
/shaders/crt-easymode.glslp:
--------------------------------------------------------------------------------
1 | shaders = 1
2 |
3 | shader0 = crt-easymode.glsl
4 | filter_linear0 = false
5 | scale_type_0 = source
6 |
--------------------------------------------------------------------------------
/shaders/crt-geom.glsl:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | CRT-interlaced
4 |
5 | Copyright (C) 2010-2012 cgwg, Themaister and DOLLS
6 |
7 | This program is free software; you can redistribute it and/or modify it
8 | under the terms of the GNU General Public License as published by the Free
9 | Software Foundation; either version 2 of the License, or (at your option)
10 | any later version.
11 |
12 | (cgwg gave their consent to have the original version of this shader
13 | distributed under the GPL in this message:
14 |
15 | http://board.byuu.org/viewtopic.php?p=26075#p26075
16 |
17 | "Feel free to distribute my shaders under the GPL. After all, the
18 | barrel distortion code was taken from the Curvature shader, which is
19 | under the GPL."
20 | )
21 | This shader variant is pre-configured with screen curvature
22 | */
23 | /*
24 | #pragma parameter CRTgamma "CRTGeom Target Gamma" 2.4 0.1 5.0 0.1
25 | #pragma parameter monitorgamma "CRTGeom Monitor Gamma" 2.2 0.1 5.0 0.1
26 | #pragma parameter d "CRTGeom Distance" 1.6 0.1 3.0 0.1
27 | #pragma parameter CURVATURE "CRTGeom Curvature Toggle" 1.0 0.0 1.0 1.0
28 | #pragma parameter R "CRTGeom Curvature Radius" 2.0 0.1 10.0 0.1
29 | #pragma parameter cornersize "CRTGeom Corner Size" 0.03 0.001 1.0 0.005
30 | #pragma parameter cornersmooth "CRTGeom Corner Smoothness" 1000.0 80.0 2000.0 100.0
31 | #pragma parameter x_tilt "CRTGeom Horizontal Tilt" 0.0 -0.5 0.5 0.05
32 | #pragma parameter y_tilt "CRTGeom Vertical Tilt" 0.0 -0.5 0.5 0.05
33 | #pragma parameter overscan_x "CRTGeom Horiz. Overscan %" 100.0 -125.0 125.0 1.0
34 | #pragma parameter overscan_y "CRTGeom Vert. Overscan %" 100.0 -125.0 125.0 1.0
35 | #pragma parameter DOTMASK "CRTGeom Dot Mask Toggle" 0.3 0.0 0.3 0.3
36 | #pragma parameter SHARPER "CRTGeom Sharpness" 1.0 1.0 3.0 1.0
37 | #pragma parameter scanline_weight "CRTGeom Scanline Weight" 0.3 0.1 0.5 0.05
38 | */
39 |
40 | #ifndef PARAMETER_UNIFORM
41 | #define CRTgamma 2.4
42 | #define monitorgamma 2.2
43 | #define d 1.6
44 | #define CURVATURE 1.0
45 | #define R 2.0
46 | #define cornersize 0.03
47 | #define cornersmooth 1000.0
48 | #define x_tilt 0.0
49 | #define y_tilt 0.0
50 | #define overscan_x 100.0
51 | #define overscan_y 100.0
52 | #define DOTMASK 0.3
53 | #define SHARPER 1.0
54 | #define scanline_weight 0.3
55 | #endif
56 |
57 | #if defined(VERTEX)
58 |
59 | #if __VERSION__ >= 130
60 | #define COMPAT_VARYING out
61 | #define COMPAT_ATTRIBUTE in
62 | #define COMPAT_TEXTURE texture
63 | #else
64 | #define COMPAT_VARYING varying
65 | #define COMPAT_ATTRIBUTE attribute
66 | #define COMPAT_TEXTURE texture2D
67 | #endif
68 |
69 | #ifdef GL_ES
70 | #define COMPAT_PRECISION mediump
71 | #else
72 | #define COMPAT_PRECISION
73 | #endif
74 |
75 | COMPAT_ATTRIBUTE vec4 VertexCoord;
76 | COMPAT_ATTRIBUTE vec4 COLOR;
77 | COMPAT_ATTRIBUTE vec4 TexCoord;
78 | COMPAT_VARYING vec4 COL0;
79 | COMPAT_VARYING vec4 TEX0;
80 |
81 | vec4 _oPosition1;
82 | uniform mat4 MVPMatrix;
83 | uniform COMPAT_PRECISION int FrameDirection;
84 | uniform COMPAT_PRECISION int FrameCount;
85 | uniform COMPAT_PRECISION vec2 OutputSize;
86 | uniform COMPAT_PRECISION vec2 TextureSize;
87 | uniform COMPAT_PRECISION vec2 InputSize;
88 |
89 | COMPAT_VARYING vec2 overscan;
90 | COMPAT_VARYING vec2 aspect;
91 | COMPAT_VARYING vec3 stretch;
92 | COMPAT_VARYING vec2 sinangle;
93 | COMPAT_VARYING vec2 cosangle;
94 | COMPAT_VARYING vec2 one;
95 | COMPAT_VARYING float mod_factor;
96 | COMPAT_VARYING vec2 ilfac;
97 |
98 | #ifdef PARAMETER_UNIFORM
99 | uniform COMPAT_PRECISION float CRTgamma;
100 | uniform COMPAT_PRECISION float monitorgamma;
101 | uniform COMPAT_PRECISION float d;
102 | uniform COMPAT_PRECISION float CURVATURE;
103 | uniform COMPAT_PRECISION float R;
104 | uniform COMPAT_PRECISION float cornersize;
105 | uniform COMPAT_PRECISION float cornersmooth;
106 | uniform COMPAT_PRECISION float x_tilt;
107 | uniform COMPAT_PRECISION float y_tilt;
108 | uniform COMPAT_PRECISION float overscan_x;
109 | uniform COMPAT_PRECISION float overscan_y;
110 | uniform COMPAT_PRECISION float DOTMASK;
111 | uniform COMPAT_PRECISION float SHARPER;
112 | uniform COMPAT_PRECISION float scanline_weight;
113 | #endif
114 |
115 | #define FIX(c) max(abs(c), 1e-5);
116 |
117 | float intersect(vec2 xy)
118 | {
119 | float A = dot(xy,xy)+d*d;
120 | float B = 2.0*(R*(dot(xy,sinangle)-d*cosangle.x*cosangle.y)-d*d);
121 | float C = d*d + 2.0*R*d*cosangle.x*cosangle.y;
122 | return (-B-sqrt(B*B-4.0*A*C))/(2.0*A);
123 | }
124 |
125 | vec2 bkwtrans(vec2 xy)
126 | {
127 | float c = intersect(xy);
128 | vec2 point = vec2(c)*xy;
129 | point -= vec2(-R)*sinangle;
130 | point /= vec2(R);
131 | vec2 tang = sinangle/cosangle;
132 | vec2 poc = point/cosangle;
133 | float A = dot(tang,tang)+1.0;
134 | float B = -2.0*dot(poc,tang);
135 | float C = dot(poc,poc)-1.0;
136 | float a = (-B+sqrt(B*B-4.0*A*C))/(2.0*A);
137 | vec2 uv = (point-a*sinangle)/cosangle;
138 | float r = R*acos(a);
139 | return uv*r/sin(r/R);
140 | }
141 |
142 | vec2 fwtrans(vec2 uv)
143 | {
144 | float r = FIX(sqrt(dot(uv,uv)));
145 | uv *= sin(r/R)/r;
146 | float x = 1.0-cos(r/R);
147 | float D = d/R + x*cosangle.x*cosangle.y+dot(uv,sinangle);
148 | return d*(uv*cosangle-x*sinangle)/D;
149 | }
150 |
151 | vec3 maxscale()
152 | {
153 | vec2 c = bkwtrans(-R * sinangle / (1.0 + R/d*cosangle.x*cosangle.y));
154 | vec2 a = vec2(0.5,0.5)*aspect;
155 | vec2 lo = vec2(fwtrans(vec2(-a.x,c.y)).x, fwtrans(vec2(c.x,-a.y)).y)/aspect;
156 | vec2 hi = vec2(fwtrans(vec2(+a.x,c.y)).x, fwtrans(vec2(c.x,+a.y)).y)/aspect;
157 | return vec3((hi+lo)*aspect*0.5,max(hi.x-lo.x,hi.y-lo.y));
158 | }
159 |
160 | void main()
161 | {
162 | // START of parameters
163 |
164 | // gamma of simulated CRT
165 | // CRTgamma = 1.8;
166 | // gamma of display monitor (typically 2.2 is correct)
167 | // monitorgamma = 2.2;
168 | // overscan (e.g. 1.02 for 2% overscan)
169 | overscan = vec2(1.00,1.00);
170 | // aspect ratio
171 | aspect = vec2(1.0, 0.75);
172 | // lengths are measured in units of (approximately) the width
173 | // of the monitor simulated distance from viewer to monitor
174 | // d = 2.0;
175 | // radius of curvature
176 | // R = 1.5;
177 | // tilt angle in radians
178 | // (behavior might be a bit wrong if both components are
179 | // nonzero)
180 | const vec2 angle = vec2(0.0,0.0);
181 | // size of curved corners
182 | // cornersize = 0.03;
183 | // border smoothness parameter
184 | // decrease if borders are too aliased
185 | // cornersmooth = 1000.0;
186 |
187 | // END of parameters
188 |
189 | vec4 _oColor;
190 | vec2 _otexCoord;
191 | gl_Position = VertexCoord.x * MVPMatrix[0] + VertexCoord.y * MVPMatrix[1] + VertexCoord.z * MVPMatrix[2] + VertexCoord.w * MVPMatrix[3];
192 | _oPosition1 = gl_Position;
193 | _oColor = COLOR;
194 | _otexCoord = TexCoord.xy;
195 | COL0 = COLOR;
196 | TEX0.xy = TexCoord.xy;
197 |
198 | // Precalculate a bunch of useful values we'll need in the fragment
199 | // shader.
200 | sinangle = sin(vec2(x_tilt, y_tilt)) + vec2(0.001);//sin(vec2(max(abs(x_tilt), 1e-3), max(abs(y_tilt), 1e-3)));
201 | cosangle = cos(vec2(x_tilt, y_tilt)) + vec2(0.001);//cos(vec2(max(abs(x_tilt), 1e-3), max(abs(y_tilt), 1e-3)));
202 | stretch = maxscale();
203 |
204 | ilfac = vec2(1.0,clamp(floor(InputSize.y/200.0), 1.0, 2.0));
205 |
206 | // The size of one texel, in texture-coordinates.
207 | vec2 sharpTextureSize = vec2(SHARPER * TextureSize.x, TextureSize.y);
208 | one = ilfac / sharpTextureSize;
209 |
210 | // Resulting X pixel-coordinate of the pixel we're drawing.
211 | mod_factor = TexCoord.x * TextureSize.x * OutputSize.x / InputSize.x;
212 |
213 | }
214 |
215 | #elif defined(FRAGMENT)
216 |
217 | #if __VERSION__ >= 130
218 | #define COMPAT_VARYING in
219 | #define COMPAT_TEXTURE texture
220 | out vec4 FragColor;
221 | #else
222 | #define COMPAT_VARYING varying
223 | #define FragColor gl_FragColor
224 | #define COMPAT_TEXTURE texture2D
225 | #endif
226 |
227 | #ifdef GL_ES
228 | #ifdef GL_FRAGMENT_PRECISION_HIGH
229 | precision highp float;
230 | #else
231 | precision mediump float;
232 | #endif
233 | #define COMPAT_PRECISION mediump
234 | #else
235 | #define COMPAT_PRECISION
236 | #endif
237 |
238 | struct output_dummy {
239 | vec4 _color;
240 | };
241 |
242 | uniform COMPAT_PRECISION int FrameDirection;
243 | uniform COMPAT_PRECISION int FrameCount;
244 | uniform COMPAT_PRECISION vec2 OutputSize;
245 | uniform COMPAT_PRECISION vec2 TextureSize;
246 | uniform COMPAT_PRECISION vec2 InputSize;
247 | uniform sampler2D Texture;
248 | COMPAT_VARYING vec4 TEX0;
249 |
250 | // Comment the next line to disable interpolation in linear gamma (and
251 | // gain speed).
252 | #define LINEAR_PROCESSING
253 |
254 | // Enable screen curvature.
255 | // #define CURVATURE
256 |
257 | // Enable 3x oversampling of the beam profile
258 | #define OVERSAMPLE
259 |
260 | // Use the older, purely gaussian beam profile
261 | //#define USEGAUSSIAN
262 |
263 | // Macros.
264 | #define FIX(c) max(abs(c), 1e-5);
265 | #define PI 3.141592653589
266 |
267 | #ifdef LINEAR_PROCESSING
268 | # define TEX2D(c) pow(COMPAT_TEXTURE(Texture, (c)), vec4(CRTgamma))
269 | #else
270 | # define TEX2D(c) COMPAT_TEXTURE(Texture, (c))
271 | #endif
272 |
273 | COMPAT_VARYING vec2 one;
274 | COMPAT_VARYING float mod_factor;
275 | COMPAT_VARYING vec2 ilfac;
276 | COMPAT_VARYING vec2 overscan;
277 | COMPAT_VARYING vec2 aspect;
278 | COMPAT_VARYING vec3 stretch;
279 | COMPAT_VARYING vec2 sinangle;
280 | COMPAT_VARYING vec2 cosangle;
281 |
282 | #ifdef PARAMETER_UNIFORM
283 | uniform COMPAT_PRECISION float CRTgamma;
284 | uniform COMPAT_PRECISION float monitorgamma;
285 | uniform COMPAT_PRECISION float d;
286 | uniform COMPAT_PRECISION float CURVATURE;
287 | uniform COMPAT_PRECISION float R;
288 | uniform COMPAT_PRECISION float cornersize;
289 | uniform COMPAT_PRECISION float cornersmooth;
290 | uniform COMPAT_PRECISION float x_tilt;
291 | uniform COMPAT_PRECISION float y_tilt;
292 | uniform COMPAT_PRECISION float overscan_x;
293 | uniform COMPAT_PRECISION float overscan_y;
294 | uniform COMPAT_PRECISION float DOTMASK;
295 | uniform COMPAT_PRECISION float SHARPER;
296 | uniform COMPAT_PRECISION float scanline_weight;
297 | #endif
298 |
299 | float intersect(vec2 xy)
300 | {
301 | float A = dot(xy,xy)+d*d;
302 | float B = 2.0*(R*(dot(xy,sinangle)-d*cosangle.x*cosangle.y)-d*d);
303 | float C = d*d + 2.0*R*d*cosangle.x*cosangle.y;
304 | return (-B-sqrt(B*B-4.0*A*C))/(2.0*A);
305 | }
306 |
307 | vec2 bkwtrans(vec2 xy)
308 | {
309 | float c = intersect(xy);
310 | vec2 point = vec2(c)*xy;
311 | point -= vec2(-R)*sinangle;
312 | point /= vec2(R);
313 | vec2 tang = sinangle/cosangle;
314 | vec2 poc = point/cosangle;
315 | float A = dot(tang,tang)+1.0;
316 | float B = -2.0*dot(poc,tang);
317 | float C = dot(poc,poc)-1.0;
318 | float a = (-B+sqrt(B*B-4.0*A*C))/(2.0*A);
319 | vec2 uv = (point-a*sinangle)/cosangle;
320 | float r = FIX(R*acos(a));
321 | return uv*r/sin(r/R);
322 | }
323 |
324 | vec2 transform(vec2 coord)
325 | {
326 | coord *= TextureSize / InputSize;
327 | coord = (coord-vec2(0.5))*aspect*stretch.z+stretch.xy;
328 | return (bkwtrans(coord)/vec2(overscan_x / 100.0, overscan_y / 100.0)/aspect+vec2(0.5)) * InputSize / TextureSize;
329 | }
330 |
331 | float corner(vec2 coord)
332 | {
333 | coord *= TextureSize / InputSize;
334 | coord = (coord - vec2(0.5)) * vec2(overscan_x / 100.0, overscan_y / 100.0) + vec2(0.5);
335 | coord = min(coord, vec2(1.0)-coord) * aspect;
336 | vec2 cdist = vec2(cornersize);
337 | coord = (cdist - min(coord,cdist));
338 | float dist = sqrt(dot(coord,coord));
339 | return clamp((cdist.x-dist)*cornersmooth,0.0, 1.0);
340 | }
341 |
342 | // Calculate the influence of a scanline on the current pixel.
343 | //
344 | // 'distance' is the distance in texture coordinates from the current
345 | // pixel to the scanline in question.
346 | // 'color' is the colour of the scanline at the horizontal location of
347 | // the current pixel.
348 | vec4 scanlineWeights(float distance, vec4 color)
349 | {
350 | // "wid" controls the width of the scanline beam, for each RGB
351 | // channel The "weights" lines basically specify the formula
352 | // that gives you the profile of the beam, i.e. the intensity as
353 | // a function of distance from the vertical center of the
354 | // scanline. In this case, it is gaussian if width=2, and
355 | // becomes nongaussian for larger widths. Ideally this should
356 | // be normalized so that the integral across the beam is
357 | // independent of its width. That is, for a narrower beam
358 | // "weights" should have a higher peak at the center of the
359 | // scanline than for a wider beam.
360 | #ifdef USEGAUSSIAN
361 | vec4 wid = 0.3 + 0.1 * pow(color, vec4(3.0));
362 | vec4 weights = vec4(distance / wid);
363 | return 0.4 * exp(-weights * weights) / wid;
364 | #else
365 | vec4 wid = 2.0 + 2.0 * pow(color, vec4(4.0));
366 | vec4 weights = vec4(distance / scanline_weight);
367 | return 1.4 * exp(-pow(weights * inversesqrt(0.5 * wid), wid)) / (0.6 + 0.2 * wid);
368 | #endif
369 | }
370 |
371 | void main()
372 | {
373 | // Here's a helpful diagram to keep in mind while trying to
374 | // understand the code:
375 | //
376 | // | | | | |
377 | // -------------------------------
378 | // | | | | |
379 | // | 01 | 11 | 21 | 31 | <-- current scanline
380 | // | | @ | | |
381 | // -------------------------------
382 | // | | | | |
383 | // | 02 | 12 | 22 | 32 | <-- next scanline
384 | // | | | | |
385 | // -------------------------------
386 | // | | | | |
387 | //
388 | // Each character-cell represents a pixel on the output
389 | // surface, "@" represents the current pixel (always somewhere
390 | // in the bottom half of the current scan-line, or the top-half
391 | // of the next scanline). The grid of lines represents the
392 | // edges of the texels of the underlying texture.
393 |
394 | // Texture coordinates of the texel containing the active pixel.
395 | vec2 xy = (CURVATURE > 0.5) ? transform(TEX0.xy) : TEX0.xy;
396 |
397 | float cval = corner(xy);
398 |
399 | // Of all the pixels that are mapped onto the texel we are
400 | // currently rendering, which pixel are we currently rendering?
401 | vec2 ilvec = vec2(0.0,ilfac.y > 1.5 ? mod(float(FrameCount),2.0) : 0.0);
402 | vec2 ratio_scale = (xy * TextureSize - vec2(0.5) + ilvec)/ilfac;
403 | #ifdef OVERSAMPLE
404 | float filter_ = InputSize.y/OutputSize.y;//fwidth(ratio_scale.y);
405 | #endif
406 | vec2 uv_ratio = fract(ratio_scale);
407 |
408 | // Snap to the center of the underlying texel.
409 | xy = (floor(ratio_scale)*ilfac + vec2(0.5) - ilvec) / TextureSize;
410 |
411 | // Calculate Lanczos scaling coefficients describing the effect
412 | // of various neighbour texels in a scanline on the current
413 | // pixel.
414 | vec4 coeffs = PI * vec4(1.0 + uv_ratio.x, uv_ratio.x, 1.0 - uv_ratio.x, 2.0 - uv_ratio.x);
415 |
416 | // Prevent division by zero.
417 | coeffs = FIX(coeffs);
418 |
419 | // Lanczos2 kernel.
420 | coeffs = 2.0 * sin(coeffs) * sin(coeffs / 2.0) / (coeffs * coeffs);
421 |
422 | // Normalize.
423 | coeffs /= dot(coeffs, vec4(1.0));
424 |
425 | // Calculate the effective colour of the current and next
426 | // scanlines at the horizontal location of the current pixel,
427 | // using the Lanczos coefficients above.
428 | vec4 col = clamp(mat4(
429 | TEX2D(xy + vec2(-one.x, 0.0)),
430 | TEX2D(xy),
431 | TEX2D(xy + vec2(one.x, 0.0)),
432 | TEX2D(xy + vec2(2.0 * one.x, 0.0))) * coeffs,
433 | 0.0, 1.0);
434 | vec4 col2 = clamp(mat4(
435 | TEX2D(xy + vec2(-one.x, one.y)),
436 | TEX2D(xy + vec2(0.0, one.y)),
437 | TEX2D(xy + one),
438 | TEX2D(xy + vec2(2.0 * one.x, one.y))) * coeffs,
439 | 0.0, 1.0);
440 |
441 | #ifndef LINEAR_PROCESSING
442 | col = pow(col , vec4(CRTgamma));
443 | col2 = pow(col2, vec4(CRTgamma));
444 | #endif
445 |
446 | // Calculate the influence of the current and next scanlines on
447 | // the current pixel.
448 | vec4 weights = scanlineWeights(uv_ratio.y, col);
449 | vec4 weights2 = scanlineWeights(1.0 - uv_ratio.y, col2);
450 | #ifdef OVERSAMPLE
451 | uv_ratio.y =uv_ratio.y+1.0/3.0*filter_;
452 | weights = (weights+scanlineWeights(uv_ratio.y, col))/3.0;
453 | weights2=(weights2+scanlineWeights(abs(1.0-uv_ratio.y), col2))/3.0;
454 | uv_ratio.y =uv_ratio.y-2.0/3.0*filter_;
455 | weights=weights+scanlineWeights(abs(uv_ratio.y), col)/3.0;
456 | weights2=weights2+scanlineWeights(abs(1.0-uv_ratio.y), col2)/3.0;
457 | #endif
458 |
459 | vec3 mul_res = (col * weights + col2 * weights2).rgb * vec3(cval);
460 |
461 | // dot-mask emulation:
462 | // Output pixels are alternately tinted green and magenta.
463 | vec3 dotMaskWeights = mix(
464 | vec3(1.0, 1.0 - DOTMASK, 1.0),
465 | vec3(1.0 - DOTMASK, 1.0, 1.0 - DOTMASK),
466 | floor(mod(mod_factor, 2.0))
467 | );
468 |
469 | mul_res *= dotMaskWeights;
470 |
471 | // Convert the image gamma for display on our output device.
472 | mul_res = pow(mul_res, vec3(1.0 / monitorgamma));
473 |
474 | // Color the texel.
475 | output_dummy _OUT;
476 | _OUT._color = vec4(mul_res, 1.0);
477 | FragColor = _OUT._color;
478 | return;
479 | }
480 | #endif
481 |
482 |
--------------------------------------------------------------------------------
/shaders/crt-geom.glslp:
--------------------------------------------------------------------------------
1 | shaders = 1
2 |
3 | shader0 = crt-geom.glsl
4 | filter_linear0 = false
5 | scale_type_0 = source
6 |
--------------------------------------------------------------------------------
/shaders/crt-mattias.glsl:
--------------------------------------------------------------------------------
1 |
2 | #pragma parameter CURVATURE "Curvature" 0.5 0.0 1.0 0.05
3 | #pragma parameter SCANSPEED "Scanline Crawl Speed" 1.0 0.0 10.0 0.5
4 | #if defined(VERTEX)
5 | #if __VERSION__ >= 130
6 | #define COMPAT_VARYING out
7 | #define COMPAT_ATTRIBUTE in
8 | #define COMPAT_TEXTURE texture
9 | #else
10 | #define COMPAT_VARYING varying
11 | #define COMPAT_ATTRIBUTE attribute
12 | #define COMPAT_TEXTURE texture2D
13 | #endif
14 |
15 | #ifdef GL_ES
16 | #define COMPAT_PRECISION mediump
17 | #else
18 | #define COMPAT_PRECISION
19 | #endif
20 |
21 | COMPAT_ATTRIBUTE vec4 VertexCoord;
22 | COMPAT_ATTRIBUTE vec4 COLOR;
23 | COMPAT_ATTRIBUTE vec4 TexCoord;
24 | COMPAT_VARYING vec4 COL0;
25 | COMPAT_VARYING vec4 TEX0;
26 |
27 | vec4 _oPosition1;
28 | uniform mat4 MVPMatrix;
29 | uniform COMPAT_PRECISION int FrameDirection;
30 | uniform COMPAT_PRECISION int FrameCount;
31 | uniform COMPAT_PRECISION vec2 OutputSize;
32 | uniform COMPAT_PRECISION vec2 TextureSize;
33 | uniform COMPAT_PRECISION vec2 InputSize;
34 |
35 | #define vTexCoord TEX0.xy
36 | #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
37 | #define OutSize vec4(OutputSize, 1.0 / OutputSize)
38 |
39 | void main()
40 | {
41 | gl_Position = MVPMatrix * VertexCoord;
42 | TEX0.xy = TexCoord.xy;
43 | }
44 |
45 | #elif defined(FRAGMENT)
46 |
47 | #ifdef GL_ES
48 | #ifdef GL_FRAGMENT_PRECISION_HIGH
49 | precision highp float;
50 | #else
51 | precision mediump float;
52 | #endif
53 | #define COMPAT_PRECISION mediump
54 | #else
55 | #define COMPAT_PRECISION
56 | #endif
57 |
58 | #if __VERSION__ >= 130
59 | #define COMPAT_VARYING in
60 | #define COMPAT_TEXTURE texture
61 | out COMPAT_PRECISION vec4 FragColor;
62 | #else
63 | #define COMPAT_VARYING varying
64 | #define FragColor gl_FragColor
65 | #define COMPAT_TEXTURE texture2D
66 | #endif
67 |
68 | uniform COMPAT_PRECISION int FrameDirection;
69 | uniform COMPAT_PRECISION int FrameCount;
70 | uniform COMPAT_PRECISION vec2 OutputSize;
71 | uniform COMPAT_PRECISION vec2 TextureSize;
72 | uniform COMPAT_PRECISION vec2 InputSize;
73 | uniform sampler2D Texture;
74 | COMPAT_VARYING vec4 TEX0;
75 |
76 | // compatibility #defines
77 | #define Source Texture
78 | #define vTexCoord TEX0.xy
79 |
80 | #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
81 | #define OutSize vec4(OutputSize, 1.0 / OutputSize)
82 |
83 | #ifdef PARAMETER_UNIFORM
84 | uniform COMPAT_PRECISION float CURVATURE, SCANSPEED;
85 | #else
86 | #define CURVATURE 0.5
87 | #define SCANSPEED 1.0
88 | #endif
89 |
90 | #define iChannel0 Texture
91 | #define iTime (float(FrameCount) / 60.0)
92 | #define iResolution OutputSize.xy
93 | #define fragCoord gl_FragCoord.xy
94 |
95 | vec3 sample_( sampler2D tex, vec2 tc )
96 | {
97 | vec3 s = pow(COMPAT_TEXTURE(tex,tc).rgb, vec3(2.2));
98 | return s;
99 | }
100 |
101 | vec3 blur(sampler2D tex, vec2 tc, float offs)
102 | {
103 | vec4 xoffs = offs * vec4(-2.0, -1.0, 1.0, 2.0) / (iResolution.x * TextureSize.x / InputSize.x);
104 | vec4 yoffs = offs * vec4(-2.0, -1.0, 1.0, 2.0) / (iResolution.y * TextureSize.y / InputSize.y);
105 | tc = tc * InputSize / TextureSize;
106 |
107 | vec3 color = vec3(0.0, 0.0, 0.0);
108 | color += sample_(tex,tc + vec2(xoffs.x, yoffs.x)) * 0.00366;
109 | color += sample_(tex,tc + vec2(xoffs.y, yoffs.x)) * 0.01465;
110 | color += sample_(tex,tc + vec2( 0.0, yoffs.x)) * 0.02564;
111 | color += sample_(tex,tc + vec2(xoffs.z, yoffs.x)) * 0.01465;
112 | color += sample_(tex,tc + vec2(xoffs.w, yoffs.x)) * 0.00366;
113 |
114 | color += sample_(tex,tc + vec2(xoffs.x, yoffs.y)) * 0.01465;
115 | color += sample_(tex,tc + vec2(xoffs.y, yoffs.y)) * 0.05861;
116 | color += sample_(tex,tc + vec2( 0.0, yoffs.y)) * 0.09524;
117 | color += sample_(tex,tc + vec2(xoffs.z, yoffs.y)) * 0.05861;
118 | color += sample_(tex,tc + vec2(xoffs.w, yoffs.y)) * 0.01465;
119 |
120 | color += sample_(tex,tc + vec2(xoffs.x, 0.0)) * 0.02564;
121 | color += sample_(tex,tc + vec2(xoffs.y, 0.0)) * 0.09524;
122 | color += sample_(tex,tc + vec2( 0.0, 0.0)) * 0.15018;
123 | color += sample_(tex,tc + vec2(xoffs.z, 0.0)) * 0.09524;
124 | color += sample_(tex,tc + vec2(xoffs.w, 0.0)) * 0.02564;
125 |
126 | color += sample_(tex,tc + vec2(xoffs.x, yoffs.z)) * 0.01465;
127 | color += sample_(tex,tc + vec2(xoffs.y, yoffs.z)) * 0.05861;
128 | color += sample_(tex,tc + vec2( 0.0, yoffs.z)) * 0.09524;
129 | color += sample_(tex,tc + vec2(xoffs.z, yoffs.z)) * 0.05861;
130 | color += sample_(tex,tc + vec2(xoffs.w, yoffs.z)) * 0.01465;
131 |
132 | color += sample_(tex,tc + vec2(xoffs.x, yoffs.w)) * 0.00366;
133 | color += sample_(tex,tc + vec2(xoffs.y, yoffs.w)) * 0.01465;
134 | color += sample_(tex,tc + vec2( 0.0, yoffs.w)) * 0.02564;
135 | color += sample_(tex,tc + vec2(xoffs.z, yoffs.w)) * 0.01465;
136 | color += sample_(tex,tc + vec2(xoffs.w, yoffs.w)) * 0.00366;
137 |
138 | return color;
139 | }
140 |
141 | float rand(vec2 co)
142 | {
143 | float a = 12.9898;
144 | float b = 78.233;
145 | float c = 43758.5453;
146 | float dt= dot(co.xy ,vec2(a,b));
147 | float sn= mod(dt,3.14);
148 | return fract(sin(sn) * c);
149 | }
150 |
151 | vec2 curve(vec2 uv)
152 | {
153 | uv = (uv - 0.5) * 2.0;
154 | uv *= 1.1;
155 | uv.x *= 1.0 + pow((abs(uv.y) / 5.0), 2.0);
156 | uv.y *= 1.0 + pow((abs(uv.x) / 4.0), 2.0);
157 | uv = (uv / 2.0) + 0.5;
158 | uv = uv *0.92 + 0.04;
159 | return uv;
160 | }
161 |
162 | void main()
163 | {
164 | vec2 q = (vTexCoord.xy * TextureSize.xy / InputSize.xy);//fragCoord.xy / iResolution.xy;
165 | vec2 uv = q;
166 | uv = mix( uv, curve( uv ), CURVATURE ) * InputSize.xy / TextureSize.xy;
167 | vec3 col;
168 | float x = sin(0.1*iTime+uv.y*21.0)*sin(0.23*iTime+uv.y*29.0)*sin(0.3+0.11*iTime+uv.y*31.0)*0.0017;
169 | float o =2.0*mod(fragCoord.y,2.0)/iResolution.x;
170 | x+=o;
171 | uv = uv * TextureSize / InputSize;
172 | col.r = 1.0*blur(iChannel0,vec2(uv.x+0.0009,uv.y+0.0009),1.2).x+0.005;
173 | col.g = 1.0*blur(iChannel0,vec2(uv.x+0.000,uv.y-0.0015),1.2).y+0.005;
174 | col.b = 1.0*blur(iChannel0,vec2(uv.x-0.0015,uv.y+0.000),1.2).z+0.005;
175 | col.r += 0.2*blur(iChannel0,vec2(uv.x+0.0009,uv.y+0.0009),2.25).x-0.005;
176 | col.g += 0.2*blur(iChannel0,vec2(uv.x+0.000,uv.y-0.0015),1.75).y-0.005;
177 | col.b += 0.2*blur(iChannel0,vec2(uv.x-0.0015,uv.y+0.000),1.25).z-0.005;
178 | float ghs = 0.05;
179 | col.r += ghs*(1.0-0.299)*blur(iChannel0,0.75*vec2(0.01, -0.027)+vec2(uv.x+0.001,uv.y+0.001),7.0).x;
180 | col.g += ghs*(1.0-0.587)*blur(iChannel0,0.75*vec2(-0.022, -0.02)+vec2(uv.x+0.000,uv.y-0.002),5.0).y;
181 | col.b += ghs*(1.0-0.114)*blur(iChannel0,0.75*vec2(-0.02, -0.0)+vec2(uv.x-0.002,uv.y+0.000),3.0).z;
182 |
183 |
184 |
185 | col = clamp(col*0.4+0.6*col*col*1.0,0.0,1.0);
186 | float vig = (0.0 + 1.0*16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y));
187 | vig = pow(vig,0.3);
188 | col *= vec3(vig);
189 |
190 | col *= vec3(0.95,1.05,0.95);
191 | col = mix( col, col * col, 0.3) * 3.8;
192 |
193 | float scans = clamp( 0.35+0.15*sin(3.5*(iTime * SCANSPEED)+uv.y*iResolution.y*1.5), 0.0, 1.0);
194 |
195 | float s = pow(scans,0.9);
196 | col = col*vec3( s) ;
197 |
198 | col *= 1.0+0.0015*sin(300.0*iTime);
199 |
200 | col*=1.0-0.15*vec3(clamp((mod(fragCoord.x+o, 2.0)-1.0)*2.0,0.0,1.0));
201 | col *= vec3( 1.0 ) - 0.25*vec3( rand( uv+0.0001*iTime), rand( uv+0.0001*iTime + 0.3 ), rand( uv+0.0001*iTime+ 0.5 ) );
202 | col = pow(col, vec3(0.45));
203 |
204 | if (uv.x < 0.0 || uv.x > 1.0)
205 | col *= 0.0;
206 | if (uv.y < 0.0 || uv.y > 1.0)
207 | col *= 0.0;
208 |
209 |
210 | float comp = smoothstep( 0.1, 0.9, sin(iTime) );
211 |
212 | FragColor = vec4(col,1.0);
213 | }
214 | #endif
215 |
--------------------------------------------------------------------------------
/shaders/crt-mattias.glslp:
--------------------------------------------------------------------------------
1 |
2 | shaders = 1
3 | shader0 = crt-mattias.glsl
4 | filter_linear0 = false
5 |
--------------------------------------------------------------------------------
/shaders/sgenpt-mix.glsl:
--------------------------------------------------------------------------------
1 | /*
2 | SGENPT-MIX - Sega Genesis Pseudo Transparency Mixer Shader - v8b
3 |
4 | 2011-2020 Hyllian - sergiogdb@gmail.com
5 |
6 | Permission is hereby granted, free of charge, to any person obtaining a copy
7 | of this software and associated documentation files (the "Software"), to deal
8 | in the Software without restriction, including without limitation the rights
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 |
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 |
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 |
24 | */
25 |
26 | #pragma parameter SGPT_BLEND_OPTION "0.OFF | 1.VL | 2.CB | 3.CB-S | 4.Both | 5.Both2 | 6.Both-S" 4.0 0.0 6.0 1.0
27 | #pragma parameter SGPT_BLEND_LEVEL "SGENPT-MIX Both Blend Level" 1.0 0.0 1.0 0.1
28 | #pragma parameter SGPT_ADJUST_VIEW "SGENPT-MIX Adjust View" 0.0 0.0 1.0 1.0
29 | #pragma parameter SGPT_LINEAR_GAMMA "SGENPT-MIX Use Linear Gamma" 1.0 0.0 1.0 1.0
30 |
31 |
32 | #define texCoord TEX0
33 |
34 | #if defined(VERTEX)
35 |
36 | #if __VERSION__ >= 130
37 | #define OUT out
38 | #define IN in
39 | #define tex2D texture
40 | #else
41 | #define OUT varying
42 | #define IN attribute
43 | #define tex2D texture2D
44 | #endif
45 |
46 | #ifdef GL_ES
47 | #define COMPAT_PRECISION mediump
48 | #else
49 | #define COMPAT_PRECISION
50 | #endif
51 |
52 |
53 | IN vec4 VertexCoord;
54 | IN vec4 Color;
55 | IN vec2 TexCoord;
56 | OUT vec4 color;
57 | OUT vec2 texCoord;
58 |
59 | uniform mat4 MVPMatrix;
60 | uniform COMPAT_PRECISION int FrameDirection;
61 | uniform COMPAT_PRECISION int FrameCount;
62 | uniform COMPAT_PRECISION vec2 OutputSize;
63 | uniform COMPAT_PRECISION vec2 TextureSize;
64 | uniform COMPAT_PRECISION vec2 InputSize;
65 |
66 | void main()
67 | {
68 | gl_Position = MVPMatrix * VertexCoord;
69 | color = Color;
70 | texCoord = TexCoord;
71 | }
72 |
73 | #elif defined(FRAGMENT)
74 |
75 | #if __VERSION__ >= 130
76 | #define IN in
77 | #define tex2D texture
78 | out vec4 FragColor;
79 | #else
80 | #define IN varying
81 | #define FragColor gl_FragColor
82 | #define tex2D texture2D
83 | #endif
84 |
85 | #ifdef GL_ES
86 | #ifdef GL_FRAGMENT_PRECISION_HIGH
87 | precision highp float;
88 | #else
89 | precision mediump float;
90 | #endif
91 | #define COMPAT_PRECISION mediump
92 | #else
93 | #define COMPAT_PRECISION
94 | #endif
95 |
96 | uniform COMPAT_PRECISION int FrameDirection;
97 | uniform COMPAT_PRECISION int FrameCount;
98 | uniform COMPAT_PRECISION vec2 OutputSize;
99 | uniform COMPAT_PRECISION vec2 TextureSize;
100 | uniform COMPAT_PRECISION vec2 InputSize;
101 | uniform sampler2D s_p;
102 | IN vec2 texCoord;
103 |
104 | #ifdef PARAMETER_UNIFORM
105 | uniform COMPAT_PRECISION float SGPT_BLEND_OPTION;
106 | uniform COMPAT_PRECISION float SGPT_BLEND_LEVEL;
107 | uniform COMPAT_PRECISION float SGPT_ADJUST_VIEW;
108 | uniform COMPAT_PRECISION float SGPT_LINEAR_GAMMA;
109 | #else
110 | #define SGPT_BLEND_OPTION 4.0
111 | #define SGPT_BLEND_LEVEL 1.0
112 | #define SGPT_ADJUST_VIEW 0.0
113 | #define SGPT_LINEAR_GAMMA 1.0
114 | #endif
115 |
116 |
117 | #define GAMMA_EXP (SGPT_LINEAR_GAMMA+1.0)
118 | #define GAMMA_IN(color) pow(color, vec3(GAMMA_EXP, GAMMA_EXP, GAMMA_EXP))
119 | #define GAMMA_OUT(color) pow(color, vec3(1.0 / GAMMA_EXP, 1.0 / GAMMA_EXP, 1.0 / GAMMA_EXP))
120 |
121 |
122 | const vec3 Y = vec3(.2126, .7152, .0722);
123 |
124 | vec3 min_s(vec3 central, vec3 adj1, vec3 adj2) {return min(central, max(adj1, adj2));}
125 | vec3 max_s(vec3 central, vec3 adj1, vec3 adj2) {return max(central, min(adj1, adj2));}
126 |
127 |
128 | void main()
129 | {
130 | vec2 dx = vec2(1.0, 0.0)/TextureSize;
131 | vec2 dy = vec2(0.0, 1.0)/TextureSize;
132 |
133 | // Reading the texels.
134 | vec3 C = GAMMA_IN(tex2D(s_p, texCoord ).xyz);
135 | vec3 L = GAMMA_IN(tex2D(s_p, texCoord -dx).xyz);
136 | vec3 R = GAMMA_IN(tex2D(s_p, texCoord +dx).xyz);
137 | vec3 U = GAMMA_IN(tex2D(s_p, texCoord -dy).xyz);
138 | vec3 D = GAMMA_IN(tex2D(s_p, texCoord +dy).xyz);
139 | vec3 UL = GAMMA_IN(tex2D(s_p, texCoord -dx -dy).xyz);
140 | vec3 UR = GAMMA_IN(tex2D(s_p, texCoord +dx -dy).xyz);
141 | vec3 DL = GAMMA_IN(tex2D(s_p, texCoord -dx +dy).xyz);
142 | vec3 DR = GAMMA_IN(tex2D(s_p, texCoord +dx +dy).xyz);
143 |
144 | vec3 color = C;
145 |
146 | // Get min/max samples
147 | vec3 min_sample = min_s(C, L, R);
148 | vec3 max_sample = max_s(C, L, R);
149 |
150 | float diff = dot(max(max(C, L), max(C, R)) - min(min(C, L), min(C, R)), Y);
151 |
152 | if (int(SGPT_BLEND_OPTION) == 1) // Only Vertical Lines
153 | {
154 | min_sample = max_s(min_sample, min_s(C, DL, DR), min_s(C, UL, UR));
155 | max_sample = min_s(max_sample, max_s(C, DL, DR), max_s(C, UL, UR));
156 |
157 | diff *= (1.0 - SGPT_BLEND_LEVEL);
158 |
159 | color = 0.5*( 1.0 + diff )*C + 0.25*( 1.0 - diff )*(L + R);
160 | }
161 | else if (int(SGPT_BLEND_OPTION) == 2) // Only Checkerboard
162 | {
163 | min_sample = max(min_sample, min_s(C, U, D));
164 | max_sample = min(max_sample, max_s(C, U, D));
165 |
166 | diff *= (1.0 - SGPT_BLEND_LEVEL);
167 |
168 | color = 0.5*( 1.0 + diff )*C + 0.125*( 1.0 - diff )*(L + R + U + D);
169 | }
170 | else if (int(SGPT_BLEND_OPTION) == 3) // Only Checkerboard - Soft
171 | {
172 | min_sample = min_s(min_sample, U, D);
173 | max_sample = max_s(max_sample, U, D);
174 |
175 | diff *= (1.0 - SGPT_BLEND_LEVEL);
176 |
177 | color = 0.5*( 1.0 + diff )*C + 0.125*( 1.0 - diff )*(L + R + U + D);
178 | }
179 | else if (int(SGPT_BLEND_OPTION) == 4) // VL-CB
180 | {
181 | diff *= (1.0 - SGPT_BLEND_LEVEL);
182 |
183 | color = 0.5*( 1.0 + diff )*C + 0.25*( 1.0 - diff )*(L + R);
184 | }
185 | else if (int(SGPT_BLEND_OPTION) == 5) // VL-CB-2
186 | {
187 | min_sample = min_s(min_sample, U, D);
188 | max_sample = max_s(max_sample, U, D);
189 |
190 | diff *= (1.0 - SGPT_BLEND_LEVEL);
191 |
192 | color = 0.5*( 1.0 + diff )*C + 0.25*( 1.0 - diff )*(L + R);
193 | }
194 | else if (int(SGPT_BLEND_OPTION) == 6) // VL-CB-Soft
195 | {
196 | min_sample = min(min_sample, min(min_s(D, DL, DR), min_s(U, UL, UR)));
197 | max_sample = max(max_sample, max(max_s(D, DL, DR), max_s(U, UL, UR)));
198 |
199 | diff *= (1.0 - SGPT_BLEND_LEVEL);
200 |
201 | color = 0.5*( 1.0 + diff )*C + 0.25*( 1.0 - diff )*(L + R);
202 | }
203 |
204 | color = clamp(color, min_sample, max_sample);
205 |
206 | color = mix(color, vec3(dot(abs(C-color), vec3(1.0, 1.0, 1.0))), SGPT_ADJUST_VIEW);
207 |
208 | FragColor.xyz = GAMMA_OUT(color);
209 | }
210 | #endif
211 |
--------------------------------------------------------------------------------
/shaders/sgenpt-mix.glslp:
--------------------------------------------------------------------------------
1 | shaders = 1
2 |
3 | shader0 = sgenpt-mix.glsl
4 | filter_linear0 = false
5 | scale_type0 = source
6 | wrap_mode0 = "clamp_to_border"
7 | scale0 = 1.0
8 |
--------------------------------------------------------------------------------