more video work

diff --git a/GBMemory.cc b/GBMemory.cc
index e5015be8d548c915d81d6dcdce519380e6b65aab..a081d06bab5ee82a125eb7ff20ab6be92a34b5eb 100644 (file)
--- a/GBMemory.cc
+++ b/GBMemory.cc
@@ -34,8 +34,8 @@ void GBMemory::write(int addr, u8 value)
                std::ostringstream errmsg;
                errmsg << "Invalid write address 0x" << 
                        std::hex << std::setw(4) << std::setfill('0') << addr;
-               logger.error(errmsg.str());
-               std::cout << *(static_cast<u8*>(0));
+               logger.debug(errmsg.str());
+               //std::cout << *(static_cast<u8*>(0));
        }
 }
 

diff --git a/GBVideo.cc b/GBVideo.cc
index 86521decb91fe3198fe8a10f2aa6586acd6d0341..5e935665f24c2ef9031932d5f6c1acc8919aacd9 100644 (file)
--- a/GBVideo.cc
+++ b/GBVideo.cc
@@ -1,10 +1,13 @@
 #include "GBVideo.h"
 #include "gbcore.h"
 #include "util.h"
+#include <iostream>
+
 
 GBVideo::GBVideo(GameBoy *core):
        display(0),
-       core(core)
+       core(core),
+       frames_rendered(0)
 {
        SDL_Init(SDL_INIT_VIDEO);
        display=SDL_SetVideoMode(160,144,32,SDL_SWSURFACE);
@@ -22,7 +25,7 @@ GBVideo::~GBVideo()
 
 u8   GBVideo::read_VRAM (int addr) const
 {
-       int STAT = memory.read(GBIO::STAT);
+       int STAT = core->memory.read(GBIO::STAT);
        if ((STAT & 3) == 3)
                return 0xFF; // VRAM access disabled
        else
@@ -31,7 +34,7 @@ u8   GBVideo::read_VRAM (int addr) const
 
 u8   GBVideo::read_OAM  (int addr) const
 {
-       int STAT = memory.read(GBIO::STAT);
+       int STAT = core->memory.read(GBIO::STAT);
        if ((STAT & 3) >= 2)
                return 0xFF; // OAM access disabled
        else
@@ -40,7 +43,7 @@ u8   GBVideo::read_OAM  (int addr) const
 
 void GBVideo::write_VRAM(int addr, u8 value)
 {
-       int STAT = memory.read(GBIO::STAT);
+       int STAT = core->memory.read(GBIO::STAT);
        if ((STAT & 3) == 3)
                return; // VRAM access disabled
        else
@@ -49,7 +52,7 @@ void GBVideo::write_VRAM(int addr, u8 value)
 
 void GBVideo::write_OAM (int addr, u8 value)
 {
-       int STAT = memory.read(GBIO::STAT);
+       int STAT = core->memory.read(GBIO::STAT);
        if ((STAT & 3) >= 2)
                return; // OAM access disabled
        else
@@ -74,24 +77,36 @@ void GBVideo::update()
        // mode 0 starts at 252, 708, 1164...
        // vblank starts at 65664
 
+       u32 *pixels = static_cast<u32*>(display->pixels);
+       u32 pixels_per_line = display->pitch/display->format->BytesPerPixel;
+
        int STAT = core->memory.read(GBIO::STAT);
        int LYC  = core->memory.read(GBIO::LYC);
-       int LY   = core->memory.read(GBIO::LY);
 
        int t = core->cycle_count % 70224;
-       
-       if (t >= 65665)
+       int hline_t=-1;
+       int     LY = t/456;
+       //std::cout << t << std::endl;
+
+       if (t >= 65664)
        {
-               if (t == 65665 && check_bit(STAT,4))
-                       core->irq(GameBoy::IRQ_VBLANK);
+               if (t == 65664)
+               {
+                       if (check_bit(STAT,4))
+                               core->irq(GameBoy::IRQ_VBLANK);
+                       SDL_UpdateRect(display, 0, 0, 0, 0);
+                       frames_rendered++;
+                       char buf[50];
+                       sprintf(buf, "%d", frames_rendered);
+                       SDL_WM_SetCaption(buf, 0);
+               }
 
                // preserve bits 3-6, set mode to 1 (VBlank) and coincidence to 0
                STAT = (STAT&0xF8) | 1;
        }
        else
        {
-               LY = t/456;
-               int hline_t = t%456;
+               hline_t = t%456;
                if (LY == LYC)
                {
                        STAT = set_bit(STAT, 2); // set coincidence flag
@@ -126,6 +141,58 @@ void GBVideo::update()
        core->memory.write(GBIO::STAT, STAT);
 
        // Draw the background
-       
+       // Draw at hline_t == 80, when the app cannot write to neither VRAM nor OAM
+       if (hline_t == 80)
+       {
+               int LCDC = core->memory.read(GBIO::LCDC);
+               int BGP  = core->memory.read(GBIO::BGP);
+               int pallette[4];
+               pallette[0] = BGP & 3;
+               pallette[1] = (BGP>>2) & 3;
+               pallette[2] = (BGP>>4) & 3;
+               pallette[3] = (BGP>>6) & 3;
+               
+               if (check_bit(LCDC, 0))  // is BG display active?
+               {
+                       u16 tile_map_addr  = check_bit(LCDC,3) ? 0x1C00  : 0x1800;
+                       u16 tile_data_addr = check_bit(LCDC,4) ? 0x0800 : 0x0000;
+                       int tile_data_base = (tile_data_addr == 0x0800) ? -128 : 127;
+
+                       // (vx    , vy    ) -> position of the pixel in the 256x256 bg
+                       // (map_x , map_y ) -> map coordinates of the current tile
+                       // (tile_x, tile_y) -> position of the pixel in the tile
+                       int SCX = core->memory.read(GBIO::SCX);
+                       int SCY = core->memory.read(GBIO::SCY);
+                       int vy = (LY + SCY) % 256;
+                       int map_y = vy / 8;
+                       int tile_y = vy % 8;
+                       for (int x=0; x<160; x++)
+                       {
+                               int vx = (x+SCX) % 256;
+                               int map_x = vx/8;
+                               int tile_x = 7-(vx%8);
+                               u8 current_tile_index = VRAM[tile_map_addr+ 32*map_y + map_x] + tile_data_base;
+                               u16 current_tile_addr = tile_data_addr + 16*current_tile_index;
+                               u8 current_row_low = VRAM[current_tile_addr+2*tile_y];
+                               u8 current_row_high = VRAM[current_tile_addr+2*tile_y+1];
+                               u8 color = ((current_row_high >> tile_x)&1) << 1 | 
+                                                       ((current_row_low >> tile_x)&1);
+
+                               pixels[LY*pixels_per_line+x] = colors[pallette[color]];
+                       }
+               }
+               else
+               {
+                       for (int x=0; x<160; x++)
+                               pixels[LY*pixels_per_line+x] = colors[0];
+               }
 
+       }
+}
+
+
+int GBVideo::poll_event(SDL_Event *ev)
+{
+       return SDL_PollEvent(ev);
 }
+

diff --git a/GBVideo.h b/GBVideo.h
index 63c8d7599818af8f7867ab00c0491dc01f8c4966..ea06bb194409fccfb889aa275d30a5a34e48dff9 100644 (file)
--- a/GBVideo.h
+++ b/GBVideo.h
@@ -15,11 +15,12 @@ class GBVideo
        u8 OAM[160];
 
        u32 colors[4];
+       u32 frames_rendered;
 
+       
        public:
-       static const u16 VRAM_BASE = 0x8000;
-       static const u16 OAM_BASE  = 0xFE00;
-
+       static const u16 VRAM_BASE  = 0x8000;
+       static const u16 OAM_BASE   = 0xFE00;
 
        GBVideo(GameBoy *core);
        ~GBVideo();
@@ -31,7 +32,13 @@ class GBVideo
        void write_OAM (int addr, u8 value);
 
        // drawing control
-       void update();  
+       void update();
+
+       // event processing
+       int poll_event(SDL_Event *ev);
+       
+       // status queries
+       u32 get_frames_rendered() { return frames_rendered; }
        
        // prevent object copying
        private:

diff --git a/MBC.cc b/MBC.cc
index 6b49b4528f56464a1707f3174eaa1daf183523a8..164617a727616c751df23a321555d45e97c863ca 100644 (file)
--- a/MBC.cc
+++ b/MBC.cc
@@ -41,8 +41,7 @@ void NoMBC::write(int addr, u8 value)
        {
                std::ostringstream errmsg;
                errmsg <<"NoMBC: trying to write in ROM, addr=0x"<<std::hex<<addr;
-               logger.error(errmsg.str());
-               std::cout << *(static_cast<u8*>(0)); // Shouldn't happen
+               logger.debug(errmsg.str());
        }
 }
 

diff --git a/Makefile b/Makefile
index 927c58843cf20ebc21fec7aa1e37f540e6e14047..e26486330062c82b94728233f414cfa5789eeb9a 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-CXXFLAGS=-g -Wall -Weffc++ -Wstrict-null-sentinel -Wold-style-cast \
+CXXFLAGS=-O2 -g -Wall -Weffc++ -Wstrict-null-sentinel -Wold-style-cast \
         -Woverloaded-virtual $(shell sdl-config --cflags)
 LDFLAGS=-g $(shell sdl-config --libs)
 

diff --git a/gbcore.cc b/gbcore.cc
index be0f451ad820ebe2fdcd618785566886f939295b..1dce04d59ef5c0911ed855f5f6be0e1a0e1a0e8a 100644 (file)
--- a/gbcore.cc
+++ b/gbcore.cc
@@ -942,15 +942,28 @@ GameBoy::run_status GameBoy::run_cycle()
        } // end switch
 
        ++cycle_count;
+       //std::cout << "cycle_count " << cycle_count << std::endl;
 
        return NORMAL;
 }
 
 GameBoy::run_status GameBoy::run() 
 {
+       SDL_Event ev;
+
        run_status status=NORMAL;
        while (status == NORMAL)
        {
+               while (video.poll_event(&ev))
+               {
+                       if (ev.type == SDL_KEYDOWN)
+                       {
+                               if (ev.key.keysym.sym == SDLK_ESCAPE)
+                               {
+                                       return PAUSED;
+                               }
+                       }
+               }
                status = run_cycle();
        }
        

diff --git a/gbcore.h b/gbcore.h
index 23829ad940e3015082d53b5ecc4f8e364b651ae5..48543aedf326180e0cc30187b082220028d2e682 100644 (file)
--- a/gbcore.h
+++ b/gbcore.h
@@ -88,6 +88,7 @@ class GameBoy
                BREAKPOINT = 1,
                WATCHPOINT = 2,
                TRACEPOINT = 3,
+               PAUSED = 4,
        };
 
        // Constructors

diff --git a/tests/test_core.cc b/tests/test_core.cc
index 9825de903deb9cf38900ba63689faced3ba773ec..b6ef4c3d79062fb39719549bfc5bf5320b2f9874 100644 (file)
--- a/tests/test_core.cc
+++ b/tests/test_core.cc
@@ -49,11 +49,12 @@ int main(int argc, char **argv)
                        gb.run_cycle();
                        cout << gb.status_string() << endl;
                }
-               else if (command == "run") 
+               else if (command == "run" || command == "r") 
                {
-                       gb.run();
+                       int status = gb.run();
+                       cout << "run returned with status " << status << endl;
                }
-               else if (command == "quit")
+               else if (command == "quit" || command == "q")
                {
                        break;
                }

diff --git a/util.h b/util.h
index 65a551f948b4b86ccf0c2b53d047caff975d13b7..31c45d16933aac23bf39564fa96ff1c24158ae52 100644 (file)
--- a/util.h
+++ b/util.h
@@ -3,25 +3,25 @@
 
 #include "sized_types.h"
 
-uint32 set_bit(uint32 pos, uint32 val)
+uint32 set_bit(uint32 val, uint32 pos)
 {
        uint32 mask = 1<<pos;
        return val | mask;
 }
 
-uint32 reset_bit(uint32 pos, uint32 val)
+uint32 reset_bit(uint32 val, uint32 pos)
 {
        uint32 mask = ~(1<<pos);
        return val & mask;
 }
 
-uint32 flip_bit(uint32 pos, uint32 val)
+uint32 flip_bit(uint32 val, uint32 pos)
 {
        uint32 mask = 1<<pos;
        return val ^ mask;
 }
 
-bool check_bit(uint32 pos, uint32 val)
+bool check_bit(uint32 val, uint32 pos)
 {
        uint32 mask = 1<<pos;
        return ((val&mask) != 0);