amaterasu 0.6.0

data/lib/amaterasu/game_boy/ppu/modes/rendering/pixel_emitter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      module Modes
+        class Rendering
+          # Responsible for emitting pixels from the Pixel FIFO to the Display.
+          class PixelEmitter
+            PIXELS_PER_SCANLINE = 160
+
+            def initialize(ppu, bg_win_fifo, sprite_fifo)
+              @ppu = ppu
+              @bg_win_fifo = bg_win_fifo
+              @sprite_fifo = sprite_fifo
+
+              @pixels_discarded = 0
+              @pixels_emitted = 0
+            end
+
+            # Called each T-cycle.
+            def tick?
+              return false if @bg_win_fifo.empty?
+              return false unless @pixels_emitted < PIXELS_PER_SCANLINE
+
+              @popped_sprite_pixel = @sprite_fifo.pop_pixel
+              @popped_bg_win_pixel = @bg_win_fifo.pop_pixel
+
+              shaded_priority_pixel = define_pixel_priority
+
+              # TODO: Implement framebuffer fixed size [lcd_y * width + lcd_x]
+              @ppu.framebuffer << shaded_priority_pixel
+              @pixels_emitted += 1
+
+              true
+            end
+
+            def reset_for_scanline
+              @pixels_emitted = 0
+              @pixels_discarded = 0
+            end
+
+            def to_s
+              "BG WIN FIFO: #{@bg_win_fifo.pixels} | " \
+                "Popped: #{@popped_pixel} (##{format('%d', @pixels_discarded)})"
+            end
+
+            private
+
+            def define_pixel_priority
+              return shaded_sprite_pixel if show_sprite?
+
+              shaded_bg_pixel
+            end
+
+            def show_sprite?
+              return false unless @ppu.registers.lcdc.obj_enabled?
+              return false if @popped_sprite_pixel.nil?
+              return false if (@popped_sprite_pixel & 0b11) == 0b00
+              return false if ((@popped_sprite_pixel & 0b1000) != 0) && (@popped_bg_win_pixel != 0b00)
+
+              true
+            end
+
+            def shaded_sprite_pixel
+              if (@popped_sprite_pixel & 0b100) == 0
+                @ppu.registers.sprite_palettes0[@popped_sprite_pixel & 0b11]
+              else
+                @ppu.registers.sprite_palettes1[@popped_sprite_pixel & 0b11]
+              end
+            end
+
+            def shaded_bg_pixel
+              return 0b00 unless @ppu.registers.lcdc.bg_win_enabled?
+
+              @ppu.registers.bg_palettes[@popped_bg_win_pixel]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/modes/rendering/pixel_fifo.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      module Modes
+        class Rendering
+          # Models the PPU Pixel FIFO from the original Game Boy (DMG).
+          class PixelFifo
+            MAX_PIXELS = 16 # or 8?
+
+            # Array of raw color indices (0 - 3).
+            attr_reader :pixels
+
+            def initialize
+              @pixel_buffer = Array.new
+            end
+
+            # The Pixel Fetcher is the pixel producer,
+            # it produces 8 color indices (1 for each pixel) and attempts
+            # to push all 8 at the same time until it succeeds.
+            #
+            # It will only succeed if the FIFO is empty.
+            #
+            # @return [Boolean] If the push was successful or not.
+            def push?(pushed_pixels)
+              return false unless @pixel_buffer.empty?
+
+              pushed_pixels.each { |pp| @pixel_buffer << pp }
+
+              true
+            end
+
+            # This is specific for Sprites.
+            #
+            def merge(sprite_pixels)
+              idx = 0
+
+              while idx <= 7
+                transparent = (@pixel_buffer[idx] & 0b11) == 0b00
+                @pixel_buffer[idx] = sprite_pixels[idx] if transparent || @pixel_buffer[idx].nil?
+                idx += 1
+              end
+            end
+
+            # To follow the FIFO rules, elements need to be popped
+            # from left to right, that is why we need to use Array#shift.
+            #
+            # @return [Integer] 2 bit number representing the color id of the pixel.
+            def pop_pixel
+              return if @pixel_buffer.empty?
+
+              @pixel_buffer.shift
+            end
+
+            # Removes all current elements of the FIFO.
+            def clear
+              @pixel_buffer.clear
+            end
+
+            # Removes all current elements of the FIFO.
+            def empty?
+              @pixel_buffer.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/modes/rendering/sprite_fetcher.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      module Modes
+        class Rendering
+          # Responsible for fetching Sprites tiles, decoding Sprite pixels
+          # and outputting them into the Sprite FIFO.
+          class SpriteFetcher
+            SpritePixel = Struct.new(:bg_win_priority_set, :use_obp1_palette, :color_id)
+
+            BIT_MASK_BG_WIN_PRIORITY_SET = 1 << 3
+            BIT_MASK_USE_OBP1_PALETTE    = 1 << 2
+
+            def initialize(ppu, sprite_fifo)
+              @ppu = ppu
+              @sprite_fifo = sprite_fifo
+
+              @step = :fetch_tile_index
+              @completed = false
+              @fetch_duration = 6
+
+              @current_sprite = nil
+
+              @tile_index     = nil
+              @tile_data_low  = nil
+              @tile_data_high = nil
+              @tile_pixels    = nil
+              @encoded_pixels = Array.new(8)
+            end
+
+            def start_for(sprite)
+              @current_sprite = sprite
+              @step = :fetch_tile_index
+              @completed = false
+              @fetch_duration = 6
+            end
+
+            # Core fetch state machine (Takes 2 dots per step).
+            #
+            def tick
+              case @step
+              when :fetch_tile_index     then fetch_tile_index
+              when :fetch_tile_data_low  then fetch_tile_data_low
+              when :fetch_tile_data_high then fetch_tile_data_high
+              end
+            end
+
+            def done?
+              @completed
+            end
+
+            private
+
+            # Fetches the Tile index of the current Sprite to be rendered.
+            def fetch_tile_index
+              @fetch_duration -= 1
+              return unless @fetch_duration == 4
+
+              obj_size_8x16 = @ppu.registers.lcdc.obj_size_8x16?
+              y_flipped = @current_sprite.y_flipped?
+
+              @tile_index = @current_sprite.tile_index(obj_size_8x16, y_flipped, current_obj_y)
+              @step = :fetch_tile_data_low
+            end
+
+            # Fetches the low byte from the Tile Row overlapping the current LY.
+            def fetch_tile_data_low
+              @fetch_duration -= 1
+              return unless @fetch_duration == 2
+
+              obj_y = @current_sprite.y_flipped? ? (7 - current_obj_y) : current_obj_y
+              @tile_data_low = obj_tile_data.tile_at(@tile_index).data_low(obj_y)
+              @step = :fetch_tile_data_high
+            end
+
+            # Fetches the high byte from the Tile Row overlapping the current LY.
+            def fetch_tile_data_high
+              @fetch_duration -= 1
+              return unless @fetch_duration == 0
+
+              obj_y = @current_sprite.y_flipped? ? (7 - current_obj_y) : current_obj_y
+              @tile_data_high = obj_tile_data.tile_at(@tile_index).data_high(obj_y)
+              fetch_tile_pixels
+              add_pixel_metadata
+              merge_into_fifo
+            end
+
+            # @return [Array] Decodes 8 pixel color ids from the high | low bytes.
+            def fetch_tile_pixels
+              @tile_pixels = Vram::Tile::PIXELS_LOOKUP[(@tile_data_high << 8) | @tile_data_low]
+            end
+
+            # Encodes the current OBP color palette and BG/WIN priority into the pixel.
+            # This data would be lost downstream (when rendering the pixels to the LCD)
+            # if not encoded in this step.
+            #
+            # @return [void]
+            def add_pixel_metadata
+              idx = 0
+
+              while idx < 8
+                pixel = @tile_pixels[idx]
+                pixel = BIT_MASK_BG_WIN_PRIORITY_SET | pixel if @current_sprite.bg_win_priority_set?
+                pixel = BIT_MASK_USE_OBP1_PALETTE | pixel if @current_sprite.use_obp1_palette?
+                @encoded_pixels[idx] = pixel
+
+                idx += 1
+              end
+            end
+
+            # Merges the 8 pixels into the Sprite FIFO.
+            def merge_into_fifo
+              @encoded_pixels.reverse! if @current_sprite.x_flipped?
+              @sprite_fifo.merge(@encoded_pixels)
+              @completed = true
+            end
+
+            def current_obj_y
+              @ppu.registers.ly - @current_sprite.y_screen_pos
+            end
+
+            def obj_tile_data
+              @ppu.obj_tile_data
+            end
+
+            def to_s
+              "Step: #{format('%-10s', @action)} | " \
+                "IDX: #{@tile_index.nil? ? 'Nil' : format('%02X', @tile_index)} | " \
+                "DL: #{@tile_data_low.nil? ? 'Nil' : format('%02X', @tile_data_low)} | " \
+                "DH: #{@tile_data_high.nil? ? 'Nil' : format('%02X', @tile_data_high)} | " \
+                "PIX: #{@tile_pixels}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/modes/rendering.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      module Modes
+        # Defines the behavior of the PPU during Rendering mode.
+        #
+        # The Rendering mode does not have a fixed duration,
+        # it can vary between 172 and 289 dots.
+        #
+        # This mode can be considered completed when 160 pixels
+        # are outputted to the LCD. Normally, the PPU can output
+        # a pixel per dot, but this is not always the case, there are
+        # several scenarios in which "penalties" occur and this
+        # causes the mode to take longer.
+        class Rendering
+          attr_reader :name, :number
+
+          def initialize(ppu)
+            @ppu = ppu
+
+            @name = 'RENDERING'
+            @number = 3
+
+            @bg_win_fifo    = PixelFifo.new
+            @sprite_fifo    = PixelFifo.new
+            @bg_win_fetcher = BgWinFetcher.new(ppu, @bg_win_fifo)
+            @sprite_fetcher = SpriteFetcher.new(ppu, @sprite_fifo)
+            @pixel_emitter  = PixelEmitter.new(ppu, @bg_win_fifo, @sprite_fifo)
+
+            @sprite_found = nil
+            @mode = :fetch_bg
+            @lcd_x = 0
+          end
+
+          def tick
+            if any_sprites? && @mode != :fetch_sprite
+              @mode = :fetch_sprite
+              @sprite_found = @ppu.sprite_buffer.shift
+              @sprite_fetcher.start_for(@sprite_found) unless sprite_offscreen?(@sprite_found)
+            elsif @mode == :fetch_sprite
+              @sprite_fetcher.tick
+              @mode = :fetch_bg if @sprite_fetcher.done?
+            else
+              @bg_win_fetcher.activate_window! if window_reached?
+
+              @bg_win_fetcher.tick
+              pixel_drawn = @pixel_emitter.tick?
+            end
+
+            @lcd_x += 1 if pixel_drawn
+            return unless @lcd_x == PIXELS_PER_SCANLINE && @bg_win_fetcher.step == :sleep
+
+            @bg_win_fetcher.reset_for_scanline
+            @pixel_emitter.reset_for_scanline
+            @lcd_x = 0
+            @sprite_fifo.clear
+            @bg_win_fifo.clear
+            @ppu.set_mode(:h_blank)
+          end
+
+          def inspect
+            '#<Amaterasu::GameBoy::Ppu::Modes::Rendering ' \
+              "@name='#{@name}' " \
+              "@number=#{@number} "
+          end
+
+          def to_s
+            if @mode == :fetch_bg
+              "#{@name} (##{@number}) | " \
+                "LCD X: #{@lcd_x} | " \
+                "#{@bg_win_fetcher} | " \
+                "#{@pixel_emitter}"
+            else
+              "#{@name} (##{@number}) | " \
+                "LCD X: #{@lcd_x} | " \
+                "Sprite: #{@sprite_fetcher}"
+            end
+          end
+
+          private
+
+          def any_sprites?
+            return false if @ppu.sprite_buffer.empty?
+            return false unless @ppu.registers.lcdc.obj_enabled?
+            return false unless @lcd_x >= @ppu.sprite_buffer.first.x_screen_pos
+
+            true
+          end
+
+          def sprite_offscreen?(sprite)
+            sprite.x < 0 || sprite.x >= 168 # @lcd_x stops at 160
+          end
+
+          def window_reached?
+            return false if @bg_win_fetcher.fetch_mode == :window
+            return false unless @ppu.wy_eq_ly
+            return false unless @ppu.registers.lcdc.window_enabled?
+            return false unless @lcd_x == @ppu.registers.wx - 7
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/modes/v_blank.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      module Modes
+        # Defines the behavior of the Ppu during VBlank mode.
+        class VBlank
+          attr_reader :name, :number
+
+          def initialize(ppu)
+            @ppu = ppu
+
+            @name = 'VBLANK'
+            @number = 1
+          end
+
+          def tick
+            return unless @ppu.dots == DOTS_PER_SCANLINE
+
+            @ppu.reset_for_scanline
+            @ppu.increment_ly
+            return unless @ppu.registers.ly == TOTAL_SCANLINES
+
+            @ppu.draw_frame
+            @ppu.reset_states
+            @ppu.set_mode(:oam_scan)
+          end
+
+          def inspect
+            '#<Amaterasu::GameBoy::Ppu::Modes::VBlank ' \
+              "@name='#{@name}' " \
+              "@number=#{@number} "
+          end
+
+          def to_s
+            "#{@name} (##{@number}) | WAITING UNTIL THE FRAME IS COMPLETED"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/modes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      # Instantiates the PPU mode objects that are going to be used.
+      module Modes
+        def self.build_hash(ppu)
+          @modes = Hash.new
+
+          @modes[:disabled]  = Disabled.new(ppu)
+          @modes[:h_blank]   = HBlank.new(ppu)
+          @modes[:v_blank]   = VBlank.new(ppu)
+          @modes[:oam_scan]  = OamScan.new(ppu)
+          @modes[:rendering] = Rendering.new(ppu)
+
+          @modes.freeze
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/registers/lcd_control.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      class Registers
+        # Models the behavior of the LCD Control PPU Register.
+        class LcdControl
+          BIT_MASK_LCD_ENABLE      = 1 << 7
+          BIT_MASK_WINDOW_TILE_MAP = 1 << 6
+          BIT_MASK_WINDOW_ENABLE   = 1 << 5
+          BIT_MASK_BG_WINDOW_TILES = 1 << 4
+          BIT_MASK_BG_TILE_MAP     = 1 << 3
+          BIT_MASK_OBJ_SIZE        = 1 << 2
+          BIT_MASK_OBJ_ENABLE      = 1 << 1
+          BIT_MASK_BG_WIN_ENABLED  = 1 << 0
+
+          attr_reader :value
+
+          def initialize(skip_boot_rom:)
+            @value = skip_boot_rom ? 0x91 : 0x00
+
+            update_derived_states
+          end
+
+          # @param value [Integer] 8-bit value written into 0xFF40.
+          def value=(value)
+            @value = value & 0xFF
+
+            update_derived_states
+          end
+
+          # Computes new state and caches the value on the Register write.
+          def update_derived_states
+            @lcd_enabled          = (@value & BIT_MASK_LCD_ENABLE) != 0
+            @window_tile_map_high = (@value & BIT_MASK_WINDOW_TILE_MAP) != 0
+            @window_enabled       = (@value & BIT_MASK_WINDOW_ENABLE) != 0
+            @tile_data_at_0x8000  = (@value & BIT_MASK_BG_WINDOW_TILES) != 0
+            @bg_tile_map_high     = (@value & BIT_MASK_BG_TILE_MAP) != 0
+            @obj_size_8x16        = (@value & BIT_MASK_OBJ_SIZE) != 0
+            @obj_enabled          = (@value & BIT_MASK_OBJ_ENABLE) != 0
+            @bg_win_enabled       = (@value & BIT_MASK_BG_WIN_ENABLED) != 0
+          end
+
+          def lcd_enabled?          = @lcd_enabled
+          def window_tile_map_high? = @window_tile_map_high
+          def window_enabled?       = @window_enabled
+          def tile_data_at_0x8000?  = @tile_data_at_0x8000
+          def bg_tile_map_high?     = @bg_tile_map_high
+          def obj_size_8x16?        = @obj_size_8x16
+          def obj_enabled?          = @obj_enabled
+          def bg_win_enabled?       = @bg_win_enabled
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/ppu/registers/lcd_status.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Ppu
+      class Registers
+        # Models the behavior of the LCD Status PPU Register.
+        class LcdStatus
+          BIT_MASK_WRITABLE_BITS = 0b01111000
+
+          BIT_MASK_LYC_INTERRUPT_SELECT    = 1 << 6
+          BIT_MASK_MODE_2_INTERRUPT_SELECT = 1 << 5
+          BIT_MASK_MODE_1_INTERRUPT_SELECT = 1 << 4
+          BIT_MASK_MODE_0_INTERRUPT_SELECT = 1 << 3
+
+          attr_reader :value, :interrupt_line_cache
+
+          def initialize(interrupts, skip_boot_rom:)
+            @interrupts = interrupts
+            @value = skip_boot_rom ? 0x85 : 0x00
+
+            @interrupt_line_cache = interrupt_line_signal
+          end
+
+          def value=(value)
+            @interrupt_line_cache = interrupt_line_signal
+            @value |= value & BIT_MASK_WRITABLE_BITS
+
+            fire_stat_interrupt if rising_edge?
+          end
+
+          # @param ppu_mode [Integer] 2-bit value.
+          def set_mode_bits(ppu_mode)
+            @interrupt_line_cache = interrupt_line_signal
+            @value = (@value & 0b11111100) | ppu_mode
+
+            fire_stat_interrupt if rising_edge?
+          end
+
+          def set_lyc_bit
+            @interrupt_line_cache = interrupt_line_signal
+            @value |= 0b100
+
+            fire_stat_interrupt if rising_edge?
+          end
+
+          def clear_lyc_bit
+            @interrupt_line_cache = interrupt_line_signal
+            @value &= 0xFB
+
+            fire_stat_interrupt if rising_edge?
+          end
+
+          def lyc_interrupt_selected?
+            (@value & BIT_MASK_LYC_INTERRUPT_SELECT) != 0
+          end
+
+          def mode_2_interrupt_selected?
+            (@value & BIT_MASK_MODE_2_INTERRUPT_SELECT) != 0
+          end
+
+          def mode_1_interrupt_selected?
+            (@value & BIT_MASK_MODE_1_INTERRUPT_SELECT) != 0
+          end
+
+          def mode_0_interrupt_selected?
+            (@value & BIT_MASK_MODE_0_INTERRUPT_SELECT) != 0
+          end
+
+          def interrupt_line_signal
+            (@value[6] == 1 && @value[2] == 1) ||
+              (@value[5] == 1 && (@value & 0b11) == 0b10) ||
+              (@value[4] == 1 && (@value & 0b11) == 0b01) ||
+              (@value[3] == 1 && (@value & 0b11) == 0b00)
+          end
+
+          def rising_edge?
+            @interrupt_line_cache == false && interrupt_line_signal == true
+          end
+
+          def fire_stat_interrupt
+            @interrupts.request(:lcd_stat)
+          end
+        end
+      end
+    end
+  end
+end