fix build?

.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: Rust
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, testing ]
 
 env:
   CARGO_TERM_COLOR: always

Cargo.toml

@@ -1,19 +1,21 @@
 [package]
 name = "uw8"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
 default = ["native", "browser"]
-native = ["wasmtime", "minifb", "cpal", "rubato", "winapi" ]
+native = ["wasmtime", "uw8-window", "cpal", "rubato" ]
 browser = ["warp", "tokio", "tokio-stream", "webbrowser"]
 
 [dependencies]
 wasmtime = { version = "0.37.0", optional = true }
 anyhow = "1"
-minifb = { version = "0.22", default-features = false, features = ["x11"], optional = true }
+env_logger = "0.9"
+log = "0.4"
+uw8-window = { path = "uw8-window", optional = true }
 notify = "4"
 pico-args = "0.4"
 curlywas = { git = "https://github.com/exoticorn/curlywas.git", rev = "0e7ea50" }
@@ -27,4 +29,3 @@ webbrowser = { version = "0.6.0", optional = true }
 ansi_term = "0.12.1"
 cpal = { version = "0.13.5", optional = true }
 rubato = { version = "0.11.0", optional = true }
-winapi = { version = "0.3.9", features = ["timeapi"], 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/wat/tunnel_opt.wat

@@ -35,24 +35,24 @@
       f32.convert_i32_s
       f32.sqrt
       f32.div
+      call $time
       i32.const 163
       f32.convert_i32_s
-      call $time
       f32.mul
       f32.add
       i32.trunc_sat_f32_s
 
-      i32.const 163
-      f32.convert_i32_s
       local.get $x
       f32.convert_i32_s
       local.get $y
       f32.convert_i32_s
       call $atan2
+      i32.const 163
+      f32.convert_i32_s
       f32.mul
+      call $time
       i32.const 64
       f32.convert_i32_s
-      call $time
       f32.mul
       f32.add
       i32.trunc_f32_s

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:

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
@@ -80,7 +81,16 @@ 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"]);
+    let disable_audio = args.contains(["-m", "--no-audio"]);
+
+    #[cfg(feature = "native")]
+    let window_config = {
+        let mut config = WindowConfig::default();
+        if !run_browser {
+            config.parse_arguments(&mut args);
+        }
+        config
+    };
 
     let filename = args.free_from_os_str::<PathBuf, bool>(|s| Ok(s.into()))?;
 
@@ -88,12 +98,14 @@ fn run(mut args: Arguments) -> Result<()> {
 
     use std::process::exit;
 
+    use uw8_window::WindowConfig;
+
     let mut runtime: Box<dyn Runtime> = if !run_browser {
         #[cfg(not(feature = "native"))]
         unimplemented!();
         #[cfg(feature = "native")]
         {
-            let mut microw8 = MicroW8::new(timeout)?;
+            let mut microw8 = MicroW8::new(timeout, window_config)?;
             if disable_audio {
                 microw8.disable_audio();
             }
@@ -165,7 +177,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_native.rs

@@ -4,31 +4,21 @@ use std::{thread, time::Instant};
 
 use anyhow::{anyhow, Result};
 use cpal::traits::*;
-use minifb::{Key, Window, WindowOptions};
 use rubato::Resampler;
+use uw8_window::{Window, WindowConfig};
 use wasmtime::{
     Engine, GlobalType, Memory, MemoryType, Module, Mutability, Store, TypedFunc, ValType,
 };
 
-static GAMEPAD_KEYS: &[Key] = &[
-    Key::Up,
-    Key::Down,
-    Key::Left,
-    Key::Right,
-    Key::Z,
-    Key::X,
-    Key::A,
-    Key::S,
-];
-
 pub struct MicroW8 {
+    window: Window,
+    stream: Option<cpal::Stream>,
     engine: Engine,
     loader_module: Module,
-    window: Window,
-    window_buffer: Vec<u32>,
-    instance: Option<UW8Instance>,
-    timeout: u32,
     disable_audio: bool,
+    module_data: Option<Vec<u8>>,
+    timeout: u32,
+    instance: Option<UW8Instance>,
 }
 
 struct UW8Instance {
@@ -37,10 +27,8 @@ struct UW8Instance {
     end_frame: TypedFunc<(), ()>,
     update: Option<TypedFunc<(), ()>>,
     start_time: Instant,
-    next_frame: Instant,
-    module: Vec<u8>,
     watchdog: Arc<Mutex<UW8WatchDog>>,
-    sound: Option<Uw8Sound>,
+    sound_tx: Option<mpsc::SyncSender<RegisterUpdate>>,
 }
 
 impl Drop for UW8Instance {
@@ -57,12 +45,7 @@ struct UW8WatchDog {
 }
 
 impl MicroW8 {
-    pub fn new(timeout: Option<u32>) -> Result<MicroW8> {
-        #[cfg(target_os = "windows")]
-        unsafe {
-            winapi::um::timeapi::timeBeginPeriod(1);
-        }
-
+    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() {
@@ -73,32 +56,20 @@ impl MicroW8 {
         let loader_module =
             wasmtime::Module::new(&engine, include_bytes!("../platform/bin/loader.wasm"))?;
 
-        let options = WindowOptions {
-            scale: minifb::Scale::X2,
-            scale_mode: minifb::ScaleMode::AspectRatioStretch,
-            resize: true,
-            ..Default::default()
-        };
-        let window = Window::new("MicroW8", 320, 240, options)?;
+        let window = Window::new(window_config)?;
 
         Ok(MicroW8 {
+            window,
+            stream: None,
             engine,
             loader_module,
-            window,
-            window_buffer: vec![0u32; 320 * 240],
-            instance: None,
-            timeout: timeout.unwrap_or(0),
             disable_audio: false,
+            module_data: None,
+            timeout: timeout.unwrap_or(0),
+            instance: None,
         })
     }
 
-    fn reset(&mut self) {
-        self.instance = None;
-        for v in &mut self.window_buffer {
-            *v = 0;
-        }
-    }
-
     pub fn disable_audio(&mut self) {
         self.disable_audio = true;
     }
@@ -106,11 +77,12 @@ impl MicroW8 {
 
 impl super::Runtime for MicroW8 {
     fn is_open(&self) -> bool {
-        self.window.is_open() && !self.window.is_key_down(Key::Escape)
+        self.window.is_open()
     }
 
     fn load(&mut self, module_data: &[u8]) -> Result<()> {
-        self.reset();
+        self.stream = None;
+        self.instance = None;
 
         let mut store = wasmtime::Store::new(&self.engine, ());
         store.set_epoch_deadline(60);
@@ -162,17 +134,17 @@ impl super::Runtime for MicroW8 {
         let end_frame = platform_instance.get_typed_func::<(), (), _>(&mut store, "endFrame")?;
         let update = instance.get_typed_func::<(), (), _>(&mut store, "upd").ok();
 
-        let sound = if self.disable_audio {
-            None
+        let (sound_tx, stream) = if self.disable_audio {
+            (None, None)
         } else {
             match init_sound(&self.engine, &platform_module, &module) {
                 Ok(sound) => {
                     sound.stream.play()?;
-                    Some(sound)
+                    (Some(sound.tx), Some(sound.stream))
                 }
                 Err(err) => {
                     eprintln!("Failed to init sound: {}", err);
-                    None
+                    (None, None)
                 }
             }
         };
@@ -183,52 +155,45 @@ impl super::Runtime for MicroW8 {
             end_frame,
             update,
             start_time: Instant::now(),
-            next_frame: Instant::now(),
-            module: module_data.into(),
             watchdog,
-            sound,
+            sound_tx,
         });
-
+        self.stream = stream;
+        self.module_data = Some(module_data.into());
         Ok(())
     }
 
     fn run_frame(&mut self) -> Result<()> {
+        let input = self.window.begin_frame();
+
+        if input.reset {
+            if let Some(module_data) = self.module_data.take() {
+                self.load(&module_data)?;
+            }
+        }
+
+        let now = Instant::now();
         let mut result = Ok(());
         if let Some(mut instance) = self.instance.take() {
-            {
-                if let Some(sleep) = instance.next_frame.checked_duration_since(Instant::now()) {
-                    std::thread::sleep(sleep);
-                }
-            }
-
-            let now = Instant::now();
             let time = (now - instance.start_time).as_millis() as i32;
-            {
+            let next_frame = {
                 let offset = ((time as u32 as i64 * 6) % 100 - 50) / 6;
-                instance.next_frame = now + Duration::from_millis((16 - offset) as u64);
-            }
+                let max = now + Duration::from_millis(17);
+                let next_center = now + Duration::from_millis((16 - offset) as u64);
+                next_center.min(max)
+            };
 
             {
-                let mut gamepad: u32 = 0;
-                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;
-                    }
-                }
-
                 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);
             if let Some(ref update) = instance.update {
-                result = update.call(&mut instance.store, ());
+                if let Err(err) = update.call(&mut instance.store, ()) {
+                    result = Err(err);
+                }
             }
             instance.end_frame.call(&mut instance.store, ())?;
 
@@ -236,33 +201,23 @@ impl super::Runtime for MicroW8 {
 
             let mut sound_regs = [0u8; 32];
             sound_regs.copy_from_slice(&memory[80..112]);
-            if let Some(ref sound) = instance.sound {
-                sound.tx.send(RegisterUpdate {
+            if let Some(ref sound_tx) = instance.sound_tx {
+                let _ = sound_tx.send(RegisterUpdate {
                     time,
                     data: sound_regs,
-                })?;
+                });
             }
 
-            let framebuffer = &memory[120..(120 + 320 * 240)];
-            let palette = &memory[0x13000..];
-            for (i, &color_index) in framebuffer.iter().enumerate() {
-                let offset = color_index as usize * 4;
-                self.window_buffer[i] = 0xff000000
-                    | ((palette[offset] as u32) << 16)
-                    | ((palette[offset + 1] as u32) << 8)
-                    | palette[offset + 2] as u32;
-            }
+            let framebuffer_mem = &memory[120..(120 + 320 * 240)];
+            let palette_mem = &memory[0x13000..];
+            self.window
+                .end_frame(framebuffer_mem, palette_mem, next_frame);
 
-            if self.window.is_key_pressed(Key::R, minifb::KeyRepeat::No) {
-                self.load(&instance.module)?;
-            } else if result.is_ok() {
+            if result.is_ok() {
                 self.instance = Some(instance);
             }
         }
 
-        self.window
-            .update_with_buffer(&self.window_buffer, 320, 240)?;
-
         result?;
         Ok(())
     }

uw8-window/.gitignore

@@ -0,0 +1 @@
+/target

uw8-window/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "uw8-window"
+version = "0.1.0"
+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"
+log = "0.4"
+pico-args = "0.4"
+wgpu = "0.13.1"
+pollster = "0.2"
+bytemuck = { version = "1.4", features = [ "derive" ] }
+anyhow = "1"
+minifb = { version = "0.23.0", default-features = false, features = ["x11"] }
+winapi = "0.3.9"

uw8-window/src/cpu.rs

@@ -0,0 +1,83 @@
+use std::time::Instant;
+
+use crate::{Input, WindowImpl};
+use anyhow::Result;
+use minifb::{Key, WindowOptions};
+
+static GAMEPAD_KEYS: &[Key] = &[
+    Key::Up,
+    Key::Down,
+    Key::Left,
+    Key::Right,
+    Key::Z,
+    Key::X,
+    Key::A,
+    Key::S,
+];
+
+pub struct Window {
+    window: minifb::Window,
+    buffer: Vec<u32>,
+}
+
+impl Window {
+    pub fn new() -> Result<Window> {
+        #[cfg(target_os = "windows")]
+        unsafe {
+            winapi::um::timeapi::timeBeginPeriod(1);
+        }
+
+        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)
+            {
+                gamepads[0] |= 1 << index;
+            }
+        }
+
+        Input {
+            gamepads,
+            reset: self.window.is_key_pressed(Key::R, minifb::KeyRepeat::No),
+        }
+    }
+
+    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
+                | ((palette[offset] as u32) << 16)
+                | ((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

@@ -0,0 +1,143 @@
+use wgpu::util::DeviceExt;
+use winit::dpi::PhysicalSize;
+
+use super::Filter;
+
+pub struct CrtFilter {
+    uniform_buffer: wgpu::Buffer,
+    bind_group: wgpu::BindGroup,
+    pipeline: wgpu::RenderPipeline,
+}
+
+impl CrtFilter {
+    pub fn new(
+        device: &wgpu::Device,
+        screen: &wgpu::TextureView,
+        resolution: PhysicalSize<u32>,
+        surface_format: wgpu::TextureFormat,
+    ) -> CrtFilter {
+        let uniforms = Uniforms {
+            texture_scale: texture_scale_from_resolution(resolution),
+        };
+
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&[uniforms]),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+
+        let crt_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Uniform,
+                            has_dynamic_offset: false,
+                            min_binding_size: None,
+                        },
+                        count: None,
+                    },
+                ],
+                label: None,
+            });
+
+        let crt_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &crt_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&screen),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: uniform_buffer.as_entire_binding(),
+                },
+            ],
+            label: None,
+        });
+
+        let crt_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(include_str!("crt.wgsl").into()),
+        });
+
+        let render_pipeline_layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: &[&crt_bind_group_layout],
+                push_constant_ranges: &[],
+            });
+
+        let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&render_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &crt_shader,
+                entry_point: "vs_main",
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &crt_shader,
+                entry_point: "fs_main",
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: surface_format,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview: None,
+        });
+
+        CrtFilter {
+            uniform_buffer,
+            bind_group: crt_bind_group,
+            pipeline: render_pipeline,
+        }
+    }
+}
+
+impl Filter for CrtFilter {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+        let uniforms = Uniforms {
+            texture_scale: texture_scale_from_resolution(new_size),
+        };
+        queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[uniforms]));
+    }
+
+    fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.draw(0..6, 0..1);
+    }
+}
+
+fn texture_scale_from_resolution(res: PhysicalSize<u32>) -> [f32; 4] {
+    let scale = ((res.width as f32) / 160.0).min((res.height as f32) / 120.0);
+    [
+        res.width as f32 / scale,
+        res.height as f32 / scale,
+        2.0 / scale,
+        0.0,
+    ]
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct Uniforms {
+    texture_scale: [f32; 4],
+}

uw8-window/src/gpu/crt.wgsl

@@ -0,0 +1,75 @@
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) tex_coords: vec2<f32>,
+}
+
+struct Uniforms {
+    texture_scale: vec4<f32>,
+}
+
+@group(0) @binding(1) var<uniform> uniforms: Uniforms;
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) in_vertex_index: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+    let i = in_vertex_index / 3u + in_vertex_index % 3u;
+    let x = -1.0 + f32(i % 2u) * 322.0;
+    let y = -1.0 + f32(i / 2u) * 242.0;
+    out.clip_position = vec4<f32>((vec2<f32>(x, y) - vec2<f32>(160.0, 120.0)) / uniforms.texture_scale.xy, 0.0, 1.0);
+    out.tex_coords = vec2<f32>(x, y);
+    return out;
+}
+
+@group(0) @binding(0) var screen_texture: texture_2d<f32>;
+
+fn sample_pixel(coords: vec2<i32>, offset: vec4<f32>) -> vec3<f32> {
+    let is_outside = any(vec2<u32>(coords) >= vec2<u32>(320u, 240u));
+    if(is_outside) {
+        return vec3<f32>(0.0);
+    } else {
+        let f = max(vec4<f32>(0.008) / offset - vec4<f32>(0.0024), vec4<f32>(0.0));
+        return textureLoad(screen_texture, coords, 0).rgb * (f.x + f.y + f.z + f.w);
+    }
+}
+
+@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 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));
+    
+    let offset_x0 = offset_x0 * offset_x0;
+    let offset_x1 = offset_x1 * offset_x1;
+    let 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 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;
+    
+    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;
+    
+    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);
+    acc = acc + sample_pixel(pixel + vec2<i32>(1, 1), offset_x2 + offset_yr);
+
+    return vec4<f32>(acc, 1.0);
+}

