GBHawk: bug fixes and ppu viewer working

BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk_new/GBHawkNew.cs

@@ -135,7 +135,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawkNew
 
 		public void SetScanlineCallback(ScanlineCallback callback, int line)
 		{
-			if ((callback == null) || (line == -1) || (line == -2))
+			if ((callback == null) || (line == -2))
 			{
 				_scanlineCallback = null;
 				LibGBHawk.GB_setscanlinecallback(GB_Pntr, null, 0);
@@ -151,7 +151,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawkNew
 
 			if (line == -2)
 			{
-				GetGPU();
 				callback(LibGBHawk.GB_get_LCDC(GB_Pntr));
 			}
 		}

libHawk/GBHawk/GBHawk/Core.h

@@ -201,6 +201,11 @@ namespace GBHawk
 
 					// send the image on VBlank
 					SendVideoBuffer();
+
+					if ((ppu->scanlineCallback) && (MemMap._scanlineCallbackLine == -1))
+					{
+						ppu->scanlineCallback();
+					}
 				}
 
 				MemMap.REG_FF0F_OLD = MemMap.REG_FF0F;
@@ -457,18 +462,23 @@ namespace GBHawk
 			{
 			case 1:
 				MemMap.Cart_RAM = new uint8_t[0x800];
+				MemMap.Cart_RAM_Length = 0x800;
 				break;
 			case 2:
 				MemMap.Cart_RAM = new uint8_t[0x2000];
+				MemMap.Cart_RAM_Length = 0x2000;
 				break;
 			case 3:
 				MemMap.Cart_RAM = new uint8_t[0x8000];
+				MemMap.Cart_RAM_Length = 0x8000;
 				break;
 			case 4:
 				MemMap.Cart_RAM = new uint8_t[0x20000];
+				MemMap.Cart_RAM_Length = 0x20000;
 				break;
 			case 5:
 				MemMap.Cart_RAM = new uint8_t[0x10000];
+				MemMap.Cart_RAM_Length = 0x10000;
 				break;
 			case 0:
 				MemMap.has_bat = false;
@@ -486,12 +496,14 @@ namespace GBHawk
 			if (mppr == "MBC2")
 			{
 				MemMap.Cart_RAM = new uint8_t[0x200];
+				MemMap.Cart_RAM_Length = 0x200;
 			}
 
 			// mbc7 has 256 bytes of RAM, regardless of any header info
 			if (mppr == "MBC7")
 			{
 				MemMap.Cart_RAM = new uint8_t[0x100];
+				MemMap.Cart_RAM_Length = 0x100;
 				MemMap.has_bat = true;
 			}
 
@@ -499,11 +511,10 @@ namespace GBHawk
 			if (mppr == "TAMA5")
 			{
 				MemMap.Cart_RAM = new uint8_t[0x20];
+				MemMap.Cart_RAM_Length = 0x20;
 				MemMap.has_bat = true;
 			}
 
-			MemMap.Cart_RAM_Length = sizeof(MemMap.Cart_RAM);
-
 			if (MemMap.Cart_RAM != nullptr && (mppr != "MBC7"))
 			{
 				for (uint32_t i = 0; i < MemMap.Cart_RAM_Length; i++)

libHawk/GBHawk/GBHawk/GBHawk.cpp

@@ -187,13 +187,12 @@ GBHawk_EXPORT uint8_t* GB_get_ppu_pntrs(GBCore* p, int sel) {
 	}
 	else 
 	{
-		// need to fix this for GB
 		switch (sel)
 		{
 		case 0: return p->MemMap.VRAM; break;
 		case 1: return p->MemMap.OAM; break;
-		case 2: return (uint8_t*)p->ppu->OBJ_palette; break;
+		case 2: return (uint8_t*)p->MemMap.color_palette_OBJ; break;
-		case 3: return (uint8_t*)p->ppu->BG_palette; break;
+		case 3: return (uint8_t*)p->MemMap.color_palette_BG; break;
 		}
 	}
 

libHawk/GBHawk/GBHawk/Memory.cpp

@@ -766,9 +766,14 @@ namespace GBHawk
 		case 0xFF44:
 		case 0xFF45:
 		case 0xFF46:
+			ppu_pntr->WriteReg(addr, value);
+			break;
 		case 0xFF47:
 		case 0xFF48:
 		case 0xFF49:
+			ppu_pntr->WriteReg(addr, value);
+			compute_palettes();
+			break;
 		case 0xFF4A:
 		case 0xFF4B:
 			ppu_pntr->WriteReg(addr, value);
@@ -911,4 +916,14 @@ namespace GBHawk
 			break;
 		}
 	}
