enable timeapi in winapi crate

Cargo.toml

@@ -11,19 +11,21 @@ native = ["wasmtime", "uw8-window", "cpal", "rubato" ]
 browser = ["warp", "tokio", "tokio-stream", "webbrowser"]
 
 [dependencies]
-wasmtime = { version = "0.37.0", optional = true }
+wasmtime = { version = "5.0.0", optional = true }
 anyhow = "1"
+env_logger = "0.10"
+log = "0.4"
 uw8-window = { path = "uw8-window", optional = true }
-notify = "4"
-pico-args = "0.4"
+notify = "5"
+pico-args = "0.5"
 curlywas = { git = "https://github.com/exoticorn/curlywas.git", rev = "0e7ea50" }
 wat = "1"
 uw8-tool = { path = "uw8-tool" }
 same-file = "1"
-warp = { version = "0.3.2", optional = true }
-tokio = { version = "1.17.0", features = ["sync", "rt"], optional = true }
-tokio-stream = { version = "0.1.8", features = ["sync"], optional = true }
-webbrowser = { version = "0.6.0", optional = true }
+warp = { version = "0.3.3", optional = true }
+tokio = { version = "1.24.0", features = ["sync", "rt"], optional = true }
+tokio-stream = { version = "0.1.11", features = ["sync"], optional = true }
+webbrowser = { version = "0.8.6", optional = true }
 ansi_term = "0.12.1"
-cpal = { version = "0.13.5", optional = true }
-rubato = { version = "0.11.0", optional = true }
+cpal = { version = "0.14.2", optional = true }
+rubato = { version = "0.12.0", optional = true }

README.md

@@ -43,6 +43,27 @@ Options:
 -l LEVEL, --level LEVEL : Compression level (0-9). Higher compression levels are really slow.
 -o FILE, --output FILE  : Write the loaded and optionally packed cart back to disk.
 
+when using the native runtime:
+
+-m, --no-audio          : Disable audio, also reduces cpu load a bit
+--no-gpu                : Force old cpu-only window code
+--filter FILTER         : Select an upscale filter at startup
+--fullscreen            : Start in fullscreen mode
+
+Note that the cpu-only window does not support fullscreen nor upscale filters.
+
+Unless --no-gpu is given, uw8 will first try to open a gpu accelerated window, falling back to the old cpu-only window if that fails.
+Therefore you should rarely need to manually pass --no-gpu. If you prefer the old pixel doubling look to the now default crt filter,
+you can just pass "--filter nearest" or "--filter 1".
+
+The upscale filter options are:
+1, nearest              : Anti-aliased nearest filter
+2, fast_crt             : Very simple, cheap crt filter, not very good below a window size of 960x720
+3, ss_crt               : Super sampled crt filter, a little more demanding on the GPU but scales well to smaller window sizes
+4, chromatic_crt        : Variant of fast_crt with a slight offset of the three color dots of a pixel, still pretty cheap
+5, auto_crt (default)   : ss_crt below 960x720, chromatic_crt otherwise
+
+You can switch the upscale filter at any time using the keys 1-5. You can toggle fullscreen with F.
 
 uw8 pack [<options>] <infile> <outfile>
 

examples/include/microw8-api.cwa

@@ -34,6 +34,7 @@ import "env.rectangle_outline" fn rectangle_outline(f32, f32, f32, f32, i32);
 import "env.circle_outline" fn circle_outline(f32, f32, f32, i32);
 import "env.exp" fn exp(f32) -> f32;
 import "env.playNote" fn playNote(i32, i32);
+import "env.sndGes" fn sndGes(i32) -> f32;
 
 const TIME_MS = 0x40;
 const GAMEPAD = 0x44;

examples/include/microw8-api.wat

@@ -34,6 +34,7 @@
 (import "env" "circle_outline" (func $circle_outline (param f32) (param f32) (param f32) (param i32)))
 (import "env" "exp" (func $exp (param f32) (result f32)))
 (import "env" "playNote" (func $playNote (param i32) (param i32)))