uw8-window/src/gpu/fast_crt.rs

@@ -0,0 +1,162 @@
+use wgpu::util::DeviceExt;
+use winit::dpi::PhysicalSize;
+
+use super::Filter;
+
+pub struct FastCrtFilter {
+    uniform_buffer: wgpu::Buffer,
+    bind_group: wgpu::BindGroup,
+    pipeline: wgpu::RenderPipeline,
+}
+
+impl FastCrtFilter {
+    pub fn new(
+        device: &wgpu::Device,
+        screen: &wgpu::TextureView,
+        resolution: PhysicalSize<u32>,
+        surface_format: wgpu::TextureFormat,
+        chromatic: bool,
+    ) -> FastCrtFilter {
+        let uniforms = Uniforms {
+            texture_scale: texture_scale_from_resolution(resolution),
+        };
+
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&[uniforms]),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+
+        let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        multisampled: false,
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                },
+            ],
+            label: None,
+        });
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            mag_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&screen),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: uniform_buffer.as_entire_binding(),
+                },
+            ],
+            label: None,
+        });
+
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(include_str!("fast_crt.wgsl").into()),
+        });
+
+        let render_pipeline_layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: &[&bind_group_layout],
+                push_constant_ranges: &[],
+            });
+
+        let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&render_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: "vs_main",
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: if chromatic {
+                    "fs_main_chromatic"
+                } else {
+                    "fs_main"
+                },
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: surface_format,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview: None,
+        });
+
+        FastCrtFilter {
+            uniform_buffer,
+            bind_group,
+            pipeline: render_pipeline,
+        }
+    }
+}
+
+impl Filter for FastCrtFilter {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+        let uniforms = Uniforms {
+            texture_scale: texture_scale_from_resolution(new_size),
+        };
+        queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[uniforms]));
+    }
+
+    fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.draw(0..6, 0..1);
+    }
+}
+
+fn texture_scale_from_resolution(res: PhysicalSize<u32>) -> [f32; 4] {
+    let scale = ((res.width as f32) / 160.0).min((res.height as f32) / 120.0);
+    [
+        scale / res.width as f32,
+        scale / res.height as f32,
+        2.0 / scale,
+        0.0,
+    ]
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct Uniforms {
+    texture_scale: [f32; 4],
+}

uw8-window/src/gpu/fast_crt.wgsl

@@ -0,0 +1,66 @@
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) tex_coords: vec2<f32>,
+}
+
+struct Uniforms {
+    texture_scale: vec4<f32>,
+}
+
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) in_vertex_index: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+    let i = in_vertex_index / 3u + in_vertex_index % 3u;
+    let x = 0.0 + f32(i % 2u) * 320.0;
+    let y = 0.0 + f32(i / 2u) * 240.0;
+    out.clip_position = vec4<f32>((vec2<f32>(x, y) - vec2<f32>(160.0, 120.0)) * uniforms.texture_scale.xy, 0.0, 1.0);
+    out.tex_coords = vec2<f32>(x, y);
+    return out;
+}
+
+@group(0) @binding(0) var screen_texture: texture_2d<f32>;
+@group(0) @binding(1) var linear_sampler: sampler;
+
+fn row_factor(offset: f32) -> f32 {
+    return 1.0 / (1.0 + offset * offset * 16.0);
+}
+
+fn col_factor(offset: f32) -> f32 {
+    let offset = max(0.0, abs(offset) - 0.4);
+    return 1.0 / (1.0 + offset * offset * 16.0);
+}
+
+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);
+    
+    let v = base.y + bottom_factor / (bottom_factor + top_factor);
+    
+    let left_factor = col_factor(frac.x);
+    let right_factor = col_factor(frac.x - 1.0);
+    
+    let u = base.x + right_factor / (right_factor + left_factor);
+    
+    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

