fix: Completly refactor GPU scanline composition code.

This change fixes #9 and emulates:
- Correct layer ordering
- Correct emulation of blending sfx
- Correct emulation of the object window (BIOS boot animation is now fixed)


Former-commit-id: caf46fe4b62cc54e6f2c02a8001da552f8e6b54a

Cargo.toml

@@ -32,6 +32,7 @@ bytesize = "1.0.0"
 memmem = "0.1.1"
 log = "0.4.8"
 flexi_logger = {version = "0.14", features = ["colors"]}
+arrayvec = "0.5.1"
 
 rustyline = {version = "5.0.0", optional = true}
 nom = {version = "5.0.0", optional = true}

src/core/gba.rs

@@ -84,7 +84,6 @@ impl GameBoyAdvance {
 
     pub fn frame(&mut self) {
         self.key_poll();
-        self.sysbus.io.gpu.clear();
         while self.sysbus.io.gpu.vcount != DISPLAY_HEIGHT {
             self.step();
         }

src/core/gpu/layer.rs

@@ -0,0 +1,91 @@
+use num::FromPrimitive;
+
+use super::*;
+
+#[derive(Primitive, Debug, Ord, Eq, PartialOrd, PartialEq, Clone, Copy)]
+pub enum RenderLayerKind {
+    Backdrop = 0b00100000,
+    Background3 = 0b00001000,
+    Background2 = 0b00000100,
+    Background1 = 0b00000010,
+    Background0 = 0b00000001,
+    Objects = 0b00010000,
+}
+
+impl RenderLayerKind {
+    pub fn get_blend_flag(&self) -> BlendFlags {
+        match self {
+            RenderLayerKind::Background0 => BlendFlags::BG0,
+            RenderLayerKind::Background1 => BlendFlags::BG1,
+            RenderLayerKind::Background2 => BlendFlags::BG2,
+            RenderLayerKind::Background3 => BlendFlags::BG3,
+            RenderLayerKind::Objects => BlendFlags::OBJ,
+            RenderLayerKind::Backdrop => BlendFlags::BACKDROP,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct RenderLayer {
+    pub kind: RenderLayerKind,
+    pub priority: u16,
+    pub pixel: Rgb15,
+    /// priority used to distinguish between sprites, backgrounds and backdrop
+    pub priority_by_type: u8,
+}
+
+impl RenderLayer {
+    pub fn background(bg: usize, pixel: Rgb15, priority: u16) -> RenderLayer {
+        RenderLayer {
+            kind: RenderLayerKind::from_usize(1 << bg).unwrap(),
+            pixel: pixel,
+            priority: priority,
+            priority_by_type: 1,
+        }
+    }
+
+    pub fn objects(pixel: Rgb15, priority: u16) -> RenderLayer {
+        RenderLayer {
+            kind: RenderLayerKind::Objects,
+            pixel: pixel,
+            priority: priority,
+            priority_by_type: 0,
+        }
+    }
+
+    pub fn backdrop(pixel: Rgb15) -> RenderLayer {
+        RenderLayer {
+            kind: RenderLayerKind::Backdrop,
+            pixel: pixel,
+            priority: 4,
+            priority_by_type: 2,
+        }
+    }
+
+    pub(super) fn is_object(&self) -> bool {
+        self.kind == RenderLayerKind::Objects
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrayvec::ArrayVec;
+
+    #[test]
+    fn test_layer_sort_order() {
+        let mut layers = ArrayVec::<[_; 7]>::new();
+
+        let backdrop = Rgb15(0xaaaa);
+        let pixel = Rgb15::WHITE;
+        layers.push(RenderLayer::background(0, pixel, 3));
+        layers.push(RenderLayer::backdrop(backdrop));
+        layers.push(RenderLayer::background(1, pixel, 2));
+        layers.push(RenderLayer::background(3, pixel, 0));
+        layers.push(RenderLayer::background(2, pixel, 2));
+        layers.push(RenderLayer::backdrop(backdrop));
+        layers.push(RenderLayer::objects(pixel, 1));
+        layers.sort_by_key(|k| (k.priority, k.priority_by_type));
+        assert_eq!(RenderLayer::background(3, pixel, 0), layers[0]);
+    }
+}

src/core/gpu/mod.rs

@@ -16,10 +16,14 @@ mod render;
 
 use render::Point;
 
+mod layer;
 mod mosaic;
 mod rgb15;
 mod sfx;
+mod window;
+
 pub use rgb15::Rgb15;
+pub use window::*;
 
 pub mod regs;
 pub use regs::*;
@@ -109,42 +113,6 @@ pub struct Background {
     mosaic_first_row: Scanline,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct Window {
-    pub left: u8,
-    pub right: u8,
-    pub top: u8,
-    pub bottom: u8,
-    pub flags: WindowFlags,
-}
-
-impl Window {
-    pub fn inside(&self, x: usize, y: usize) -> bool {
-        let left = self.left as usize;
-        let mut right = self.right as usize;
-        let top = self.top as usize;
-        let mut bottom = self.bottom as usize;
-
-        if right > DISPLAY_WIDTH || right < left {
-            right = DISPLAY_WIDTH;
-        }
-        if bottom > DISPLAY_HEIGHT || bottom < top {
-            bottom = DISPLAY_HEIGHT;
-        }
-
-        (x >= left && x < right) && (y >= top && y < bottom)
-    }
-}
-
-#[derive(Debug)]
-pub enum WindowType {
-    Win0,
-    Win1,
-    WinObj,
-    WinOut,
-    WinNone,
-}
-
 #[derive(Debug, Default, Copy, Clone)]
 pub struct AffineMatrix {
     pub pa: i32,
@@ -167,15 +135,17 @@ pub struct BgAffine {
 
 #[derive(Serialize, Deserialize, Debug, Copy, Clone)]
 pub struct ObjBufferEntry {
+    pub(super) window: bool,
+    pub(super) alpha: bool,
     pub(super) color: Rgb15,
     pub(super) priority: u16,
-    pub(super) window: bool,
 }
 
 impl Default for ObjBufferEntry {
     fn default() -> ObjBufferEntry {
         ObjBufferEntry {
             window: false,
+            alpha: false,
             color: Rgb15::TRANSPARENT,
             priority: 4,
         }
@@ -250,6 +220,7 @@ impl Gpu {
             oam: BoxedMemory::new(vec![0; OAM_SIZE].into_boxed_slice()),
 
             obj_buffer: vec![Default::default(); DISPLAY_WIDTH * DISPLAY_HEIGHT],
+
             frame_buffer: vec![0; DISPLAY_WIDTH * DISPLAY_HEIGHT],
         }
     }
@@ -289,18 +260,16 @@ impl Gpu {
         )
     }
 
+    #[inline]
     pub(super) fn obj_buffer_get(&self, x: usize, y: usize) -> &ObjBufferEntry {
         &self.obj_buffer[index2d!(x, y, DISPLAY_WIDTH)]
     }
 
+    #[inline]
     pub(super) fn obj_buffer_get_mut(&mut self, x: usize, y: usize) -> &mut ObjBufferEntry {
         &mut self.obj_buffer[index2d!(x, y, DISPLAY_WIDTH)]
     }
 
-    pub(super) fn render_pixel(&mut self, x: i32, y: i32, p: Rgb15) {
-        self.frame_buffer[index2d!(usize, x, y, DISPLAY_WIDTH)] = p.to_rgb24();
-    }
-
     pub fn get_ref_point(&self, bg: usize) -> Point {
         assert!(bg == 2 || bg == 3);
         (
@@ -310,46 +279,50 @@ impl Gpu {
     }
 
     pub fn render_scanline(&mut self) {
+        if self.dispcnt.enable_obj() {
+            self.render_objs();
+        }
         match self.dispcnt.mode() {
             0 => {
-                for bg in 0..4 {
+                for bg in 0..=3 {
-                    if self.dispcnt.disp_bg(bg) {
+                    if self.dispcnt.enable_bg(bg) {
                         self.render_reg_bg(bg);
                     }
                 }
+                self.finalize_scanline(0, 3);
             }
             1 => {
-                if self.dispcnt.disp_bg(2) {
+                if self.dispcnt.enable_bg(2) {
                     self.render_aff_bg(2);
                 }
-                if self.dispcnt.disp_bg(1) {
+                if self.dispcnt.enable_bg(1) {
                     self.render_reg_bg(1);
                 }
-                if self.dispcnt.disp_bg(0) {
+                if self.dispcnt.enable_bg(0) {
                     self.render_reg_bg(0);
                 }
+                self.finalize_scanline(0, 2);
             }
             2 => {
-                if self.dispcnt.disp_bg(3) {
+                if self.dispcnt.enable_bg(3) {
                     self.render_aff_bg(3);
                 }
-                if self.dispcnt.disp_bg(2) {
+                if self.dispcnt.enable_bg(2) {
                     self.render_aff_bg(2);
                 }
+                self.finalize_scanline(2, 3);
             }
             3 => {
                 self.render_mode3(2);
+                self.finalize_scanline(2, 2);
             }
             4 => {
                 self.render_mode4(2);
+                self.finalize_scanline(2, 2);
             }
             _ => panic!("{:?} not supported", self.dispcnt.mode()),
         }
-        if self.dispcnt.disp_obj() {
+        // self.mosaic_sfx();
-            self.render_objs();
-        }
-        self.mosaic_sfx();
-        self.composite_sfx_to_framebuffer();
     }
 
     fn update_vcount(&mut self, value: usize, irqs: &mut IrqBitmask) {
@@ -363,8 +336,8 @@ impl Gpu {
         }
     }
 
-    // Clears the gpu internal buffer
+    /// Clears the gpu obj buffer
-    pub fn clear(&mut self) {
+    pub fn obj_buffer_reset(&mut self) {
         for x in self.obj_buffer.iter_mut() {
             *x = Default::default();
         }
@@ -377,7 +350,7 @@ impl Gpu {
         irqs: &mut IrqBitmask,
         video_device: &VideoDeviceRcRefCell,
     ) {
-        match self.state {
+        match completed {
             HDraw => {
                 // Transition to HBlank
                 self.state = HBlank;
@@ -419,6 +392,7 @@ impl Gpu {
 
                     sb.io.dmac.notify_vblank();
                     video_device.borrow_mut().render(&self.frame_buffer);
+                    self.obj_buffer_reset();
                     self.cycles_left_for_current_state = CYCLES_SCANLINE;
                 }
             }

src/core/gpu/mosaic.rs

@@ -13,7 +13,7 @@ impl Gpu {
         let vsize = (self.mosaic.bg_vsize() + 1) as usize;
 
         for bg in 0..4 {
-            if self.dispcnt.disp_bg(bg) && self.bg[bg].bgcnt.mosaic() {
+            if self.dispcnt.enable_bg(bg) && self.bg[bg].bgcnt.mosaic() {
                 let y = self.vcount as usize;
                 if y % vsize == 0 {
                     self.bg[bg].mosaic_first_row = self.bg[bg].line.clone();

src/core/gpu/regs.rs

@@ -1,6 +1,8 @@
+use super::layer::{RenderLayer, RenderLayerKind};
 use super::sfx::BldMode;
 use super::*;
 
+use num::ToPrimitive;
 use serde::{Deserialize, Serialize};
 
 pub const SCREEN_BLOCK_SIZE: u32 = 0x800;
@@ -12,11 +14,11 @@ pub enum ObjMapping {
 }
 
 impl DisplayControl {
-    pub fn disp_bg(&self, bg: usize) -> bool {
+    pub fn enable_bg(&self, bg: usize) -> bool {
         self.0.bit(8 + bg)
     }
     pub fn is_using_windows(&self) -> bool {
-        self.disp_window0() || self.disp_window1() || self.disp_obj_window()
+        self.enable_window0() || self.enable_window1() || self.enable_obj_window()
     }
     pub fn obj_mapping(&self) -> ObjMapping {
         if self.obj_character_vram_mapping() {
@@ -71,14 +73,14 @@ bitfield! {
     pub hblank_interval_free, _: 5;
     pub obj_character_vram_mapping, _: 6;
     pub forst_vblank, _: 7;
-    pub disp_bg0, _ : 8;
+    pub enable_bg0, _ : 8;
-    pub disp_bg1, _ : 9;
+    pub enable_bg1, _ : 9;
-    pub disp_bg2, _ : 10;
+    pub enable_bg2, _ : 10;
-    pub disp_bg3, _ : 11;
+    pub enable_bg3, _ : 11;
-    pub disp_obj, _ : 12;
+    pub enable_obj, _ : 12;
-    pub disp_window0, _ : 13;
+    pub enable_window0, _ : 13;
-    pub disp_window1, _ : 14;
+    pub enable_window1, _ : 14;
-    pub disp_obj_window, _ : 15;
+    pub enable_obj_window, _ : 15;
 }
 
 bitfield! {
@@ -149,6 +151,15 @@ impl BlendFlags {
     pub fn from_bg(bg: usize) -> BlendFlags {
         Self::BG_LAYER_FLAG[bg]
     }
+
+    pub fn obj_enabled(&self) -> bool {
+        self.contains(BlendFlags::OBJ)
+    }
+
+    pub fn contains_render_layer(&self, layer: &RenderLayer) -> bool {
+        let layer_flags = BlendFlags::from_bits(layer.kind.to_u32().unwrap()).unwrap();
+        self.contains(layer_flags)
+    }
 }
 
 bitfield! {
@@ -194,6 +205,9 @@ impl WindowFlags {
     pub fn bg_enabled(&self, bg: usize) -> bool {
         self.contains(BG_WIN_FLAG[bg])
     }
+    pub fn obj_enabled(&self) -> bool {
+        self.contains(WindowFlags::OBJ)
+    }
 }
 
 const BG_WIN_FLAG: [WindowFlags; 4] = [

src/core/gpu/render/obj.rs

@@ -45,18 +45,12 @@ impl ObjAttrs {
             (0x20, PixelFormat::BPP4)
         }
     }
-    fn is_affine(&self) -> bool {
-        match self.0.objtype() {
-            ObjType::Affine | ObjType::AffineDoubleSize => true,
-            _ => false,
-        }
-    }
     fn affine_index(&self) -> u32 {
         let attr1 = (self.1).0;
         ((attr1 >> 9) & 0x1f) as u32
     }
-    fn is_hidden(&self) -> bool {
+    fn is_obj_window(&self) -> bool {
-        self.0.objtype() == ObjType::Hidden
+        self.0.objmode() == ObjMode::Window
     }
 }
 
@@ -89,14 +83,14 @@ impl Gpu {
         ObjAttrs(attr0, attr1, attr2)
     }
 
-    fn render_affine_obj(&mut self, obj: ObjAttrs, _obj_num: usize) {
+    fn render_affine_obj(&mut self, attrs: ObjAttrs, _obj_num: usize) {
         let screen_y = self.vcount as i32;
 
-        let (ref_x, ref_y) = obj.coords();
+        let (ref_x, ref_y) = attrs.coords();
 
-        let (obj_w, obj_h) = obj.size();
+        let (obj_w, obj_h) = attrs.size();
 
-        let (bbox_w, bbox_h) = match obj.0.objtype() {
+        let (bbox_w, bbox_h) = match attrs.0.objtype() {
             ObjType::AffineDoubleSize => (2 * obj_w, 2 * obj_h),
             _ => (obj_w, obj_h),
         };
@@ -106,18 +100,18 @@ impl Gpu {
             return;
         }
 
-        let tile_base = self.obj_tile_base() + 0x20 * (obj.2.tile() as u32);
+        let tile_base = self.obj_tile_base() + 0x20 * (attrs.2.tile() as u32);
 
-        let (tile_size, pixel_format) = obj.tile_format();
+        let (tile_size, pixel_format) = attrs.tile_format();
         let palette_bank = match pixel_format {
-            PixelFormat::BPP4 => obj.2.palette(),
+            PixelFormat::BPP4 => attrs.2.palette(),
             _ => 0u32,
         };
 
         let tile_array_width = match self.dispcnt.obj_mapping() {
             ObjMapping::OneDimension => obj_w / 8,
             ObjMapping::TwoDimension => {
-                if obj.0.is_8bpp() {
+                if attrs.0.is_8bpp() {
                     16
                 } else {
                     32
@@ -125,7 +119,7 @@ impl Gpu {
             }
         };
 
-        let affine_matrix = self.get_affine_matrix(obj.affine_index());
+        let affine_matrix = self.get_affine_matrix(attrs.affine_index());
 
         let half_width = bbox_w / 2;
         let half_height = bbox_h / 2;
@@ -142,7 +136,8 @@ impl Gpu {
             if self
                 .obj_buffer_get(screen_x as usize, screen_y as usize)
                 .priority
-                <= obj.2.priority()
+                <= attrs.2.priority()
+                && !attrs.is_obj_window()
             {
                 continue;
             }
@@ -161,34 +156,36 @@ impl Gpu {
                     self.read_pixel_index(tile_addr, tile_x as u32, tile_y as u32, pixel_format);
                 let pixel_color =
                     self.get_palette_color(pixel_index as u32, palette_bank, PALRAM_OFS_FG);
-                self.write_obj_pixel(screen_x as usize, screen_y as usize, pixel_color, &obj);
+                if pixel_color != Rgb15::TRANSPARENT {
+                    self.write_obj_pixel(screen_x as usize, screen_y as usize, pixel_color, &attrs);
+                }
             }
         }
     }
 
-    fn render_normal_obj(&mut self, obj: ObjAttrs, _obj_num: usize) {
+    fn render_normal_obj(&mut self, attrs: ObjAttrs, _obj_num: usize) {
         let screen_y = self.vcount as i32;
 
-        let (ref_x, ref_y) = obj.coords();
+        let (ref_x, ref_y) = attrs.coords();
-        let (obj_w, obj_h) = obj.size();
+        let (obj_w, obj_h) = attrs.size();
 
         // skip this obj if not within its vertical bounds.
         if !(screen_y >= ref_y && screen_y < ref_y + obj_h) {
             return;
         }
 
-        let tile_base = self.obj_tile_base() + 0x20 * (obj.2.tile() as u32);
+        let tile_base = self.obj_tile_base() + 0x20 * (attrs.2.tile() as u32);
 
-        let (tile_size, pixel_format) = obj.tile_format();
+        let (tile_size, pixel_format) = attrs.tile_format();
         let palette_bank = match pixel_format {
-            PixelFormat::BPP4 => obj.2.palette(),
+            PixelFormat::BPP4 => attrs.2.palette(),
             _ => 0u32,
         };
 
         let tile_array_width = match self.dispcnt.obj_mapping() {
             ObjMapping::OneDimension => obj_w / 8,
             ObjMapping::TwoDimension => {
-                if obj.0.is_8bpp() {
+                if attrs.0.is_8bpp() {
                     16
                 } else {
                     32
@@ -209,18 +206,19 @@ impl Gpu {
             if self
                 .obj_buffer_get(screen_x as usize, screen_y as usize)
                 .priority
-                <= obj.2.priority()
+                <= attrs.2.priority()
+                && !attrs.is_obj_window()
             {
                 continue;
             }
             let mut sprite_y = screen_y - ref_y;
             let mut sprite_x = screen_x - ref_x;
-            sprite_y = if obj.1.v_flip() {
+            sprite_y = if attrs.1.v_flip() {
                 obj_h - sprite_y - 1
             } else {
                 sprite_y
             };
-            sprite_x = if obj.1.h_flip() {
+            sprite_x = if attrs.1.h_flip() {
                 obj_w - sprite_x - 1
             } else {
                 sprite_x
@@ -233,18 +231,20 @@ impl Gpu {
                 self.read_pixel_index(tile_addr, tile_x as u32, tile_y as u32, pixel_format);
             let pixel_color =
                 self.get_palette_color(pixel_index as u32, palette_bank, PALRAM_OFS_FG);
-            self.write_obj_pixel(screen_x as usize, screen_y as usize, pixel_color, &obj);
+            if pixel_color != Rgb15::TRANSPARENT {
+                self.write_obj_pixel(screen_x as usize, screen_y as usize, pixel_color, &attrs);
+            }
         }
     }
 
     fn write_obj_pixel(&mut self, x: usize, y: usize, pixel_color: Rgb15, attrs: &ObjAttrs) {
         let mut current_obj = self.obj_buffer_get_mut(x, y);
-        match attrs.0.objmode() {
+        let obj_mode = attrs.0.objmode();
+        match obj_mode {
             ObjMode::Normal | ObjMode::Sfx => {
-                if pixel_color != Rgb15::TRANSPARENT {
                 current_obj.color = pixel_color;
                 current_obj.priority = attrs.2.priority();
-                }
+                current_obj.alpha = obj_mode == ObjMode::Sfx;
             }
             ObjMode::Window => {
                 current_obj.window = true;

src/core/gpu/sfx.rs

@@ -1,9 +1,14 @@
 use std::cmp;
 
+use arrayvec::ArrayVec;
+use num::FromPrimitive;
+
 use super::regs::*;
+
+use super::layer::*;
 use super::*;
 
-#[derive(Debug, Primitive, Clone, Copy)]
+#[derive(Debug, Primitive, PartialEq, Clone, Copy)]
 pub enum BldMode {
     BldNone = 0b00,
     BldAlpha = 0b01,
@@ -32,159 +37,210 @@ impl From<WindowFlags> for BlendFlags {
     }
 }
 
-#[derive(Debug, Default)]
-struct Layer {
-    color: Rgb15,
-    blend_flag: BlendFlags,
-}
-
 impl Gpu {
-    fn get_top_layer(
+    /// returns a none sorted array of background indexes that are enabled
+    fn active_backgrounds_sorted(
         &self,
-        screen_x: usize,
+        bg_start: usize,
-        bflags: BlendFlags,
+        bg_end: usize,
-        wflags: WindowFlags,
+        window_flags: WindowFlags,
-    ) -> Option<Layer> {
+    ) -> ArrayVec<[usize; 4]> {
-        // priorities are 0-4 when 0 is the highest
+        let mut backgrounds = ArrayVec::<[usize; 4]>::new();
-        'outer: for priority in 0..4 {
+
-            let obj = self.obj_buffer_get(screen_x, self.vcount);
+        for bg in bg_start..=bg_end {
-            if bflags.contains(BlendFlags::OBJ)
+            if self.dispcnt.enable_bg(bg) && window_flags.bg_enabled(bg) {
-                && wflags.contains(WindowFlags::OBJ)
+                unsafe {
-                && !obj.color.is_transparent()
+                    backgrounds.push_unchecked(bg);
-                && obj.priority == priority
-            {
-                return Some(Layer {
-                    color: obj.color,
-                    blend_flag: BlendFlags::OBJ,
-                });
-            }
-            for bg in 0..4 {
-                let c = self.bg[bg].line[screen_x];
-                let bflag = BlendFlags::from_bg(bg);
-                if self.dispcnt.disp_bg(bg)
-                    && !c.is_transparent()
-                    && bflags.contains(bflag)
-                    && wflags.bg_enabled(bg)
-                    && self.bg[bg].bgcnt.priority() == priority
-                {
-                    return Some(Layer {
-                        color: c,
-                        blend_flag: bflag,
-                    });
                 }
             }
         }
-        let backdrop = self.palette_ram.read_16(0);
+        backgrounds.sort_by_key(|bg| (self.bg[*bg].bgcnt.priority(), *bg));
-        if bflags.contains(BlendFlags::BACKDROP) {
+
-            return Some(Layer {
+        backgrounds
-                color: Rgb15(backdrop),
-                blend_flag: BlendFlags::BACKDROP,
-            });
-        }
-        None
     }
 
-    fn get_active_window_type(&self, x: usize, y: usize) -> WindowType {
+    #[allow(unused)]
+    fn layer_to_pixel(&self, x: usize, y: usize, layer: &RenderLayer) -> Rgb15 {
+        match layer.kind {
+            RenderLayerKind::Background0 => self.bg[0].line[x],
+            RenderLayerKind::Background1 => self.bg[1].line[x],
+            RenderLayerKind::Background2 => self.bg[2].line[x],
+            RenderLayerKind::Background3 => self.bg[3].line[x],
+            RenderLayerKind::Objects => self.obj_buffer_get(x, y).color,
+            RenderLayerKind::Backdrop => Rgb15(self.palette_ram.read_16(0)),
+        }
+    }
+
+    /// Composes the render layers into a final scanline while applying needed special effects, and render it to the frame buffer
+    pub fn finalize_scanline(&mut self, bg_start: usize, bg_end: usize) {
+        let y = self.vcount;
+        let output = unsafe {
+            let ptr = self.frame_buffer[y * DISPLAY_WIDTH..].as_mut_ptr();
+            std::slice::from_raw_parts_mut(ptr, DISPLAY_WIDTH)
+        };
         if !self.dispcnt.is_using_windows() {
-            WindowType::WinNone
+            let win = WindowInfo::new(WindowType::WinNone, WindowFlags::all());
+            let backgrounds = self.active_backgrounds_sorted(bg_start, bg_end, win.flags);
+            for x in 0..DISPLAY_WIDTH {
+                let pixel = self.compose_pixel(x, y, &win, &backgrounds);
+                output[x] = pixel.to_rgb24();
+            }
         } else {
-            if self.dispcnt.disp_window0() && self.win0.inside(x, y) {
+            let mut occupied = [false; DISPLAY_WIDTH];
-                return WindowType::Win0;
+            let mut occupied_count = 0;
+            if self.dispcnt.enable_window0() && self.win0.contains_y(y) {
+                let win = WindowInfo::new(WindowType::Win0, self.win0.flags);
+                let backgrounds = self.active_backgrounds_sorted(bg_start, bg_end, win.flags);
+                for x in self.win0.left()..self.win0.right() {
+                    let pixel = self.compose_pixel(x, y, &win, &backgrounds);
+                    output[x] = pixel.to_rgb24();
+                    occupied[x] = true;
+                    occupied_count += 1;
+                }
+            }
+            if occupied_count == DISPLAY_WIDTH {
+                return;
+            }
+            if self.dispcnt.enable_window1() && self.win1.contains_y(y) {
+                let win = WindowInfo::new(WindowType::Win1, self.win1.flags);
+                let backgrounds = self.active_backgrounds_sorted(bg_start, bg_end, win.flags);
+                for x in self.win1.left()..self.win1.right() {
+                    if !occupied[x] {
+                        let pixel = self.compose_pixel(x, y, &win, &backgrounds);
+                        output[x] = pixel.to_rgb24();
+                        occupied[x] = true;
+                        occupied_count += 1;
+                    }
+                }
+            }
+            if occupied_count == DISPLAY_WIDTH {
+                return;
+            }
+            let win_out = WindowInfo::new(WindowType::WinOut, self.winout_flags);
+            let win_out_backgrounds =
+                self.active_backgrounds_sorted(bg_start, bg_end, win_out.flags);
+            if self.dispcnt.enable_obj_window() {
+                let win_obj = WindowInfo::new(WindowType::WinObj, self.winobj_flags);
+                let win_obj_backgrounds =
+                    self.active_backgrounds_sorted(bg_start, bg_end, win_obj.flags);
+                for x in 0..DISPLAY_WIDTH {
+                    if occupied[x] {
+                        continue;
+                    }
+                    let obj_entry = self.obj_buffer_get(x, y);
+                    if obj_entry.window {
+                        // WinObj
+                        let pixel = self.compose_pixel(x, y, &win_obj, &win_obj_backgrounds);
+                        output[x] = pixel.to_rgb24();
+                        occupied[x] = true;
+                        occupied_count += 1;
+                    } else {
+                        // WinOut
+                        let pixel = self.compose_pixel(x, y, &win_out, &win_out_backgrounds);
+                        output[x] = pixel.to_rgb24();
+                        occupied[x] = true;
+                        occupied_count += 1;
+                    }
+                }
+            } else {
+                for x in 0..DISPLAY_WIDTH {
+                    if occupied[x] {
+                        continue;
+                    }
+                    let pixel = self.compose_pixel(x, y, &win_out, &win_out_backgrounds);
+                    output[x] = pixel.to_rgb24();
+                    occupied[x] = true;
+                    occupied_count += 1;
                 }
-            if self.dispcnt.disp_window1() && self.win1.inside(x, y) {
-                return WindowType::Win1;
             }
-            // TODO win_obj
-            return WindowType::WinOut;
         }
     }
 
-    fn get_window_flags(&self, wintyp: WindowType) -> WindowFlags {
+    fn compose_pixel(&self, x: usize, y: usize, win: &WindowInfo, backgrounds: &[usize]) -> Rgb15 {
-        match wintyp {
+        let backdrop_color = Rgb15(self.palette_ram.read_16(0));
-            WindowType::Win0 => self.win0.flags,
+
-            WindowType::Win1 => self.win1.flags,
+        let mut layers = ArrayVec::<[_; 7]>::new();
-            WindowType::WinObj => self.winobj_flags,
+        unsafe {
-            WindowType::WinOut => self.winout_flags,
+            layers.push_unchecked(RenderLayer::backdrop(backdrop_color));
-            WindowType::WinNone => WindowFlags::all(),
+        }
+
+        for bg in backgrounds.into_iter() {
+            let bg_pixel = self.bg[*bg].line[x];
+            if !bg_pixel.is_transparent() {
+                unsafe {
+                    layers.push_unchecked(RenderLayer::background(
+                        *bg,
+                        bg_pixel,
+                        self.bg[*bg].bgcnt.priority(),
+                    ));
+                }
             }
         }
 
-    fn sfx_blend_alpha(&self, x: usize, _y: usize, wflags: WindowFlags) -> Option<Rgb15> {
+        let obj_entry = self.obj_buffer_get(x, y);
-        let top_layers = self.bldcnt.top();
+        if self.dispcnt.enable_obj() && win.flags.obj_enabled() && !obj_entry.color.is_transparent()
-        let bottom_layers = self.bldcnt.bottom();
+        {
-        if let Some(top_layer) = self.get_top_layer(x, top_layers, wflags) {
+            unsafe {
-            if let Some(bot_layer) = self.get_top_layer(x, bottom_layers, wflags) {
+                layers.push_unchecked(RenderLayer::objects(obj_entry.color, obj_entry.priority))
+            }
+        }
+
+        // now, sort the layers
+        layers.sort_by_key(|k| (k.priority, k.priority_by_type));
+
+        let top_pixel = layers[0].pixel; // self.layer_to_pixel(x, y, &layers[0]);
+        let mut result = top_pixel;
+        'blend: loop {
+            /* loop hack so we can leave this block early */
+            let obj_sfx = obj_entry.alpha && layers[0].is_object();
+            if win.flags.sfx_enabled() || obj_sfx {
+                let top_layer_flags = self.bldcnt.top();
+                let bot_layer_flags = self.bldcnt.bottom();
+
+                if !(top_layer_flags.contains_render_layer(&layers[0]) || obj_sfx) {
+                    break 'blend;
+                }
+                if layers.len() > 1 && !(bot_layer_flags.contains_render_layer(&layers[1])) {
+                    break 'blend;
+                }
+
+                let mut blend_mode = self.bldcnt.mode();
+
+                // push another backdrop layer in case there is only 1 layer
+                // unsafe { layers.push_unchecked(RenderLayer::backdrop(backdrop_color)); }
+                // if this is object alpha blending, ensure that the bottom layer contains a color to blend with
+                if obj_sfx && layers.len() > 1 && bot_layer_flags.contains_render_layer(&layers[1])
+                {
+                    blend_mode = BldMode::BldAlpha;
+                }
+
+                match blend_mode {
+                    BldMode::BldAlpha => {
+                        let bot_pixel = if layers.len() > 1 {
+                            layers[1].pixel //self.layer_to_pixel(x, y, &layers[1])
+                        } else {
+                            backdrop_color
+                        };
+
                         let eva = self.bldalpha.eva();
                         let evb = self.bldalpha.evb();
-                return Some(top_layer.color.blend_with(bot_layer.color, eva, evb));
+                        result = top_pixel.blend_with(bot_pixel, eva, evb);
-            } else {
-                return Some(top_layer.color);
-            }
-        }
-        None
-    }
-
-    fn sfx_blend_bw(
-        &self,
-        fadeto: Rgb15,
-        x: usize,
-        _y: usize,
-        wflags: WindowFlags,
-    ) -> Option<Rgb15> {
-        let top_layers = self.bldcnt.top();
-        let evy = self.bldy;
-
-        if let Some(layer) = self.get_top_layer(x, top_layers, wflags) {
-            return Some(layer.color.blend_with(fadeto, 16 - evy, evy));
-        }
-        None
-    }
-
-    pub fn composite_sfx_to_framebuffer(&mut self) {
-        let y = self.vcount;
-
-        for x in 0..DISPLAY_WIDTH {
-            let window = self.get_active_window_type(x, y);
-            let wflags = self.get_window_flags(window);
-            let toplayer = self.get_top_layer(x, BlendFlags::all(), wflags).unwrap();
-
-            let bldmode = if wflags.sfx_enabled() {
-                self.bldcnt.mode()
-            } else {
-                BldMode::BldNone
-            };
-
-            let pixel = match bldmode {
-                BldMode::BldAlpha => {
-                    if self.bldcnt.top().contains(toplayer.blend_flag)
-                        || self.bldcnt.bottom().contains(toplayer.blend_flag)
-                    {
-                        self.sfx_blend_alpha(x, y, wflags).unwrap_or(toplayer.color)
-                    } else {
-                        toplayer.color
-                    }
                     }
                     BldMode::BldWhite => {
-                    let result = if self.bldcnt.top().contains(toplayer.blend_flag) {
+                        let evy = self.bldy;
-                        self.sfx_blend_bw(Rgb15::WHITE, x, y, wflags)
+                        result = top_pixel.blend_with(Rgb15::WHITE, 16 - evy, evy);
-                            .unwrap_or(toplayer.color)
-                    } else {
-                        toplayer.color
-                    };
-                    result
                     }
                     BldMode::BldBlack => {
-                    let result = if self.bldcnt.top().contains(toplayer.blend_flag) {
+                        let evy = self.bldy;
-                        self.sfx_blend_bw(Rgb15::BLACK, x, y, wflags)
+                        result = top_pixel.blend_with(Rgb15::BLACK, 16 - evy, evy);
-                            .unwrap_or(toplayer.color)
+                    }
-                    } else {
+                    BldMode::BldNone => {
-                        toplayer.color
+                        result = top_pixel;
-                    };
+                    }
+                }
+            }
+            break 'blend;
+        }
         result
     }
-                BldMode::BldNone => toplayer.color,
-            };
-            self.render_pixel(x as i32, y as i32, pixel);
-        }
-    }
 }

src/core/gpu/window.rs

@@ -0,0 +1,79 @@
+use serde::{Deserialize, Serialize};
+
+use super::consts::*;
+use super::WindowFlags;
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct Window {
+    pub left: u8,
+    pub right: u8,
+    pub top: u8,
+    pub bottom: u8,
+    pub flags: WindowFlags,
+}
+
+impl Window {
+    pub fn inside(&self, x: usize, y: usize) -> bool {
+        let left = self.left();
+        let right = self.right();
+        self.contains_y(y) && (x >= left && x < right)
+    }
+
+    #[inline]
+    pub fn left(&self) -> usize {
+        self.left as usize
+    }
+
+    #[inline]
+    pub fn right(&self) -> usize {
+        let left = self.left as usize;
+        let mut right = self.right as usize;
+        if right > DISPLAY_WIDTH || right < left {
+            right = DISPLAY_WIDTH;
+        }
+        right
+    }
+
+    #[inline]
+    pub fn top(&self) -> usize {
+        self.top as usize
+    }
+
+    #[inline]
+    pub fn bottom(&self) -> usize {
+        let top = self.top as usize;
+        let mut bottom = self.bottom as usize;
+        if bottom > DISPLAY_HEIGHT || bottom < top {
+            bottom = DISPLAY_HEIGHT;
+        }
+        bottom
+    }
+
+    #[inline]
+    pub fn contains_y(&self, y: usize) -> bool {
+        let top = self.top();
+        let bottom = self.bottom();
+        (y >= top && y < bottom)
+    }
+}
+
+#[derive(Debug, PartialEq, Copy, Clone)]
+pub enum WindowType {
+    Win0,
+    Win1,
+    WinObj,
+    WinOut,
+    WinNone,
+}
+
+#[derive(Debug)]
+pub struct WindowInfo {
+    pub typ: WindowType,
+    pub flags: WindowFlags,
+}
+
+impl WindowInfo {
+    pub fn new(typ: WindowType, flags: WindowFlags) -> WindowInfo {
+        WindowInfo { typ, flags }
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
+#![warn(unused_extern_crates)]
 #![feature(asm)]
 #![feature(core_intrinsics)]
 #![feature(exclusive_range_pattern)]