+(import "env" "sndGes" (func $sndGes (param i32) (result f32)))
 
 ;; to use defines, include this file with a preprocessor
 ;; like gpp (https://logological.org/gpp).

platform/Cargo.lock

@@ -391,7 +391,7 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
 [[package]]
 name = "upkr"
 version = "0.1.0"
-source = "git+https://github.com/exoticorn/upkr.git?rev=2e7983fc#2e7983fc650788d98da2eecef2d16f63e849e4a0"
+source = "git+https://github.com/exoticorn/upkr.git?rev=d93aec186c9fb91d962c488682a2db125c61306c#d93aec186c9fb91d962c488682a2db125c61306c"
 dependencies = [
  "anyhow",
  "cdivsufsort",

platform/src/ges.cwa

@@ -10,7 +10,7 @@ const GesState.Size = GesState.Filter + 8*4;
 const GesStateOffset = 32;
 const GesBufferOffset = 32 + GesState.Size;
 
-export fn gesSnd(t: i32) -> f32 {
+export fn sndGes(t: i32) -> f32 {
     let baseAddr = 0!0x12c78;
     if !(t & 127) {
         let i: i32;

site/content/_index.md

@@ -29,6 +29,19 @@ Examplers for older versions:
 
 ## Versions
 
+### v0.2.1
+
+* [Web runtime](v0.2.1)
+* [Linux](https://github.com/exoticorn/microw8/releases/download/v0.2.1/microw8-0.2.1-linux.tgz)
+* [MacOS](https://github.com/exoticorn/microw8/releases/download/v0.2.1/microw8-0.2.1-macos.tgz)
+* [Windows](https://github.com/exoticorn/microw8/releases/download/v0.2.1/microw8-0.2.1-windows.zip)
+
+Changes:
+
+* new gpu accelerated renderer with (optional) crt filter
+* optimized `hline` function, a big speed-up when drawing large filled circles or rectangles
+* print fractional size of packed `uw8` cart
+
 ### v0.2.0
 
 * [Web runtime](v0.2.0)

site/content/docs.md

@@ -436,6 +436,30 @@ and execution of the cart is stopped. Defaults to 30 (0.5s)
 * `-l LEVEL`, `--level LEVEL`: Compression level (0-9). Higher compression levels are really slow.
 * `-o FILE`, `--output FILE`: Write the loaded and optionally packed cart back to disk.
 
+when using the native runtime:
+
+* `-m`, `--no-audio`: Disable audio, also reduces cpu load a bit
+* `--no-gpu`:  Force old cpu-only window code
+* `--filter FILTER`:  Select an upscale filter at startup
+* `--fullscreen`:  Start in fullscreen mode
+
+Note that the cpu-only window does not support fullscreen nor upscale filters.
+
+Unless --no-gpu is given, uw8 will first try to open a gpu accelerated window, falling back to the old cpu-only window if that fails.
+Therefore you should rarely need to manually pass --no-gpu. If you prefer the old pixel doubling look to the now default crt filter,
+you can just pass `--filter nearest` or `--filter 1`.
+
+The upscale filter options are:
+```
+1, nearest              : Anti-aliased nearest filter
+2, fast_crt             : Very simple, cheap crt filter, not very good below a window size of 960x720
+3, ss_crt               : Super sampled crt filter, a little more demanding on the GPU but scales well to smaller window sizes
+4, chromatic_crt        : Variant of fast_crt with a slight offset of the three color dots of a pixel, still pretty cheap
+5, auto_crt (default)   : ss_crt below 960x720, chromatic_crt otherwise
+```
+
+You can switch the upscale filter at any time using the keys 1-5. You can toggle fullscreen with F.
+
 ## `uw8 pack`
 
 Usage:

site/static/v0.2.1/index.html

@@ -0,0 +1 @@
+<!doctype html><html><head><meta charset="utf8"><title>MicroW8</title><link href="https://fonts.googleapis.com/css2?family=Josefin+Sans:wght@500&display=swap" rel="stylesheet"><style>html,body,canvas{margin:0;padding:0}html{color:#808070;height:100%;background-color:#202024;font-family:Josefin Sans,Verdana,Arial Black,sans-serif}body{height:100%;grid-template-rows:1fr 0fr;display:grid}#uw8{position:absolute}#uw8 a{font-size:130%}#centered{place-self:center}a{color:#303630}a:hover{color:#405040}.screen{width:320px;height:240px;image-rendering:pixelated;background-color:#202428;border:4px solid #303040;margin-bottom:8px;box-shadow:5px 5px 20px #000}#screen{cursor:none}#start{font-size:150%}#timer:before{content:"";width:12px;height:12px;background-color:red;border-radius:6px;margin-right:3px;display:inline-block}#message{margin-bottom:8px}.error{color:#e04030}button{color:#808070;background-color:#303440;border:1px solid #404040;border-radius:4px;padding:4px;font-family:inherit}button:hover{background-color:#202010}button:active{background-color:#504450}@media (min-width:680px) and (min-height:620px){.screen{width:640px;height:480px}}@media (min-width:1000px) and (min-height:800px){.screen{width:960px;height:720px}}@media (width:640px) and (height:480px){.screen{width:640px;height:480px;border:0;margin:0}body{overflow:hidden}}</style></head><body> <div id="uw8"> <a href="https://exoticorn.github.io/microw8">MicroW8</a> 0.2.1 </div> <div id="centered"> <canvas class="screen" id="screen" width="320" height="240"> </canvas> <button class="screen" id="start" style="display:none">Click to start</button> <div id="timer" hidden></div> <div id="message"></div> <button id="cartButton" style="visibility:hidden">Load cart...</button> </div> <div id="footer"> <a href="http://unlicense.org/" ref="license">Unlicense</a> </div> </body><script type="module">function e(e){return e&&e.__esModule?e.default:e}class t extends AudioWorkletNode{constructor(e){super(e,"apu",{outputChannelCount:[2]})}}let a=(...e)=>new Uint8Array(...e),n=(...e)=>new Uint32Array(...e);let s=function(s,A={}){A.setMessage||(A.setMessage=(e,t)=>{t&&console.log("error: "+t)});let r,B,o,i,l,d,F,u,g=s.getContext("2d"),c=g.createImageData(320,240),D=A.devkitMode,C=0,f=null==A.keyboardElement?s:A.keyboardElement;if(f){let e=e=>{let t,a="keydown"==e.type;switch(e.code){case"ArrowUp":t=1;break;case"ArrowDown":t=2;break;case"ArrowLeft":t=4;break;case"ArrowRight":t=8;break;case"KeyZ":t=16;break;case"KeyX":t=32;break;case"KeyA":t=64;break;case"KeyS":t=128;break;case"KeyR":a&&w(B,!0);break;case"F9":a&&s.toBlob((e=>{h(e,".png")})),e.preventDefault();break;case"F10":a&&function(){if(l)return l.stop(),l=null,F.disconnect(u),F=null,void(u=null);let e=s.captureStream();u=o.createMediaStreamDestination(),F=i,i.connect(u),e.addTrack(u.stream.getAudioTracks()[0]),l=new MediaRecorder(e,{mimeType:"video/webm",videoBitsPerSecond:25e6});let t=[];l.ondataavailable=e=>{t.push(e.data)};let a=A.timerElement;a&&(a.hidden=!1,a.innerText="00:00");function n(){if(d){if(a){let e=Math.floor((Date.now()-d)/1e3);a.innerText=Math.floor(e/60).toString().padStart(2,"0")+":"+(e%60).toString().padStart(2,"0")}setTimeout(n,1e3)}}l.onstop=()=>{a&&(a.hidden=!0),h(new Blob(t,{type:"video/webm"}),".webm")},l.start(),d=Date.now(),setTimeout(n,1e3)}(),e.preventDefault()}a?C|=t:C&=~t};f.onkeydown=e,f.onkeyup=e}async function w(l,d){r&&(r(),r=null),o=new AudioContext({sampleRate:44100});let F=!0,u=new AbortController;r=()=>{o.close(),F=!1,u.abort()};let f=l.byteLength;if(A.setMessage(f),0==f)return;await o.audioWorklet.addModule(e("data:application/javascript,let%20e%3D%28...e%29%3D%3Enew%20Uint8Array%28...e%29%3Bclass%20s%20extends%20AudioWorkletProcessor%7Bconstructor%28%29%7Bsuper%28%29%2Cthis.sampleIndex%3D0%2Cthis.currentTime%3D0%2Cthis.isFirstMessage%3D%210%2Cthis.pendingUpdates%3D%5B%5D%2Cthis.port.onmessage%3De%3D%3E%7Bthis.memory%3F%28this.isFirstMessage%26%26%28this.currentTime%2B%3D%28e.data.t-this.currentTime%29%2F8%2Cthis.isFirstMessage%3D%211%29%2Cthis.pendingUpdates.push%28e.data%29%29%3Athis.load%28e.data%5B0%5D%2Ce.data%5B1%5D%29%7D%7Dasync%20load%28e%2Cs%29%7Blet%20t%3Dnew%20WebAssembly.Memory%28%7Binitial%3A4%2Cmaximum%3A4%7D%29%2Ci%3D%7Benv%3A%7Bmemory%3At%7D%7D%3Bfor%28let%20e%20of%5B%22acos%22%2C%22asin%22%2C%22atan%22%2C%22atan2%22%2C%22cos%22%2C%22exp%22%2C%22log%22%2C%22sin%22%2C%22tan%22%2C%22pow%22%5D%29i.env%5Be%5D%3DMath%5Be%5D%3Bfor%28let%20e%3D9%3Be%3C64%3B%2B%2Be%29i.env%5B%22reserved%22%2Be%5D%3D%28%29%3D%3E%7B%7D%3Blet%20r%3D%22%22%3Bi.env.logChar%3De%3D%3E%7B10%3D%3De%3F%28console.log%28r%29%2Cr%3D%22%22%29%3Ar%2B%3DString.fromCharCode%28e%29%7D%3Bfor%28let%20e%3D0%3Be%3C16%3B%2B%2Be%29i.env%5B%22g_reserved%22%2Be%5D%3D0%3Blet%20n%3Dasync%20e%3D%3E%28await%20WebAssembly.instantiate%28e%2Ci%29%29.instance%2Ca%3Dawait%20n%28e%29%3Bfor%28let%20e%20in%20a.exports%29i.env%5Be%5D%3Da.exports%5Be%5D%3Blet%20o%3Dawait%20n%28s%29%3Bthis.memory%3Dt%2Cthis.snd%3Do.exports.snd%7Line truncated

site/templates/index.html

@@ -4,7 +4,7 @@
         <section>
             <h1 class="text-center heading-text">A WebAssembly based fantasy console</h1>
         </section>
-        <a href="v0.2.0">
+        <a href="v0.2.1">
             <img class="demonstration-gif" style="width:640px;height:480px;image-rendering:pixelated" src="img/technotunnel.png"></img>
         </a>
     </div>

src/filewatcher.rs

@@ -1,18 +1,21 @@
 use anyhow::{anyhow, bail, Result};
-use notify::{DebouncedEvent, RecommendedWatcher, Watcher};
-use std::{collections::BTreeSet, path::PathBuf, sync::mpsc, time::Duration};
+use notify::{Event, EventKind, RecommendedWatcher, Watcher};
+use std::{collections::BTreeSet, path::PathBuf, sync::mpsc};
 
 pub struct FileWatcher {
     watcher: RecommendedWatcher,
     watched_files: BTreeSet<PathBuf>,
     directories: BTreeSet<PathBuf>,
-    rx: mpsc::Receiver<DebouncedEvent>,
+    rx: mpsc::Receiver<Event>,
 }
 
 impl FileWatcher {
     pub fn new() -> Result<FileWatcher> {
         let (tx, rx) = mpsc::channel();
-        let watcher = notify::watcher(tx, Duration::from_millis(100))?;
+        let watcher = notify::recommended_watcher(move |res| match res {
+            Ok(event) => _ = tx.send(event),
+            Err(err) => eprintln!("Error watching for file changes: {err}"),
+        })?;
         Ok(FileWatcher {
             watcher,
             watched_files: BTreeSet::new(),
@@ -36,16 +39,20 @@ impl FileWatcher {
     }
 
     pub fn poll_changed_file(&self) -> Result<Option<PathBuf>> {
-        let event = self.rx.try_recv();
-        match event {
-            Ok(DebouncedEvent::Create(path) | DebouncedEvent::Write(path)) => {
-                let handle = same_file::Handle::from_path(&path)?;
-                for file in &self.watched_files {
-                    if handle == same_file::Handle::from_path(file)? {
-                        return Ok(Some(path));
+        match self.rx.try_recv() {
+            Ok(event) => match event.kind {
+                EventKind::Create(_) | EventKind::Modify(_) => {
+                    for path in event.paths {
+                        let handle = same_file::Handle::from_path(&path)?;
+                        for file in &self.watched_files {
+                            if handle == same_file::Handle::from_path(file)? {
+                                return Ok(Some(path));
+                            }
+                        }
                     }
                 }
-            }
+                _ => (),
+            },
             Err(mpsc::TryRecvError::Disconnected) => bail!("File watcher disconnected"),
             _ => (),
         }

src/main.rs

@@ -13,6 +13,7 @@ use uw8::RunWebServer;
 use uw8::Runtime;
 
 fn main() -> Result<()> {
+    env_logger::Builder::from_env(env_logger::Env::default()).init();
     let mut args = Arguments::from_env();
 
     // try to enable ansi support in win10 cmd shell
@@ -35,7 +36,7 @@ fn main() -> Result<()> {
             println!();
             println!("Usage:");
             #[cfg(any(feature = "native", feature = "browser"))]
-            println!("  uw8 run [-t/--timeout <frames>] [--no-gpu] [--b/--browser] [-w/--watch] [-p/--pack] [-u/--uncompressed] [-l/--level] [-o/--output <out-file>] <file>");
+            println!("  uw8 run [-t/--timeout <frames>] [--b/--browser] [-w/--watch] [-p/--pack] [-u/--uncompressed] [-l/--level] [-o/--output <out-file>] <file>");
             println!("  uw8 pack [-u/--uncompressed] [-l/--level] <in-file> <out-file>");
             println!("  uw8 unpack <in-file> <out-file>");
             println!("  uw8 compile [-d/--debug] <in-file> <out-file>");
@@ -54,8 +55,6 @@ fn run(mut args: Arguments) -> Result<()> {
     let watch_mode = args.contains(["-w", "--watch"]);
     #[allow(unused)]
     let timeout: Option<u32> = args.opt_value_from_str(["-t", "--timeout"])?;
-    #[allow(unused)]
-    let gpu = !args.contains("--no-gpu");
 
     let mut config = Config::default();
     if args.contains(["-p", "--pack"]) {
@@ -82,7 +81,17 @@ fn run(mut args: Arguments) -> Result<()> {
     #[cfg(not(feature = "native"))]
     let run_browser = args.contains(["-b", "--browser"]) || true;
 
-    let disable_audio = args.contains(["-m", "--disable-audio"]);
+    #[allow(unused)]
+    let disable_audio = args.contains(["-m", "--no-audio"]);
+
+    #[cfg(feature = "native")]
+    let window_config = {
+        let mut config = uw8_window::WindowConfig::default();
+        if !run_browser {
+            config.parse_arguments(&mut args);
+        }
+        config
+    };
 
     let filename = args.free_from_os_str::<PathBuf, bool>(|s| Ok(s.into()))?;
 
@@ -95,7 +104,7 @@ fn run(mut args: Arguments) -> Result<()> {
         unimplemented!();
         #[cfg(feature = "native")]
         {
-            let mut microw8 = MicroW8::new(timeout, gpu)?;
+            let mut microw8 = MicroW8::new(timeout, window_config)?;
             if disable_audio {
                 microw8.disable_audio();
             }
@@ -167,7 +176,8 @@ fn load_cart(filename: &Path, config: &Config) -> (Result<Vec<u8>>, Vec<PathBuf>
         if let Some(ref pack_config) = config.pack {
             cart = uw8_tool::pack(&cart, pack_config)?;
             println!(
-                "\npacked size: {:.2} bytes",
+                "\npacked size: {} bytes ({:.2})",
+                cart.len(),
                 uw8_tool::compressed_size(&cart)
             );
         }

src/run-web.html

@@ -1 +1 @@
-<!doctype html><html><head><meta charset="utf8"><title>uw8-run</title><style>html,body,canvas{background-color:#202024;margin:0;padding:0}html{height:100%}body{height:100%;grid-template-rows:1fr;display:grid}#screen{image-rendering:pixelated;border:4px solid #303040;place-self:center}#message{width:calc(100% - 16px);color:#c64;z-index:2;background-color:#0006;padding:8px;font:700 12pt sans-serif;position:absolute}@media (min-width:648px) and (min-height:488px){#screen{width:640px;height:480px}}@media (min-width:968px) and (min-height:728px){#screen{width:960px;height:720px}}</style></head><body> <canvas id="screen" width="320" height="240" tabindex="1"> </canvas> <div id="message"></div> </body><script type="module">function e(e){return e&&e.__esModule?e.default:e}class t extends AudioWorkletNode{constructor(e){super(e,"apu",{outputChannelCount:[2]})}}let A=(...e)=>new Uint8Array(...e),a=(...e)=>new Uint32Array(...e);let s=function(s,B={}){B.setMessage||(B.setMessage=(e,t)=>{t&&console.log("error: "+t)});let n,r,o,i,l,F,d,g,C=s.getContext("2d"),u=C.createImageData(320,240),D=B.devkitMode,c=0,f=null==B.keyboardElement?s:B.keyboardElement;if(f){let e=e=>{let t,A="keydown"==e.type;switch(e.code){case"ArrowUp":t=1;break;case"ArrowDown":t=2;break;case"ArrowLeft":t=4;break;case"ArrowRight":t=8;break;case"KeyZ":t=16;break;case"KeyX":t=32;break;case"KeyA":t=64;break;case"KeyS":t=128;break;case"KeyR":A&&w(r,!0);break;case"F9":A&&s.toBlob((e=>{I(e,".png")})),e.preventDefault();break;case"F10":A&&function(){if(l)return l.stop(),l=null,d.disconnect(g),d=null,void(g=null);let e=s.captureStream();g=o.createMediaStreamDestination(),d=i,i.connect(g),e.addTrack(g.stream.getAudioTracks()[0]),l=new MediaRecorder(e,{mimeType:"video/webm",videoBitsPerSecond:25e6});let t=[];l.ondataavailable=e=>{t.push(e.data)};let A=B.timerElement;A&&(A.hidden=!1,A.innerText="00:00");function a(){if(F){if(A){let e=Math.floor((Date.now()-F)/1e3);A.innerText=Math.floor(e/60).toString().padStart(2,"0")+":"+(e%60).toString().padStart(2,"0")}setTimeout(a,1e3)}}l.onstop=()=>{A&&(A.hidden=!0),I(new Blob(t,{type:"video/webm"}),".webm")},l.start(),F=Date.now(),setTimeout(a,1e3)}(),e.preventDefault()}A?c|=t:c&=~t};f.onkeydown=e,f.onkeyup=e}async function w(l,F){n&&(n(),n=null),o=new AudioContext({sampleRate:44100});let d=!0,g=new AbortController;n=()=>{o.close(),d=!1,g.abort()};let f=l.byteLength;if(B.setMessage(f),0==f)return;await o.audioWorklet.addModule(e("data:application/javascript,let%20e%3D%28...e%29%3D%3Enew%20Uint8Array%28...e%29%3Bclass%20s%20extends%20AudioWorkletProcessor%7Bconstructor%28%29%7Bsuper%28%29%2Cthis.sampleIndex%3D0%2Cthis.currentTime%3D0%2Cthis.isFirstMessage%3D%210%2Cthis.pendingUpdates%3D%5B%5D%2Cthis.port.onmessage%3De%3D%3E%7Bthis.memory%3F%28this.isFirstMessage%26%26%28this.currentTime%2B%3D%28e.data.t-this.currentTime%29%2F8%2Cthis.isFirstMessage%3D%211%29%2Cthis.pendingUpdates.push%28e.data%29%29%3Athis.load%28e.data%5B0%5D%2Ce.data%5B1%5D%29%7D%7Dasync%20load%28e%2Cs%29%7Blet%20t%3Dnew%20WebAssembly.Memory%28%7Binitial%3A4%2Cmaximum%3A4%7D%29%2Ci%3D%7Benv%3A%7Bmemory%3At%7D%7D%3Bfor%28let%20e%20of%5B%22acos%22%2C%22asin%22%2C%22atan%22%2C%22atan2%22%2C%22cos%22%2C%22exp%22%2C%22log%22%2C%22sin%22%2C%22tan%22%2C%22pow%22%5D%29i.env%5Be%5D%3DMath%5Be%5D%3Bfor%28let%20e%3D9%3Be%3C64%3B%2B%2Be%29i.env%5B%22reserved%22%2Be%5D%3D%28%29%3D%3E%7B%7D%3Blet%20r%3D%22%22%3Bi.env.logChar%3De%3D%3E%7B10%3D%3De%3F%28console.log%28r%29%2Cr%3D%22%22%29%3Ar%2B%3DString.fromCharCode%28e%29%7D%3Bfor%28let%20e%3D0%3Be%3C16%3B%2B%2Be%29i.env%5B%22g_reserved%22%2Be%5D%3D0%3Blet%20n%3Dasync%20e%3D%3E%28await%20WebAssembly.instantiate%28e%2Ci%29%29.instance%2Ca%3Dawait%20n%28e%29%3Bfor%28let%20e%20in%20a.exports%29i.env%5Be%5D%3Da.exports%5Be%5D%3Blet%20o%3Dawait%20n%28s%29%3Bthis.memory%3Dt%2Cthis.snd%3Do.exports.snd%7C%7Ca.exports.gesSnd%2Cthis.port.postMessage%282%29%7Dprocess%28s%2Ct%2Ci%29%7Bif%28this.isFirstMessage%3D%210%2Cthis.snd%29%7Bfor%28%3Bthis.pendingUpdates.length%3E0%26%26this.pendingUpdates%5B0%5D.t%3C%3Dthis.currentTime%3B%29e%28this.memory.buffer%2C80%2C32%29.set%28e%28this.pendingUpdates.shift%28%29.r%29%29%3Bnew%20Uint32Array%28this.memory.buffer%29%5B16%5D%3Dthis.currentTime%3Blet%20s%3Dt%5B0%5D%2Ci%3Dthis.sampleIndex%2Cr%3Ds%5B0%5D.length%3Bfor%28let%20e%3D0%3Be%3Cr%3B%2B%2Be%29s%5B0%5D%5Be%5D%3Dthis.snd%28i%2B%2B%29%2Cs%5B1%5D%5Be%5D%3Dthis.snd%28i%2B%2B%29%3Bthis.sampleIndex%3D4294967295%26i%2Cthis.currentTime%2B%3Dr%2F44.1%7Dreturn%210%7D%7DregisterProcessor%28%22apu%22%2Cs%29%3B")),i=new t(o);let I,h=0,Q=new Promise((e=>I=e)),m=e=>{h|=e,3==h&&I&&(I(!0),I=null)},M=()=>{"suspended"==o.state?(B.startButton&&(B.startButton.style="",s.style="display:none"),(B.startButton||s).onclick=()=>{o.resume()}):(B.startButton&&(B.startButton.style="display:none",s.style=""),m(1))};o.onstatechange=M,M(),r=l;let E=window.location.pathname;if(f<=1024&&!F){let e="";for(let t of A(l))e+=String.fromCharCode(t);E+="#"+btoa(e),E!=window.locLine truncated
+<!doctype html><html><head><meta charset="utf8"><title>uw8-run</title><style>html,body,canvas{background-color:#202024;margin:0;padding:0}html{height:100%}body{height:100%;grid-template-rows:1fr;display:grid}#screen{image-rendering:pixelated;border:4px solid #303040;place-self:center}#message{width:calc(100% - 16px);color:#c64;z-index:2;background-color:#0006;padding:8px;font:700 12pt sans-serif;position:absolute}@media (min-width:648px) and (min-height:488px){#screen{width:640px;height:480px}}@media (min-width:968px) and (min-height:728px){#screen{width:960px;height:720px}}</style></head><body> <canvas id="screen" width="320" height="240" tabindex="1"> </canvas> <div id="message"></div> </body><script type="module">function e(e){return e&&e.__esModule?e.default:e}class t extends AudioWorkletNode{constructor(e){super(e,"apu",{outputChannelCount:[2]})}}let s=(...e)=>new Uint8Array(...e),A=(...e)=>new Uint32Array(...e);let a=function(a,n={}){n.setMessage||(n.setMessage=(e,t)=>{t&&console.log("error: "+t)});let B,o,r,i,l,F,d,C,D=a.getContext("2d"),g=D.createImageData(320,240),u=n.devkitMode,c=0,w=null==n.keyboardElement?a:n.keyboardElement;if(w){let e=e=>{let t,s="keydown"==e.type;switch(e.code){case"ArrowUp":t=1;break;case"ArrowDown":t=2;break;case"ArrowLeft":t=4;break;case"ArrowRight":t=8;break;case"KeyZ":t=16;break;case"KeyX":t=32;break;case"KeyA":t=64;break;case"KeyS":t=128;break;case"KeyR":s&&h(o,!0);break;case"F9":s&&a.toBlob((e=>{f(e,".png")})),e.preventDefault();break;case"F10":s&&function(){if(l)return l.stop(),l=null,d.disconnect(C),d=null,void(C=null);let e=a.captureStream();C=r.createMediaStreamDestination(),d=i,i.connect(C),e.addTrack(C.stream.getAudioTracks()[0]),l=new MediaRecorder(e,{mimeType:"video/webm",videoBitsPerSecond:25e6});let t=[];l.ondataavailable=e=>{t.push(e.data)};let s=n.timerElement;s&&(s.hidden=!1,s.innerText="00:00");function A(){if(F){if(s){let e=Math.floor((Date.now()-F)/1e3);s.innerText=Math.floor(e/60).toString().padStart(2,"0")+":"+(e%60).toString().padStart(2,"0")}setTimeout(A,1e3)}}l.onstop=()=>{s&&(s.hidden=!0),f(new Blob(t,{type:"video/webm"}),".webm")},l.start(),F=Date.now(),setTimeout(A,1e3)}(),e.preventDefault()}s?c|=t:c&=~t};w.onkeydown=e,w.onkeyup=e}async function h(l,F){B&&(B(),B=null),r=new AudioContext({sampleRate:44100});let d=!0,C=new AbortController;B=()=>{r.close(),d=!1,C.abort()};let w=l.byteLength;if(n.setMessage(w),0==w)return;await r.audioWorklet.addModule(e("data:application/javascript,let%20e%3D%28...e%29%3D%3Enew%20Uint8Array%28...e%29%3Bclass%20s%20extends%20AudioWorkletProcessor%7Bconstructor%28%29%7Bsuper%28%29%2Cthis.sampleIndex%3D0%2Cthis.currentTime%3D0%2Cthis.isFirstMessage%3D%210%2Cthis.pendingUpdates%3D%5B%5D%2Cthis.port.onmessage%3De%3D%3E%7Bthis.memory%3F%28this.isFirstMessage%26%26%28this.currentTime%2B%3D%28e.data.t-this.currentTime%29%2F8%2Cthis.isFirstMessage%3D%211%29%2Cthis.pendingUpdates.push%28e.data%29%29%3Athis.load%28e.data%5B0%5D%2Ce.data%5B1%5D%29%7D%7Dasync%20load%28e%2Cs%29%7Blet%20t%3Dnew%20WebAssembly.Memory%28%7Binitial%3A4%2Cmaximum%3A4%7D%29%2Ci%3D%7Benv%3A%7Bmemory%3At%7D%7D%3Bfor%28let%20e%20of%5B%22acos%22%2C%22asin%22%2C%22atan%22%2C%22atan2%22%2C%22cos%22%2C%22exp%22%2C%22log%22%2C%22sin%22%2C%22tan%22%2C%22pow%22%5D%29i.env%5Be%5D%3DMath%5Be%5D%3Bfor%28let%20e%3D9%3Be%3C64%3B%2B%2Be%29i.env%5B%22reserved%22%2Be%5D%3D%28%29%3D%3E%7B%7D%3Blet%20r%3D%22%22%3Bi.env.logChar%3De%3D%3E%7B10%3D%3De%3F%28console.log%28r%29%2Cr%3D%22%22%29%3Ar%2B%3DString.fromCharCode%28e%29%7D%3Bfor%28let%20e%3D0%3Be%3C16%3B%2B%2Be%29i.env%5B%22g_reserved%22%2Be%5D%3D0%3Blet%20n%3Dasync%20e%3D%3E%28await%20WebAssembly.instantiate%28e%2Ci%29%29.instance%2Ca%3Dawait%20n%28e%29%3Bfor%28let%20e%20in%20a.exports%29i.env%5Be%5D%3Da.exports%5Be%5D%3Blet%20o%3Dawait%20n%28s%29%3Bthis.memory%3Dt%2Cthis.snd%3Do.exports.snd%7C%7Ca.exports.sndGes%2Cthis.port.postMessage%282%29%7Dprocess%28s%2Ct%2Ci%29%7Bif%28this.isFirstMessage%3D%210%2Cthis.snd%29%7Bfor%28%3Bthis.pendingUpdates.length%3E0%26%26this.pendingUpdates%5B0%5D.t%3C%3Dthis.currentTime%3B%29e%28this.memory.buffer%2C80%2C32%29.set%28e%28this.pendingUpdates.shift%28%29.r%29%29%3Bnew%20Uint32Array%28this.memory.buffer%29%5B16%5D%3Dthis.currentTime%3Blet%20s%3Dt%5B0%5D%2Ci%3Dthis.sampleIndex%2Cr%3Ds%5B0%5D.length%3Bfor%28let%20e%3D0%3Be%3Cr%3B%2B%2Be%29s%5B0%5D%5Be%5D%3Dthis.snd%28i%2B%2B%29%2Cs%5B1%5D%5Be%5D%3Dthis.snd%28i%2B%2B%29%3Bthis.sampleIndex%3D4294967295%26i%2Cthis.currentTime%2B%3Dr%2F44.1%7Dreturn%210%7D%7DregisterProcessor%28%22apu%22%2Cs%29%3B")),i=new t(r);let f,y=0,Q=new Promise((e=>f=e)),m=e=>{y|=e,3==y&&f&&(f(!0),f=null)},p=()=>{"suspended"==r.state?(n.startButton&&(n.startButton.style="",a.style="display:none"),(n.startButton||a).onclick=()=>{r.resume()}):(n.startButton&&(n.startButton.style="display:none",a.style=""),m(1))};r.onstatechange=p,p(),o=l;let E=window.location.pathname;if(w<=1024&&!F){let e="";for(let t of s(l))e+=String.fromCharCode(t);E+="#"+btoa(e),E!=window.locLine truncated

src/run_native.rs

@@ -5,23 +5,20 @@ use std::{thread, time::Instant};
 use anyhow::{anyhow, Result};
 use cpal::traits::*;
 use rubato::Resampler;
+use uw8_window::{Window, WindowConfig};
 use wasmtime::{
     Engine, GlobalType, Memory, MemoryType, Module, Mutability, Store, TypedFunc, ValType,
 };
 
 pub struct MicroW8 {
-    tx: mpsc::SyncSender<Option<UW8Instance>>,
-    rx: mpsc::Receiver<UIEvent>,
+    window: Window,
     stream: Option<cpal::Stream>,
     engine: Engine,
     loader_module: Module,
     disable_audio: bool,
     module_data: Option<Vec<u8>>,
-}
-
-enum UIEvent {
-    Error(Result<()>),
-    Reset,
+    timeout: u32,
+    instance: Option<UW8Instance>,
 }
 
 struct UW8Instance {
@@ -48,7 +45,7 @@ struct UW8WatchDog {
 }
 
 impl MicroW8 {
-    pub fn new(timeout: Option<u32>, gpu: bool) -> Result<MicroW8> {
+    pub fn new(timeout: Option<u32>, window_config: WindowConfig) -> Result<MicroW8> {
         let mut config = wasmtime::Config::new();
         config.cranelift_opt_level(wasmtime::OptLevel::Speed);
         if timeout.is_some() {
@@ -59,39 +56,17 @@ impl MicroW8 {
         let loader_module =
             wasmtime::Module::new(&engine, include_bytes!("../platform/bin/loader.wasm"))?;
 
-        let (to_ui_tx, to_ui_rx) = mpsc::sync_channel(2);
-        let (from_ui_tx, from_ui_rx) = mpsc::sync_channel(1);
-
-        std::thread::spawn(move || {
-            let mut state = State {
-                instance: None,
-                timeout: timeout.unwrap_or(0),
-            };
-
-            uw8_window::run(gpu, move |framebuffer, gamepad, reset| {
-                while let Ok(instance) = to_ui_rx.try_recv() {
-                    state.instance = instance;
-                }
-
-                if reset {
-                    from_ui_tx.send(UIEvent::Reset).unwrap();
-                }
-
-                state.run_frame(framebuffer, gamepad).unwrap_or_else(|err| {
-                    from_ui_tx.send(UIEvent::Error(Err(err))).unwrap();
-                    Instant::now()
-                })
-            });
-        });
+        let window = Window::new(window_config)?;
 
         Ok(MicroW8 {
-            tx: to_ui_tx,
-            rx: from_ui_rx,
+            window,
             stream: None,
             engine,
             loader_module,
             disable_audio: false,
             module_data: None,
+            timeout: timeout.unwrap_or(0),
+            instance: None,
         })
     }
 
@@ -102,12 +77,12 @@ impl MicroW8 {
 
 impl super::Runtime for MicroW8 {
     fn is_open(&self) -> bool {
-        true
+        self.window.is_open()
     }
 
     fn load(&mut self, module_data: &[u8]) -> Result<()> {
         self.stream = None;
-        self.tx.send(None)?;
+        self.instance = None;
 
         let mut store = wasmtime::Store::new(&self.engine, ());
         store.set_epoch_deadline(60);
@@ -118,7 +93,7 @@ impl super::Runtime for MicroW8 {
         linker.define("env", "memory", memory)?;
 
         let loader_instance = linker.instantiate(&mut store, &self.loader_module)?;
-        let load_uw8 = loader_instance.get_typed_func::<i32, i32, _>(&mut store, "load_uw8")?;
+        let load_uw8 = loader_instance.get_typed_func::<i32, i32>(&mut store, "load_uw8")?;
 
         let platform_data = include_bytes!("../platform/bin/platform.uw8");
         memory.data_mut(&mut store)[..platform_data.len()].copy_from_slice(platform_data);
@@ -156,8 +131,8 @@ impl super::Runtime for MicroW8 {
         }
 
         let instance = linker.instantiate(&mut store, &module)?;
-        let end_frame = platform_instance.get_typed_func::<(), (), _>(&mut store, "endFrame")?;
-        let update = instance.get_typed_func::<(), (), _>(&mut store, "upd").ok();
+        let end_frame = platform_instance.get_typed_func::<(), ()>(&mut store, "endFrame")?;
+        let update = instance.get_typed_func::<(), ()>(&mut store, "upd").ok();
 
         let (sound_tx, stream) = if self.disable_audio {
             (None, None)
@@ -174,7 +149,7 @@ impl super::Runtime for MicroW8 {
             }
         };
 
-        self.tx.send(Some(UW8Instance {
+        self.instance = Some(UW8Instance {
             store,
             memory,
             end_frame,
@@ -182,56 +157,36 @@ impl super::Runtime for MicroW8 {
             start_time: Instant::now(),
             watchdog,
             sound_tx,
-        }))?;
+        });
         self.stream = stream;
         self.module_data = Some(module_data.into());
         Ok(())
     }
 
     fn run_frame(&mut self) -> Result<()> {
-        if let Ok(event) = self.rx.try_recv() {
-            match event {
-                UIEvent::Error(err) => err,
-                UIEvent::Reset => {
-                    if let Some(module_data) = self.module_data.take() {
-                        self.load(&module_data)
-                    } else {
-                        Ok(())
-                    }
-                }
+        let input = self.window.begin_frame();
+
+        if input.reset {
+            if let Some(module_data) = self.module_data.take() {
+                self.load(&module_data)?;
             }
-        } else {
-            Ok(())
         }
-    }
-}
 
-struct State {
-    instance: Option<UW8Instance>,
-    timeout: u32,
-}
-
-impl State {
-    fn run_frame(
-        &mut self,
-        framebuffer: &mut dyn uw8_window::Framebuffer,
-        gamepad: u32,
-    ) -> Result<Instant> {
         let now = Instant::now();
-        let mut result = Ok(now);
+        let mut result = Ok(());
         if let Some(mut instance) = self.instance.take() {
             let time = (now - instance.start_time).as_millis() as i32;
-            {
+            let next_frame = {
                 let offset = ((time as u32 as i64 * 6) % 100 - 50) / 6;
                 let max = now + Duration::from_millis(17);
                 let next_center = now + Duration::from_millis((16 - offset) as u64);
-                result = Ok(next_center.min(max));
-            }
+                next_center.min(max)
+            };
 
             {
                 let mem = instance.memory.data_mut(&mut instance.store);
                 mem[64..68].copy_from_slice(&time.to_le_bytes());
-                mem[68..72].copy_from_slice(&gamepad.to_le_bytes());
+                mem[68..72].copy_from_slice(&input.gamepads);
             }
 
             instance.store.set_epoch_deadline(self.timeout as u64);
@@ -255,14 +210,16 @@ impl State {
 
             let framebuffer_mem = &memory[120..(120 + 320 * 240)];
             let palette_mem = &memory[0x13000..];
-            framebuffer.update(framebuffer_mem, palette_mem);
+            self.window
+                .end_frame(framebuffer_mem, palette_mem, next_frame);
 
             if result.is_ok() {
                 self.instance = Some(instance);
             }
         }
 
-        Ok(result?)
+        result?;
+        Ok(())
     }
 }
 
@@ -356,8 +313,8 @@ fn init_sound(
     let instance = linker.instantiate(&mut store, module)?;
 
     let snd = instance
-        .get_typed_func::<(i32,), f32, _>(&mut store, "snd")
-        .or_else(|_| platform_instance.get_typed_func::<(i32,), f32, _>(&mut store, "gesSnd"))?;
+        .get_typed_func::<(i32,), f32>(&mut store, "snd")
+        .or_else(|_| platform_instance.get_typed_func::<(i32,), f32>(&mut store, "sndGes"))?;
 
     let host = cpal::default_host();
     let device = host
@@ -385,7 +342,7 @@ fn init_sound(
         .ok_or_else(|| anyhow!("Could not find float output config"))?;
     let sample_rate = cpal::SampleRate(44100)
         .max(config.min_sample_rate())
-        .max(config.max_sample_rate());
+        .min(config.max_sample_rate());
     let config = config.with_sample_rate(sample_rate);
     let buffer_size = match *config.buffer_size() {
         cpal::SupportedBufferSize::Unknown => cpal::BufferSize::Default,

uw8-tool/src/base_module.rs

@@ -167,6 +167,7 @@ impl BaseModule {
         add_function(&mut functions, &type_map, "exp", &[F32], Some(F32));
 
         add_function(&mut functions, &type_map, "playNote", &[I32, I32], None);
+        add_function(&mut functions, &type_map, "sndGes", &[I32], Some(F32));
 
         for i in functions.len()..64 {
             add_function(

uw8-tool/src/pack.rs

@@ -220,6 +220,11 @@ impl<'a> ParsedModule<'a> {
                     validate_table_section(reader)?;
                     table_section = Some(Section::new(range, ()));
                 }
+                Payload::MemorySection(reader) => {
+                    if reader.get_count() != 0 {
+                        bail!("Found non-empty MemorySection. Memory has to be imported!");
+                    }
+                }
                 Payload::ElementSection(mut reader) => {
                     let mut elements = Vec::with_capacity(reader.get_count() as usize);
                     for _ in 0..reader.get_count() {

uw8-window/Cargo.toml

@@ -6,12 +6,13 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-winit = "0.26.1"
-env_logger = "0.9"
+winit = "0.27.5"
+env_logger = "0.10"
 log = "0.4"
-wgpu = "0.13.1"
-pollster = "0.2"
-bytemuck = { version = "1.4", features = [ "derive" ] }
+pico-args = "0.5"
+wgpu = "0.15"
+pollster = "0.2.5"
+bytemuck = { version = "1.13", features = [ "derive" ] }
 anyhow = "1"
 minifb = { version = "0.23.0", default-features = false, features = ["x11"] }
-winapi = "0.3.9"
+winapi = { version = "0.3.9", features = [ "timeapi" ] }

uw8-window/src/cpu.rs

@@ -1,7 +1,8 @@
 use std::time::Instant;
 
-use crate::Framebuffer;
-use minifb::{Key, Window, WindowOptions};
+use crate::{Input, WindowImpl};
+use anyhow::Result;
+use minifb::{Key, WindowOptions};
 
 static GAMEPAD_KEYS: &[Key] = &[
     Key::Up,
@@ -14,58 +15,53 @@ static GAMEPAD_KEYS: &[Key] = &[
     Key::S,
 ];
 
-pub fn run(mut update: Box<dyn FnMut(&mut dyn Framebuffer, u32, bool) -> Instant + 'static>) -> ! {
-    #[cfg(target_os = "windows")]
-    unsafe {
-        winapi::um::timeapi::timeBeginPeriod(1);
-    }
+pub struct Window {
+    window: minifb::Window,
+    buffer: Vec<u32>,
+}
 
-    let mut buffer: Vec<u32> = vec![0; 320 * 240];
-
-    let options = WindowOptions {
-        scale: minifb::Scale::X2,
-        scale_mode: minifb::ScaleMode::AspectRatioStretch,
-        resize: true,
-        ..Default::default()
-    };
-    let mut window = Window::new("MicroW8", 320, 240, options).unwrap();
-
-    let mut next_frame = Instant::now();
-    while window.is_open() && !window.is_key_down(Key::Escape) {
-        if let Some(sleep) = next_frame.checked_duration_since(Instant::now()) {
-            std::thread::sleep(sleep);
+impl Window {
+    pub fn new() -> Result<Window> {
+        #[cfg(target_os = "windows")]
+        unsafe {
+            winapi::um::timeapi::timeBeginPeriod(1);
         }
 
-        let mut gamepad = 0;
-        for key in window.get_keys() {
+        let buffer: Vec<u32> = vec![0; 320 * 240];
+
+        let options = WindowOptions {
+            scale: minifb::Scale::X2,
+            scale_mode: minifb::ScaleMode::AspectRatioStretch,
+            resize: true,
+            ..Default::default()
+        };
+        let window = minifb::Window::new("MicroW8", 320, 240, options).unwrap();
+
+        Ok(Window { window, buffer })
+    }
+}
+
+impl WindowImpl for Window {
+    fn begin_frame(&mut self) -> Input {
+        let mut gamepads = [0u8; 4];
+        for key in self.window.get_keys() {
             if let Some(index) = GAMEPAD_KEYS
                 .iter()
                 .enumerate()
                 .find(|(_, &k)| k == key)
                 .map(|(i, _)| i)
             {
-                gamepad |= 1 << index;
+                gamepads[0] |= 1 << index;
             }
         }
 
-        next_frame = update(
-            &mut CpuFramebuffer {
-                buffer: &mut buffer,
-            },
-            gamepad,
-            window.is_key_pressed(Key::R, minifb::KeyRepeat::No),
-        );
-        window.update_with_buffer(&buffer, 320, 240).unwrap();
+        Input {
+            gamepads,
+            reset: self.window.is_key_pressed(Key::R, minifb::KeyRepeat::No),
+        }
     }
-    std::process::exit(0);
-}
 
-struct CpuFramebuffer<'a> {
-    buffer: &'a mut Vec<u32>,
-}
-
-impl<'a> Framebuffer for CpuFramebuffer<'a> {
-    fn update(&mut self, framebuffer: &[u8], palette: &[u8]) {
+    fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
         for (i, &color_index) in framebuffer.iter().enumerate() {
             let offset = color_index as usize * 4;
             self.buffer[i] = 0xff000000
@@ -73,5 +69,15 @@ impl<'a> Framebuffer for CpuFramebuffer<'a> {
                 | ((palette[offset + 1] as u32) << 8)
                 | palette[offset + 2] as u32;
         }
+        self.window
+            .update_with_buffer(&self.buffer, 320, 240)
+            .unwrap();
+        if let Some(sleep) = next_frame.checked_duration_since(Instant::now()) {
+            std::thread::sleep(sleep);
+        }
+    }
+
+    fn is_open(&self) -> bool {
+        self.window.is_open() && !self.window.is_key_down(Key::Escape)
     }
 }

uw8-window/src/gpu/crt.rs

@@ -112,7 +112,7 @@ impl CrtFilter {
 }
 
 impl Filter for CrtFilter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
         let uniforms = Uniforms {
             texture_scale: texture_scale_from_resolution(new_size),
         };

uw8-window/src/gpu/crt.wgsl

@@ -36,36 +36,36 @@ fn sample_pixel(coords: vec2<i32>, offset: vec4<f32>) -> vec3<f32> {
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    let pixel = floor(in.tex_coords);
-    let o = vec2<f32>(0.5) - (in.tex_coords - pixel);
-    let pixel = vec2<i32>(pixel);
+    let pixelf = floor(in.tex_coords);
+    let o = vec2<f32>(0.5) - (in.tex_coords - pixelf);
+    let pixel = vec2<i32>(pixelf);
     
     let offset_x = o.xxxx + vec4<f32>(-0.125, 0.375, 0.125, -0.375) * uniforms.texture_scale.z;
     let offset_y = o.yyyy + vec4<f32>(-0.375, -0.125, 0.375, 0.125) * uniforms.texture_scale.z;
     
-    let offset_x0 = max(abs(offset_x + vec4<f32>(-1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
-    let offset_x1 = max(abs(offset_x) - vec4<f32>(0.5), vec4<f32>(0.0));
-    let offset_x2 = max(abs(offset_x + vec4<f32>(1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
+    var offset_x0 = max(abs(offset_x + vec4<f32>(-1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
+    var offset_x1 = max(abs(offset_x) - vec4<f32>(0.5), vec4<f32>(0.0));
+    var offset_x2 = max(abs(offset_x + vec4<f32>(1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
     
-    let offset_x0 = offset_x0 * offset_x0;
-    let offset_x1 = offset_x1 * offset_x1;
-    let offset_x2 = offset_x2 * offset_x2;
+    offset_x0 = offset_x0 * offset_x0;
+    offset_x1 = offset_x1 * offset_x1;
+    offset_x2 = offset_x2 * offset_x2;
     
-    let offset_yr = offset_y + vec4<f32>(-1.0);
-    let offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
+    var offset_yr = offset_y + vec4<f32>(-1.0);
+    offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
     
     var acc = sample_pixel(pixel + vec2<i32>(-1, -1), offset_x0 + offset_yr);
     acc = acc + sample_pixel(pixel + vec2<i32>(0, -1), offset_x1 + offset_yr);
     acc = acc + sample_pixel(pixel + vec2<i32>(1, -1), offset_x2 + offset_yr);
 
-    let offset_yr = vec4<f32>(0.02) + offset_y * offset_y;
+    offset_yr = vec4<f32>(0.02) + offset_y * offset_y;
     
     acc = acc + sample_pixel(pixel + vec2<i32>(-1, 0), offset_x0 + offset_yr);
     acc = acc + sample_pixel(pixel, offset_x1 + offset_yr);
     acc = acc + sample_pixel(pixel + vec2<i32>(1, 0), offset_x2 + offset_yr);
 
-    let offset_yr = offset_y + vec4<f32>(1.0);
-    let offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
+    offset_yr = offset_y + vec4<f32>(1.0);
+    offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
     
     acc = acc + sample_pixel(pixel + vec2<i32>(-1, 1), offset_x0 + offset_yr);
     acc = acc + sample_pixel(pixel + vec2<i32>(0, 1), offset_x1 + offset_yr);

uw8-window/src/gpu/fast_crt.rs

@@ -15,6 +15,7 @@ impl FastCrtFilter {
         screen: &wgpu::TextureView,
         resolution: PhysicalSize<u32>,
         surface_format: wgpu::TextureFormat,
+        chromatic: bool,
     ) -> FastCrtFilter {
         let uniforms = Uniforms {
             texture_scale: texture_scale_from_resolution(resolution),
@@ -104,7 +105,11 @@ impl FastCrtFilter {
             },
             fragment: Some(wgpu::FragmentState {
                 module: &shader,
-                entry_point: "fs_main",
+                entry_point: if chromatic {
+                    "fs_main_chromatic"
+                } else {
+                    "fs_main"
+                },
                 targets: &[Some(wgpu::ColorTargetState {
                     format: surface_format,
                     blend: None,
@@ -126,7 +131,7 @@ impl FastCrtFilter {
 }
 
 impl Filter for FastCrtFilter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
         let uniforms = Uniforms {
             texture_scale: texture_scale_from_resolution(new_size),
         };

uw8-window/src/gpu/fast_crt.wgsl

@@ -34,10 +34,9 @@ fn col_factor(offset: f32) -> f32 {
     return 1.0 / (1.0 + offset * offset * 16.0);
 }
 
-@fragment
-fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    let base = round(in.tex_coords) - vec2<f32>(0.5);
-    let frac = in.tex_coords - base;
+fn sample_screen(tex_coords: vec2<f32>) -> vec4<f32> {
+    let base = round(tex_coords) - vec2<f32>(0.5);
+    let frac = tex_coords - base;
     
     let top_factor = row_factor(frac.y);
     let bottom_factor = row_factor(frac.y - 1.0);
@@ -52,3 +51,16 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     return textureSample(screen_texture, linear_sampler, vec2<f32>(u, v) / vec2<f32>(320.0, 240.0)) * (top_factor + bottom_factor) * (left_factor + right_factor) * 1.1;
 }
 
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return sample_screen(in.tex_coords);
+}
+
+@fragment
+fn fs_main_chromatic(in: VertexOutput) -> @location(0) vec4<f32> {
+    let r = sample_screen(in.tex_coords + vec2<f32>(0.2, 0.2)).r;
+    let g = sample_screen(in.tex_coords + vec2<f32>(0.07, -0.27)).g;
+    let b = sample_screen(in.tex_coords + vec2<f32>(-0.27, 0.07)).b;
+    return vec4<f32>(r, g, b, 1.0);
+}
+

uw8-window/src/gpu/mod.rs

@@ -1,4 +1,4 @@
-use crate::Framebuffer;
+use crate::{Input, WindowConfig, WindowImpl};
 use anyhow::{anyhow, Result};
 use std::{num::NonZeroU32, time::Instant};
 
@@ -9,12 +9,7 @@ use winit::{
     window::{Fullscreen, WindowBuilder},
 };
 
-#[cfg(target_os = "macos")]
-use winit::platform::macos::EventLoopExtMacOS;
-#[cfg(target_os = "linux")]
-use winit::platform::unix::EventLoopExtUnix;
-#[cfg(target_os = "windows")]
-use winit::platform::windows::EventLoopExtWindows;
+use winit::platform::run_return::EventLoopExtRunReturn;
 
 mod crt;
 mod fast_crt;
@@ -25,29 +20,41 @@ use fast_crt::FastCrtFilter;
 use square::SquareFilter;
 
 pub struct Window {
-    event_loop: EventLoop<()>,
-    window: winit::window::Window,
-    instance: wgpu::Instance,
+    _instance: wgpu::Instance,
     surface: wgpu::Surface,
-    adapter: wgpu::Adapter,
+    _adapter: wgpu::Adapter,
     device: wgpu::Device,
     queue: wgpu::Queue,
+    palette_screen_mode: PaletteScreenMode,
+    surface_config: wgpu::SurfaceConfiguration,
+    filter: Box<dyn Filter>,
+    event_loop: EventLoop<()>,
+    window: winit::window::Window,
+    gamepads: [u8; 4],
+    next_frame: Instant,
+    is_fullscreen: bool,
+    is_open: bool,
 }
 
 impl Window {
-    pub fn new() -> Result<Window> {
-        async fn create() -> Result<Window> {
-            let event_loop = EventLoop::new_any_thread();
+    pub fn new(window_config: WindowConfig) -> Result<Window> {
+        async fn create(window_config: WindowConfig) -> Result<Window> {
+            let event_loop = EventLoop::new();
             let window = WindowBuilder::new()
                 .with_inner_size(PhysicalSize::new(640u32, 480))
                 .with_min_inner_size(PhysicalSize::new(320u32, 240))
                 .with_title("MicroW8")
+                .with_fullscreen(if window_config.fullscreen {
+                    Some(Fullscreen::Borderless(None))
+                } else {
+                    None
+                })
                 .build(&event_loop)?;
 
             window.set_cursor_visible(false);
 
-            let instance = wgpu::Instance::new(wgpu::Backends::all());
-            let surface = unsafe { instance.create_surface(&window) };
+            let instance = wgpu::Instance::new(Default::default());
+            let surface = unsafe { instance.create_surface(&window) }?;
             let adapter = instance
                 .request_adapter(&wgpu::RequestAdapterOptions {
                     power_preference: wgpu::PowerPreference::LowPower,
@@ -61,70 +68,65 @@ impl Window {
                 .request_device(&wgpu::DeviceDescriptor::default(), None)
                 .await?;
 
+            let palette_screen_mode = PaletteScreenMode::new(&device);
+
+            let surface_config = wgpu::SurfaceConfiguration {
+                present_mode: wgpu::PresentMode::AutoNoVsync,
+                ..surface.get_default_config(&adapter, window.inner_size().width, window.inner_size().height).expect("Surface incompatible with adapter")
+            };
+
+            let filter: Box<dyn Filter> = create_filter(
+                &device,
+                &palette_screen_mode.screen_view,
+                window.inner_size(),
+                surface_config.format,
+                window_config.filter,
+            );
+
+            surface.configure(&device, &surface_config);
+
             Ok(Window {
                 event_loop,
                 window,
-                instance,
+                _instance: instance,
                 surface,
-                adapter,
+                _adapter: adapter,
                 device,
                 queue,
+                palette_screen_mode,
+                surface_config,
+                filter,
+                gamepads: [0; 4],
+                next_frame: Instant::now(),
+                is_fullscreen: window_config.fullscreen,
+                is_open: true,
             })
         }
 
-        pollster::block_on(create())
+        pollster::block_on(create(window_config))
     }
+}
 
-    pub fn run(
-        self,
-        mut update: Box<dyn FnMut(&mut dyn Framebuffer, u32, bool) -> Instant + 'static>,
-    ) -> ! {
-        let Window {
-            event_loop,
-            window,
-            instance,
-            surface,
-            adapter,
-            device,
-            queue,
-        } = self;
-
-        let palette_screen_mode = PaletteScreenMode::new(&device);
-
-        let mut surface_config = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format: surface.get_supported_formats(&adapter)[0],
-            width: window.inner_size().width,
-            height: window.inner_size().height,
-            present_mode: wgpu::PresentMode::AutoNoVsync,
-        };
-
-        let mut filter: Box<dyn Filter> = Box::new(CrtFilter::new(
-            &device,
-            &palette_screen_mode.screen_view,
-            window.inner_size(),
-            surface_config.format,
-        ));
-
-        surface.configure(&device, &surface_config);
-
+impl WindowImpl for Window {
+    fn begin_frame(&mut self) -> Input {
         let mut reset = false;
-        let mut gamepad = 0;
-
-        event_loop.run(move |event, _, control_flow| {
-            let _ = (&window, &instance, &surface, &adapter, &device);
-
+        self.event_loop.run_return(|event, _, control_flow| {
+            *control_flow = ControlFlow::WaitUntil(self.next_frame);
+            let mut new_filter = None;
             match event {
                 Event::WindowEvent { event, .. } => match event {
                     WindowEvent::Resized(new_size) => {
-                        surface_config.width = new_size.width;
-                        surface_config.height = new_size.height;
-                        surface.configure(&device, &surface_config);
-                        filter.resize(&queue, new_size);
+                        self.surface_config.width = new_size.width;
+                        self.surface_config.height = new_size.height;
+                        self.surface.configure(&self.device, &self.surface_config);
+                        self.filter.resize(&self.queue, new_size);
+                    }
+                    WindowEvent::CloseRequested => {
+                        self.is_open = false;
+                        *control_flow = ControlFlow::Exit;
                     }
-                    WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
                     WindowEvent::KeyboardInput { input, .. } => {
-                        fn gamepad_button(input: &winit::event::KeyboardInput) -> u32 {
+                        fn gamepad_button(input: &winit::event::KeyboardInput) -> u8 {
                             match input.scancode {
                                 44 => 16,
                                 45 => 32,
@@ -141,124 +143,195 @@ impl Window {
                         }
                         if input.state == winit::event::ElementState::Pressed {
                             match input.virtual_keycode {
-                                Some(VirtualKeyCode::Escape) => *control_flow = ControlFlow::Exit,
+                                Some(VirtualKeyCode::Escape) => {
+                                    self.is_open = false;
+                                    *control_flow = ControlFlow::Exit;
+                                }
                                 Some(VirtualKeyCode::F) => {
-                                    window.set_fullscreen(if window.fullscreen().is_some() {
+                                    let fullscreen = if self.window.fullscreen().is_some() {
                                         None
                                     } else {
                                         Some(Fullscreen::Borderless(None))
-                                    });
+                                    };
+                                    self.is_fullscreen = fullscreen.is_some();
+                                    self.window.set_fullscreen(fullscreen);
                                 }
                                 Some(VirtualKeyCode::R) => reset = true,
-                                Some(VirtualKeyCode::Key1) => {
-                                    filter = Box::new(SquareFilter::new(
-                                        &device,
-                                        &palette_screen_mode.screen_view,
-                                        window.inner_size(),
-                                        surface_config.format,
-                                    ))
-                                }
-                                Some(VirtualKeyCode::Key2) => {
-                                    filter = Box::new(FastCrtFilter::new(
-                                        &device,
-                                        &palette_screen_mode.screen_view,
-                                        window.inner_size(),
-                                        surface_config.format,
-                                    ))
-                                }
-                                Some(VirtualKeyCode::Key3) => {
-                                    filter = Box::new(CrtFilter::new(
-                                        &device,
-                                        &palette_screen_mode.screen_view,
-                                        window.inner_size(),
-                                        surface_config.format,
-                                    ))
-                                }
+                                Some(VirtualKeyCode::Key1) => new_filter = Some(1),
+                                Some(VirtualKeyCode::Key2) => new_filter = Some(2),
+                                Some(VirtualKeyCode::Key3) => new_filter = Some(3),
+                                Some(VirtualKeyCode::Key4) => new_filter = Some(4),
+                                Some(VirtualKeyCode::Key5) => new_filter = Some(5),
                                 _ => (),
                             }
 
-                            gamepad |= gamepad_button(&input);
+                            self.gamepads[0] |= gamepad_button(&input);
                         } else {
-                            gamepad &= !gamepad_button(&input);
+                            self.gamepads[0] &= !gamepad_button(&input);
                         }
                     }
                     _ => (),
                 },
-                Event::MainEventsCleared => {
-                    if let ControlFlow::WaitUntil(t) = *control_flow {
-                        if Instant::now() < t {
-                            return;
-                        }
-                    }
-                    let next_frame = update(
-                        &mut GpuFramebuffer {
-                            queue: &queue,
-                            framebuffer: &palette_screen_mode,
-                        },
-                        gamepad,
-                        reset,
-                    );
-                    reset = false;
-                    *control_flow = ControlFlow::WaitUntil(next_frame);
-
-                    let output = surface.get_current_texture().unwrap();
-                    let view = output
-                        .texture
-                        .create_view(&wgpu::TextureViewDescriptor::default());
-                    let mut encoder = device
-                        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
-
-                    palette_screen_mode.resolve_screen(&mut encoder);
-
+                Event::RedrawEventsCleared => {
+                    if Instant::now() >= self.next_frame
+                        // workaround needed on Wayland until the next winit release
+                        && self.window.fullscreen().is_some() == self.is_fullscreen
                     {
-                        let mut render_pass =
-                            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                                label: None,
-                                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                                    view: &view,
-                                    resolve_target: None,
-                                    ops: wgpu::Operations {
-                                        load: wgpu::LoadOp::Clear(wgpu::Color {
-                                            r: 0.0,
-                                            g: 0.0,
-                                            b: 0.0,
-                                            a: 1.0,
-                                        }),
-                                        store: true,
-                                    },
-                                })],
-                                depth_stencil_attachment: None,
-                            });
-
-                        filter.render(&mut render_pass);
+                        *control_flow = ControlFlow::Exit
                     }
-
-                    queue.submit(std::iter::once(encoder.finish()));
-                    output.present();
                 }
                 _ => (),
             }
+            if let Some(new_filter) = new_filter {
+                self.filter = create_filter(
+                    &self.device,
+                    &self.palette_screen_mode.screen_view,
+                    self.window.inner_size(),
+                    self.surface_config.format,
+                    new_filter,
+                );
+            }
         });
+        Input {
+            gamepads: self.gamepads,
+            reset,
+        }
+    }
+
+    fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
+        self.next_frame = next_frame;
+        self.palette_screen_mode
+            .write_framebuffer(&self.queue, framebuffer);
+        self.palette_screen_mode.write_palette(&self.queue, palette);
+
+        let output = self.surface.get_current_texture().unwrap();
+        let view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+
+        self.palette_screen_mode.resolve_screen(&mut encoder);
+
+        {
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color {
+                            r: 0.0,
+                            g: 0.0,
+                            b: 0.0,
+                            a: 1.0,
+                        }),
+                        store: true,
+                    },
+                })],
+                depth_stencil_attachment: None,
+            });
+
+            self.filter.render(&mut render_pass);
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        output.present();
+    }
+
+    fn is_open(&self) -> bool {
+        self.is_open
     }
 }
 
-struct GpuFramebuffer<'a> {
-    framebuffer: &'a PaletteScreenMode,
-    queue: &'a wgpu::Queue,
-}
-
-impl<'a> Framebuffer for GpuFramebuffer<'a> {
-    fn update(&mut self, pixels: &[u8], palette: &[u8]) {
-        self.framebuffer.write_framebuffer(self.queue, pixels);
-        self.framebuffer.write_palette(self.queue, palette);
+fn create_filter(
+    device: &wgpu::Device,
+    screen_texture: &wgpu::TextureView,
+    window_size: PhysicalSize<u32>,
+    surface_format: wgpu::TextureFormat,
+    filter: u32,
+) -> Box<dyn Filter> {
+    match filter {
+        1 => Box::new(SquareFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+        )),
+        2 => Box::new(FastCrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+            false,
+        )),
+        3 => Box::new(CrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+        )),
+        4 => Box::new(FastCrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+            true,
+        )),
+        _ => Box::new(AutoCrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+        )),
     }
 }
 
 trait Filter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>);
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>);
     fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>);
 }
 
+struct AutoCrtFilter {
+    small: CrtFilter,
+    large: FastCrtFilter,
+    resolution: PhysicalSize<u32>,
+}
+
+impl AutoCrtFilter {
+    fn new(
+        device: &wgpu::Device,
+        screen: &wgpu::TextureView,
+        resolution: PhysicalSize<u32>,
+        surface_format: wgpu::TextureFormat,
+    ) -> AutoCrtFilter {
+        let small = CrtFilter::new(device, screen, resolution, surface_format);
+        let large = FastCrtFilter::new(device, screen, resolution, surface_format, true);
+        AutoCrtFilter {
+            small,
+            large,
+            resolution,
+        }
+    }
+}
+
+impl Filter for AutoCrtFilter {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+        self.small.resize(queue, new_size);
+        self.large.resize(queue, new_size);
+        self.resolution = new_size;
+    }
+
+    fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+        if self.resolution.width < 960 || self.resolution.height < 720 {
+            self.small.render(render_pass);
+        } else {
+            self.large.render(render_pass);
+        }
+    }
+}
+
 struct PaletteScreenMode {
     framebuffer: wgpu::Texture,
     palette: wgpu::Texture,
@@ -281,6 +354,7 @@ impl PaletteScreenMode {
             format: wgpu::TextureFormat::R8Uint,
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
             label: None,
+            view_formats: &[]
         });
 
         let palette_texture = device.create_texture(&wgpu::TextureDescriptor {
@@ -295,6 +369,7 @@ impl PaletteScreenMode {
             format: wgpu::TextureFormat::Rgba8UnormSrgb,
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
             label: None,
+            view_formats: &[]
         });
 
         let screen_texture = device.create_texture(&wgpu::TextureDescriptor {
@@ -309,6 +384,7 @@ impl PaletteScreenMode {
             format: wgpu::TextureFormat::Rgba8UnormSrgb,
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
             label: None,
+            view_formats: &[]
         });
 
         let framebuffer_texture_view =

uw8-window/src/gpu/square.rs

@@ -126,7 +126,7 @@ impl SquareFilter {
 }
 
 impl Filter for SquareFilter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
         let uniforms = Uniforms {
             texture_scale: texture_scale_from_resolution(new_size),
         };

uw8-window/src/lib.rs

@@ -1,24 +1,117 @@
+use anyhow::Result;
 use std::time::Instant;
 
 mod cpu;
 mod gpu;
 
-pub fn run<F: 'static + FnMut(&mut dyn Framebuffer, u32, bool) -> Instant>(
-    gpu: bool,
-    update: F,
-) -> ! {
-    if gpu {
-        match gpu::Window::new() {
-            Ok(window) => window.run(Box::new(update)),
-            Err(err) => eprintln!(
-                "Failed to create gpu window: {}\nFalling back to cpu window",
-                err
-            ),
-        }
-    }
-    cpu::run(Box::new(update));
+pub struct Window {
+    inner: Box<dyn WindowImpl>,
+    fps_counter: Option<FpsCounter>,
 }
 
-pub trait Framebuffer {
-    fn update(&mut self, pixels: &[u8], palette: &[u8]);
+struct FpsCounter {
+    start: Instant,
+    num_frames: u32,
+}
+
+impl Window {
+    pub fn new(config: WindowConfig) -> Result<Window> {
+        let fps_counter = if config.fps_counter {
+            Some(FpsCounter {
+                start: Instant::now(),
+                num_frames: 0,
+            })
+        } else {
+            None
+        };
+        if config.enable_gpu {
+            match gpu::Window::new(config) {
+                Ok(window) => {
+                    return Ok(Window {
+                        inner: Box::new(window),
+                        fps_counter,
+                    })
+                }
+                Err(err) => eprintln!(
+                    "Failed to create gpu window: {}\nFalling back tp cpu window",
+                    err
+                ),
+            }
+        }
+        cpu::Window::new().map(|window| Window {
+            inner: Box::new(window),
+            fps_counter,
+        })
+    }
+
+    pub fn begin_frame(&mut self) -> Input {
+        self.inner.begin_frame()
+    }
+    pub fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
+        self.inner.end_frame(framebuffer, palette, next_frame);
+        if let Some(ref mut fps_counter) = self.fps_counter {
+            fps_counter.num_frames += 1;
+            let elapsed = fps_counter.start.elapsed().as_secs_f32();
+            if elapsed >= 1.0 {
+                println!("fps: {:.1}", fps_counter.num_frames as f32 / elapsed);
+                fps_counter.num_frames = 0;
+                fps_counter.start = Instant::now();
+            }
+        }
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.inner.is_open()
+    }
+}
+
+#[derive(Debug)]
+pub struct WindowConfig {
+    enable_gpu: bool,
+    filter: u32,
+    fullscreen: bool,
+    fps_counter: bool,
+}
+
+impl Default for WindowConfig {
+    fn default() -> WindowConfig {
+        WindowConfig {
+            enable_gpu: true,
+            filter: 5,
+            fullscreen: false,
+            fps_counter: false,
+        }
+    }
+}
+
+impl WindowConfig {
+    pub fn parse_arguments(&mut self, args: &mut pico_args::Arguments) {
+        self.enable_gpu = !args.contains("--no-gpu");
+        if let Some(filter) = args.opt_value_from_str::<_, String>("--filter").unwrap() {
+            self.filter = match filter.as_str() {
+                "1" | "nearest" => 1,
+                "2" | "fast_crt" => 2,
+                "3" | "ss_crt" => 3,
+                "4" | "chromatic" => 4,
+                "5" | "auto_crt" => 5,
+                o => {
+                    println!("Unknown --filter '{}'", o);
+                    std::process::exit(1);
+                }
+            }
+        }
+        self.fullscreen = args.contains("--fullscreen");
+        self.fps_counter = args.contains("--fps");
+    }
+}
+
+pub struct Input {
+    pub gamepads: [u8; 4],
+    pub reset: bool,
+}
+
+trait WindowImpl {
+    fn begin_frame(&mut self) -> Input;
+    fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant);
+    fn is_open(&self) -> bool;
 }

uw8-window/src/main.rs

@@ -1,10 +1,13 @@
 use std::time::Instant;
+use uw8_window::WindowConfig;
 
 fn main() {
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
 
+    let mut args = pico_args::Arguments::from_env();
+
     let mut framebuffer = vec![0u8; 320 * 240];
-    let start_time = Instant::now();
+    let mut start_time = Instant::now();
 
     let mut palette = vec![0u32; 256];
     for i in 0..256 {
@@ -18,11 +21,19 @@ fn main() {
     let mut fps_start = Instant::now();
     let mut fps_counter = 0;
 
-    uw8_window::run(true, move |gpu_framebuffer, _gamepads, _reset| {
-        for _ in 0..1 {
-            draw_frame(&mut framebuffer, start_time.elapsed().as_secs_f32());
+    let mut window_config = WindowConfig::default();
+    window_config.parse_arguments(&mut args);
+
+    let mut window = uw8_window::Window::new(window_config).unwrap();
+
+    while window.is_open() {
+        let input = window.begin_frame();
+        if input.reset {
+            start_time = Instant::now();
         }
-        gpu_framebuffer.update(&framebuffer, bytemuck::cast_slice(&palette));
+        draw_frame(&mut framebuffer, start_time.elapsed().as_secs_f32());
+        window.end_frame(&framebuffer, bytemuck::cast_slice(&palette), Instant::now());
+
         fps_counter += 1;
         let elapsed = fps_start.elapsed().as_secs_f32();
         if elapsed >= 1.0 {
@@ -30,8 +41,7 @@ fn main() {
             fps_start = Instant::now();
             fps_counter = 0;
         }
-        Instant::now()
-    });
+    }
 }
 
 fn draw_frame(framebuffer: &mut [u8], time: f32) {

web/src/audiolet.js

@@ -63,7 +63,7 @@ class APU extends AudioWorkletProcessor {
 
         this.memory = memory;
 
-        this.snd = instance.exports.snd || platform_instance.exports.gesSnd;
+        this.snd = instance.exports.snd || platform_instance.exports.sndGes;
 
         this.port.postMessage(2);
     }