@@ -0,0 +1,545 @@
+use crate::{Input, WindowConfig, WindowImpl};
+use anyhow::{anyhow, Result};
+use std::{num::NonZeroU32, time::Instant};
+
+use winit::{
+    dpi::PhysicalSize,
+    event::{Event, VirtualKeyCode, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::{Fullscreen, WindowBuilder},
+};
+
+use winit::platform::run_return::EventLoopExtRunReturn;
+
+mod crt;
+mod fast_crt;
+mod square;
+
+use crt::CrtFilter;
+use fast_crt::FastCrtFilter;
+use square::SquareFilter;
+
+pub struct Window {
+    _instance: wgpu::Instance,
+    surface: wgpu::Surface,
+    _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(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 adapter = instance
+                .request_adapter(&wgpu::RequestAdapterOptions {
+                    power_preference: wgpu::PowerPreference::LowPower,
+                    compatible_surface: Some(&surface),
+                    force_fallback_adapter: false,
+                })
+                .await
+                .ok_or_else(|| anyhow!("Request adapter failed"))?;
+
+            let (device, queue) = adapter
+                .request_device(&wgpu::DeviceDescriptor::default(), None)
+                .await?;
+
+            let palette_screen_mode = PaletteScreenMode::new(&device);
+
+            let 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 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,
+                surface,
+                _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(window_config))
+    }
+}
+
+impl WindowImpl for Window {
+    fn begin_frame(&mut self) -> Input {
+        let mut reset = false;
+        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) => {
+                        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::KeyboardInput { input, .. } => {
+                        fn gamepad_button(input: &winit::event::KeyboardInput) -> u8 {
+                            match input.scancode {
+                                44 => 16,
+                                45 => 32,
+                                30 => 64,
+                                31 => 128,
+                                _ => match input.virtual_keycode {
+                                    Some(VirtualKeyCode::Up) => 1,
+                                    Some(VirtualKeyCode::Down) => 2,
+                                    Some(VirtualKeyCode::Left) => 4,
+                                    Some(VirtualKeyCode::Right) => 8,
+                                    _ => 0,
+                                },
+                            }
+                        }
+                        if input.state == winit::event::ElementState::Pressed {
+                            match input.virtual_keycode {
+                                Some(VirtualKeyCode::Escape) => {
+                                    self.is_open = false;
+                                    *control_flow = ControlFlow::Exit;
+                                }
+                                Some(VirtualKeyCode::F) => {
+                                    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) => 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),
+                                _ => (),
+                            }
+
+                            self.gamepads[0] |= gamepad_button(&input);
+                        } else {
+                            self.gamepads[0] &= !gamepad_button(&input);
+                        }
+                    }
+                    _ => (),
+                },
+                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
+                    {
+                        *control_flow = ControlFlow::Exit
+                    }
+                }
+                _ => (),
+            }
+            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
+    }
+}
+
+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(&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,
+    screen_view: wgpu::TextureView,
+    bind_group: wgpu::BindGroup,
+    pipeline: wgpu::RenderPipeline,
+}
+
+impl PaletteScreenMode {
+    fn new(device: &wgpu::Device) -> PaletteScreenMode {
+        let framebuffer_texture = device.create_texture(&wgpu::TextureDescriptor {
+            size: wgpu::Extent3d {
+                width: 320,
+                height: 240,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::R8Uint,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            label: None,
+        });
+
+        let palette_texture = device.create_texture(&wgpu::TextureDescriptor {
+            size: wgpu::Extent3d {
+                width: 256,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D1,
+            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            label: None,
+        });
+
+        let screen_texture = device.create_texture(&wgpu::TextureDescriptor {
+            size: wgpu::Extent3d {
+                width: 320,
+                height: 240,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
+            label: None,
+        });
+
+        let framebuffer_texture_view =
+            framebuffer_texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let palette_texture_view =
+            palette_texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let screen_texture_view =
+            screen_texture.create_view(&wgpu::TextureViewDescriptor::default());
+
+        let palette_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            sample_type: wgpu::TextureSampleType::Uint,
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            view_dimension: wgpu::TextureViewDimension::D1,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                        },
+                        count: None,
+                    },
+                ],
+                label: None,
+            });
+
+        let palette_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &palette_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&framebuffer_texture_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::TextureView(&palette_texture_view),
+                },
+            ],
+            label: None,
+        });
+
+        let palette_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(include_str!("palette.wgsl").into()),
+        });
+
+        let palette_pipeline_layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: &[&palette_bind_group_layout],
+                push_constant_ranges: &[],
+            });
+
+        let palette_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&palette_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &palette_shader,
+                entry_point: "vs_main",
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &palette_shader,
+                entry_point: "fs_main",
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: wgpu::TextureFormat::Rgba8UnormSrgb,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview: None,
+        });
+
+        PaletteScreenMode {
+            framebuffer: framebuffer_texture,
+            palette: palette_texture,
+            screen_view: screen_texture_view,
+            bind_group: palette_bind_group,
+            pipeline: palette_pipeline,
+        }
+    }
+
+    fn write_framebuffer(&self, queue: &wgpu::Queue, pixels: &[u8]) {
+        queue.write_texture(
+            wgpu::ImageCopyTexture {
+                texture: &self.framebuffer,
+                mip_level: 0,
+                origin: wgpu::Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            &bytemuck::cast_slice(pixels),
+            wgpu::ImageDataLayout {
+                offset: 0,
+                bytes_per_row: NonZeroU32::new(320),
+                rows_per_image: None,
+            },
+            wgpu::Extent3d {
+                width: 320,
+                height: 240,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+
+    fn write_palette(&self, queue: &wgpu::Queue, palette: &[u8]) {
+        queue.write_texture(
+            wgpu::ImageCopyTexture {
+                texture: &self.palette,
+                mip_level: 0,
+                origin: wgpu::Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            &bytemuck::cast_slice(palette),
+            wgpu::ImageDataLayout {
+                offset: 0,
+                bytes_per_row: NonZeroU32::new(256 * 4),
+                rows_per_image: None,
+            },
+            wgpu::Extent3d {
+                width: 256,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+
+    fn resolve_screen(&self, encoder: &mut wgpu::CommandEncoder) {
+        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: None,
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: &self.screen_view,
+                resolve_target: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: true,
+                },
+            })],
+            depth_stencil_attachment: None,
+        });
+
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.draw(0..3, 0..1);
+    }
+}

uw8-window/src/gpu/palette.wgsl

@@ -0,0 +1,24 @@
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) tex_coords: vec2<f32>,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index: u32) -> VertexOutput {
+    var out: VertexOutput;
+    let x = (1.0 - f32(vertex_index)) * 3.0;
+    let y = f32(vertex_index & 1u) * 3.0 - 1.0;
+    out.clip_position = vec4<f32>(x, y, 0.0, 1.0);
+    out.tex_coords = vec2<f32>((x + 1.0) * 160.0, (y + 1.0) * 120.0);
+    return out;
+}
+
+@group(0) @binding(0) var framebuffer_texture: texture_2d<u32>;
+@group(0) @binding(1) var palette_texture: texture_1d<f32>;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let texel = vec2<i32>(floor(in.tex_coords));
+    let index = textureLoad(framebuffer_texture, texel, 0).r;
+    return textureLoad(palette_texture, i32(index), 0);
+}