+
+	void MemoryManager::compute_palettes()
+	{
+		for (int i = 0; i < 4; i++)
+		{
+			color_palette_OBJ[i] = color_palette[(ppu_pntr->obj_pal_0 >> (i * 2)) & 3];
+			color_palette_OBJ[i + 4] = color_palette[(ppu_pntr->obj_pal_1 >> (i * 2)) & 3];
+			color_palette_BG[i] = color_palette[(ppu_pntr->BGP >> (i * 2)) & 3];
+		}
+	}
 }

libHawk/GBHawk/GBHawk/Memory.h

@@ -28,6 +28,7 @@ namespace GBHawk
 		void WriteMemory(uint32_t addr, uint8_t value);
 		uint8_t Read_Registers(uint32_t addr);
 		void Write_Registers(uint32_t addr, uint8_t value);
+		void compute_palettes();
 
 		#pragma region Declarations
 
@@ -67,10 +68,10 @@ namespace GBHawk
 
 		uint8_t REG_FFFF, REG_FF0F, REG_FF0F_OLD;
 
-		uint8_t _scanlineCallbackLine;
+		int32_t _scanlineCallbackLine;
 		uint8_t input_register;
-		uint32_t RAM_Bank;
+		uint32_t RAM_Bank = 0;
-		uint32_t VRAM_Bank;
+		uint32_t VRAM_Bank = 0;
 		uint32_t IR_write;
 		uint32_t addr_access;
 		uint32_t Acc_X_state;
@@ -87,6 +88,10 @@ namespace GBHawk
 
 		const uint8_t GBA_override[13] = { 0xFF, 0x00, 0xCD, 0x03, 0x35, 0xAA, 0x31, 0x90, 0x94, 0x00, 0x00, 0x00, 0x00 };
 
+		// these two arrays are computed on calls from the GPU Viewer to get the GB palettes
+		uint32_t color_palette_BG[4] = {};
+		uint32_t color_palette_OBJ[8] = {};
+
 		#pragma endregion
 
 		#pragma region Functions
@@ -206,9 +211,10 @@ namespace GBHawk
 			saver = byte_saver(REG_FFFF, saver);
 			saver = byte_saver(REG_FF0F, saver);
 			saver = byte_saver(REG_FF0F_OLD, saver);
-			saver = byte_saver(_scanlineCallbackLine, saver);
 			saver = byte_saver(input_register, saver);
 
+			saver = int_saver(_scanlineCallbackLine, saver);
+
 			saver = int_saver(RAM_Bank, saver);
 			saver = int_saver(VRAM_Bank, saver);
 			saver = int_saver(IR_write, saver);
@@ -261,9 +267,10 @@ namespace GBHawk
 			loader = byte_loader(&REG_FFFF, loader);
 			loader = byte_loader(&REG_FF0F, loader);
 			loader = byte_loader(&REG_FF0F_OLD, loader);
-			loader = byte_loader(&_scanlineCallbackLine, loader);
 			loader = byte_loader(&input_register, loader);
 
+			loader = sint_loader(&_scanlineCallbackLine, loader);
+
 			loader = int_loader(&RAM_Bank, loader);
 			loader = int_loader(&VRAM_Bank, loader);
 			loader = int_loader(&IR_write, loader);

libHawk/GBHawk/GBHawk/PPU.h

@@ -38,7 +38,7 @@ namespace GBHawk
 		uint8_t* cpu_LY = nullptr;
 		uint8_t* REG_FFFF = nullptr;
 		uint8_t* REG_FF0F = nullptr;
-		uint8_t* _scanlineCallbackLine = nullptr;
+		int32_t* _scanlineCallbackLine = nullptr;
 		uint8_t* OAM = nullptr;
 		uint8_t* VRAM = nullptr;
 		uint32_t* VRAM_Bank = nullptr;
@@ -3487,6 +3487,8 @@ namespace GBHawk
 					VRAM_access_write = true;
 					OAM_access_read = true;
 					OAM_access_write = true;
+
+					clear_screen = true;
 				}
 
 				if (!((LCDC & 0x80) > 0) && ((value & 0x80) > 0))
@@ -4328,7 +4330,7 @@ namespace GBHawk
 					if ((internal_cycle % 2) == 1)
 					{
 						// calculate the row number of the tiles to be fetched
-						y_tile = ((uint32_t)floor((float)((uint32_t)scroll_y + LY) / 8.0)) % 32;
+						y_tile = ((uint32_t)floor(((float)scroll_y + (float)LY) / (float)8.0)) % 32;
 
 						temp_fetch = y_tile * 32 + (x_tile + tile_inc) % 32;
 						tile_byte = VRAM[0x1800 + (((LCDC & 0x4) > 0) ? 1 : 0) * 0x400 + temp_fetch];