uw8-window/src/gpu/square.rs

@@ -0,0 +1,157 @@
+use wgpu::util::DeviceExt;
+use winit::dpi::PhysicalSize;
+
+use super::Filter;
+
+pub struct SquareFilter {
+    uniform_buffer: wgpu::Buffer,
+    bind_group: wgpu::BindGroup,
+    pipeline: wgpu::RenderPipeline,
+}
+
+impl SquareFilter {
+    pub fn new(
+        device: &wgpu::Device,
+        screen: &wgpu::TextureView,
+        resolution: PhysicalSize<u32>,
+        surface_format: wgpu::TextureFormat,
+    ) -> SquareFilter {
+        let uniforms = Uniforms {
+            texture_scale: texture_scale_from_resolution(resolution),
+        };
+
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&[uniforms]),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+
+        let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        multisampled: false,
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                },
+            ],
+            label: None,
+        });
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            mag_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&screen),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: uniform_buffer.as_entire_binding(),
+                },
+            ],
+            label: None,
+        });
+
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(include_str!("square.wgsl").into()),
+        });
+
+        let render_pipeline_layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: &[&bind_group_layout],
+                push_constant_ranges: &[],
+            });
+
+        let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&render_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: "vs_main",
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: "fs_main",
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: surface_format,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview: None,
+        });
+
+        SquareFilter {
+            uniform_buffer,
+            bind_group,
+            pipeline: render_pipeline,
+        }
+    }
+}
+
+impl Filter for SquareFilter {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+        let uniforms = Uniforms {
+            texture_scale: texture_scale_from_resolution(new_size),
+        };
+        queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[uniforms]));
+    }
+
+    fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.draw(0..6, 0..1);
+    }
+}
+
+fn texture_scale_from_resolution(res: PhysicalSize<u32>) -> [f32; 4] {
+    let scale = ((res.width as f32) / 160.0).min((res.height as f32) / 120.0);
+    [
+        scale / res.width as f32,
+        scale / res.height as f32,
+        2.0 / scale,
+        0.0,
+    ]
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct Uniforms {
+    texture_scale: [f32; 4],
+}

uw8-window/src/gpu/square.wgsl

@@ -0,0 +1,44 @@
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) tex_coords: vec2<f32>,
+}
+
+struct Uniforms {
+    texture_scale: vec4<f32>,
+}
+
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) in_vertex_index: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+    let i = in_vertex_index / 3u + in_vertex_index % 3u;
+    let x = 0.0 + f32(i % 2u) * 320.0;
+    let y = 0.0 + f32(i / 2u) * 240.0;
+    out.clip_position = vec4<f32>((vec2<f32>(x, y) - vec2<f32>(160.0, 120.0)) * uniforms.texture_scale.xy, 0.0, 1.0);
+    out.tex_coords = vec2<f32>(x, y);
+    return out;
+}
+
+@group(0) @binding(0) var screen_texture: texture_2d<f32>;
+@group(0) @binding(1) var linear_sampler: sampler;
+
+fn aa_tex_coord(c: f32) -> f32 {
+    let low = c - uniforms.texture_scale.z * 0.5;
+    let high = c + uniforms.texture_scale.z * 0.5;
+    let base = floor(low);
+    let center = base + 0.5;
+    let next = base + 1.0;
+    if high > next {
+        return center + (high - next) / (high - low);
+    } else {
+        return center;
+    }
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return textureSample(screen_texture, linear_sampler, vec2<f32>(aa_tex_coord(in.tex_coords.x), aa_tex_coord(in.tex_coords.y)) / vec2<f32>(320.0, 240.0));
+}

uw8-window/src/lib.rs

@@ -0,0 +1,81 @@
+use anyhow::Result;
+use std::time::Instant;
+
+mod cpu;
+mod gpu;
+
+pub struct Window(Box<dyn WindowImpl>);
+
+impl Window {
+    pub fn new(config: WindowConfig) -> Result<Window> {
+        if config.enable_gpu {
+            match gpu::Window::new(config) {
+                Ok(window) => return Ok(Window(Box::new(window))),
+                Err(err) => eprintln!(
+                    "Failed to create gpu window: {}\nFalling back tp cpu window",
+                    err
+                ),
+            }
+        }
+        cpu::Window::new().map(|window| Window(Box::new(window)))
+    }
+
+    pub fn begin_frame(&mut self) -> Input {
+        self.0.begin_frame()
+    }
+    pub fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
+        self.0.end_frame(framebuffer, palette, next_frame)
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.0.is_open()
+    }
+}
+
+#[derive(Debug)]
+pub struct WindowConfig {
+    enable_gpu: bool,
+    filter: u32,
+    fullscreen: bool,
+}
+
+impl Default for WindowConfig {
+    fn default() -> WindowConfig {
+        WindowConfig {
+            enable_gpu: true,
+            filter: 5,
+            fullscreen: 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");
+    }
+}
+
+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

@@ -0,0 +1,59 @@
+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 mut start_time = Instant::now();
+
+    let mut palette = vec![0u32; 256];
+    for i in 0..256 {
+        let v = i & 15;
+        let r = ((i >> 2) & 12) * v;
+        let g = ((i >> 3) & 12) * v;
+        let b = ((i >> 4) & 12) * v;
+        palette[i as usize] = r + (g << 8) + (b << 16);
+    }
+
+    let mut fps_start = Instant::now();
+    let mut fps_counter = 0;
+
+    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();
+        }
+        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 {
+            println!("{:.1} fps", fps_counter as f32 / elapsed);
+            fps_start = Instant::now();
+            fps_counter = 0;
+        }
+    }
+}
+
+fn draw_frame(framebuffer: &mut [u8], time: f32) {
+    for x in 0..320 {
+        let xr = x as f32 - 160.0;
+        for y in 0..240 {
+            let yr = y as f32 - 120.0;
+            let f = 8192.0 / (xr * xr + yr * yr);
+            let u = xr * f + 512.0 + time * 32.0;
+            let v = yr * f + time * 29.0;
+            let c = (u.floor() as i32 ^ v.floor() as i32) as u32;
+            framebuffer[x + y * 320] = c as u8;
+        }
+    }
+}

web/src/index.html

@@ -10,7 +10,7 @@
     </head>
     <body>
         <div id="uw8">
-            <a href="https://exoticorn.github.io/microw8">MicroW8</a> 0.2.0
+            <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">