From: Shamus Hammons Date: Wed, 24 Jun 2009 05:58:02 +0000 (+0000) Subject: And so with this revision, we commit massive breakage. We Apologize For The Inconveni... X-Git-Tag: 2.0.0~38 X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=dd520b965a1e6531bd1d285494b223ab04c5368b;p=virtualjaguar And so with this revision, we commit massive breakage. We Apologize For The Inconvenience. --- diff --git a/src/blitter.cpp b/src/blitter.cpp index 90f0438..75d65a4 100644 --- a/src/blitter.cpp +++ b/src/blitter.cpp @@ -8,7 +8,7 @@ // to Curt. ;-) Without that excellent documentation which shows *exactly* // what's going on inside the TOM chip, we'd all still be guessing as to how // the wily blitter and other pieces of the Jaguar puzzle actually work. -// Now how about those JERRY ASIC nets gentlemen...? ;-) +// Now how about those JERRY ASIC nets gentlemen...? [We have those now!] ;-) // #include "blitter.h" diff --git a/src/dac.cpp b/src/dac.cpp index 6a43cff..9dc1a2e 100644 --- a/src/dac.cpp +++ b/src/dac.cpp @@ -174,7 +174,7 @@ if (numLeftSamplesReady == 0 || numRightSamplesReady == 0) } // -// Calculate the frequency of SCLK * 32 using the divider +// Calculate the freq9uency of SCLK * 32 using the divider // int GetCalculatedFrequency(void) { diff --git a/src/gpu.cpp b/src/gpu.cpp index 0275a26..aec51a1 100644 --- a/src/gpu.cpp +++ b/src/gpu.cpp @@ -1,3 +1,5 @@ +#if 1 + // // GPU Core // @@ -2419,3 +2421,13 @@ static void gpu_opcode_sh(void) //Temporary: Testing only! //#include "gpu2.cpp" //#include "gpu3.cpp" + +#else + +// New thread-safe GPU core + +int GPUCore(void * data) +{ +} + +#endif diff --git a/src/jaguar.cpp b/src/jaguar.cpp index 0a54ea4..f524242 100644 --- a/src/jaguar.cpp +++ b/src/jaguar.cpp @@ -25,6 +25,10 @@ #include "settings.h" #include "tom.h" #include "video.h" +#include "blitter.h" +#include "jerry.h" +#include "dac.h" +#include "eeprom.h" #define CPU_DEBUG //Do this in makefile??? Yes! Could, but it's easier to define here... @@ -44,7 +48,6 @@ void M68K_show_context(void); // External variables -//extern bool hardwareTypeNTSC; // Set to false for PAL #ifdef CPU_DEBUG_MEMORY extern bool startMemLog; // Set by "e" key extern int effect_start; @@ -58,15 +61,19 @@ const char * whoName[9] = uint32 jaguar_active_memory_dumps = 0; -uint32 jaguarMainRomCRC32, jaguarRomSize, jaguarRunAddress; +uint32 jaguarMainROMCRC32, jaguarROMSize, jaguarRunAddress; -uint8 * jaguarMainRam = NULL; -uint8 * jaguarMainRom = NULL; -uint8 * jaguarBootRom = NULL; -uint8 * jaguarCDBootROM = NULL; +uint8 jaguarMainRAM[0x400000]; // 68K CPU RAM +uint8 jaguarMainROM[0x600000]; // 68K CPU ROM +uint8 jaguarBootROM[0x040000]; // 68K CPU BIOS ROM--uses only half of this! +uint8 jaguarCDBootROM[0x040000]; // 68K CPU CD BIOS ROM bool BIOSLoaded = false; bool CDBIOSLoaded = false; +uint8 cdRAM[0x100]; +uint8 tomRAM[0x4000]; +uint8 jerryRAM[0x10000]; + #ifdef CPU_DEBUG_MEMORY uint8 writeMemMax[0x400000], writeMemMin[0x400000]; uint8 readMem[0x400000]; @@ -81,7 +88,8 @@ uint32 pcQPtr = 0; // void GPUDumpDisassembly(void); void GPUDumpRegisters(void); - static bool start = false; +static bool start = false; + void M68KInstructionHook(void) { uint32 m68kPC = m68k_get_reg(NULL, M68K_REG_PC); @@ -346,6 +354,321 @@ CD_switch:: -> $306C #endif } +#if 0 +Now here be dragons... +Here is how memory ranges are defined in the CoJag driver. +Note that we only have to be concerned with 3 entities read/writing anything: +The main CPU, the GPU, and the DSP. Everything else is unnecessary. So we can keep our main memory +checking in jaguar.cpp, gpu.cpp and dsp.cpp. There should be NO checking in TOM, JERRY, etc. other than +things that are entirely internal to those modules. This way we should be able to get a handle on all +this crap which is currently scattered over Hell's Half Acre(tm). + +Also: We need to distinguish whether or not we need .b, .w, and .dw versions of everything, or if there +is a good way to collapse that shit. + +/************************************* + * + * Main CPU memory handlers + * + *************************************/ + +static ADDRESS_MAP_START( m68020_map, ADDRESS_SPACE_PROGRAM, 32 ) + AM_RANGE(0x000000, 0x7fffff) AM_RAM AM_BASE(&jaguar_shared_ram) AM_SHARE(1) + AM_RANGE(0x800000, 0x9fffff) AM_ROM AM_REGION(REGION_USER1, 0) AM_BASE(&rom_base) + AM_RANGE(0xa00000, 0xa1ffff) AM_RAM + AM_RANGE(0xa20000, 0xa21fff) AM_READWRITE(eeprom_data_r, eeprom_data_w) AM_BASE(&generic_nvram32) AM_SIZE(&generic_nvram_size) + AM_RANGE(0xa30000, 0xa30003) AM_WRITE(watchdog_reset32_w) + AM_RANGE(0xa40000, 0xa40003) AM_WRITE(eeprom_enable_w) + AM_RANGE(0xb70000, 0xb70003) AM_READWRITE(misc_control_r, misc_control_w) + AM_RANGE(0xc00000, 0xdfffff) AM_ROMBANK(2) + AM_RANGE(0xe00000, 0xe003ff) AM_DEVREADWRITE(IDE_CONTROLLER, "ide", ide_controller32_r, ide_controller32_w) + AM_RANGE(0xf00000, 0xf003ff) AM_READWRITE(jaguar_tom_regs32_r, jaguar_tom_regs32_w) + AM_RANGE(0xf00400, 0xf007ff) AM_RAM AM_BASE(&jaguar_gpu_clut) AM_SHARE(2) + AM_RANGE(0xf02100, 0xf021ff) AM_READWRITE(gpuctrl_r, gpuctrl_w) + AM_RANGE(0xf02200, 0xf022ff) AM_READWRITE(jaguar_blitter_r, jaguar_blitter_w) + AM_RANGE(0xf03000, 0xf03fff) AM_MIRROR(0x008000) AM_RAM AM_BASE(&jaguar_gpu_ram) AM_SHARE(3) + AM_RANGE(0xf10000, 0xf103ff) AM_READWRITE(jaguar_jerry_regs32_r, jaguar_jerry_regs32_w) + AM_RANGE(0xf16000, 0xf1600b) AM_READ(cojag_gun_input_r) // GPI02 + AM_RANGE(0xf17000, 0xf17003) AM_READ(status_r) // GPI03 +// AM_RANGE(0xf17800, 0xf17803) AM_WRITE(latch_w) // GPI04 + AM_RANGE(0xf17c00, 0xf17c03) AM_READ(jamma_r) // GPI05 + AM_RANGE(0xf1a100, 0xf1a13f) AM_READWRITE(dspctrl_r, dspctrl_w) + AM_RANGE(0xf1a140, 0xf1a17f) AM_READWRITE(jaguar_serial_r, jaguar_serial_w) + AM_RANGE(0xf1b000, 0xf1cfff) AM_RAM AM_BASE(&jaguar_dsp_ram) AM_SHARE(4) +ADDRESS_MAP_END + +/************************************* + * + * GPU memory handlers + * + *************************************/ + +static ADDRESS_MAP_START( gpu_map, ADDRESS_SPACE_PROGRAM, 32 ) + AM_RANGE(0x000000, 0x7fffff) AM_RAM AM_SHARE(1) + AM_RANGE(0x800000, 0xbfffff) AM_ROMBANK(8) + AM_RANGE(0xc00000, 0xdfffff) AM_ROMBANK(9) + AM_RANGE(0xe00000, 0xe003ff) AM_DEVREADWRITE(IDE_CONTROLLER, "ide", ide_controller32_r, ide_controller32_w) + AM_RANGE(0xf00000, 0xf003ff) AM_READWRITE(jaguar_tom_regs32_r, jaguar_tom_regs32_w) + AM_RANGE(0xf00400, 0xf007ff) AM_RAM AM_SHARE(2) + AM_RANGE(0xf02100, 0xf021ff) AM_READWRITE(gpuctrl_r, gpuctrl_w) + AM_RANGE(0xf02200, 0xf022ff) AM_READWRITE(jaguar_blitter_r, jaguar_blitter_w) + AM_RANGE(0xf03000, 0xf03fff) AM_RAM AM_SHARE(3) + AM_RANGE(0xf10000, 0xf103ff) AM_READWRITE(jaguar_jerry_regs32_r, jaguar_jerry_regs32_w) +ADDRESS_MAP_END + +/************************************* + * + * DSP memory handlers + * + *************************************/ + +static ADDRESS_MAP_START( dsp_map, ADDRESS_SPACE_PROGRAM, 32 ) + AM_RANGE(0x000000, 0x7fffff) AM_RAM AM_SHARE(1) + AM_RANGE(0x800000, 0xbfffff) AM_ROMBANK(8) + AM_RANGE(0xc00000, 0xdfffff) AM_ROMBANK(9) + AM_RANGE(0xf10000, 0xf103ff) AM_READWRITE(jaguar_jerry_regs32_r, jaguar_jerry_regs32_w) + AM_RANGE(0xf1a100, 0xf1a13f) AM_READWRITE(dspctrl_r, dspctrl_w) + AM_RANGE(0xf1a140, 0xf1a17f) AM_READWRITE(jaguar_serial_r, jaguar_serial_w) + AM_RANGE(0xf1b000, 0xf1cfff) AM_RAM AM_SHARE(4) + AM_RANGE(0xf1d000, 0xf1dfff) AM_READ(jaguar_wave_rom_r) AM_BASE(&jaguar_wave_rom) +ADDRESS_MAP_END +*/ +#endif + +#define EXPERIMENTAL_MEMORY_HANDLING +// Experimental memory mappage... +// Dunno if this is a good approach or not, but it seems to make better +// sense to have all this crap in one spot intstead of scattered all over +// the place the way it is now. +#ifdef EXPERIMENTAL_MEMORY_HANDLING +// Needed defines... +#define NEW_TIMER_SYSTEM +void WriteByte(uint32 address, uint8 byte, uint32 who/*=UNKNOWN*/) +{ + // Not sure, but I think the system only has 24 address bits... + address &= 0x00FFFFFF; + + // RAM ($000000 - $3FFFFF) 4M + if (address <= 0x3FFFFF) + jaguarMainRAM[address] = byte; + // hole ($400000 - $7FFFFF) 4M + else if (address <= 0x7FFFFF) + ; // Do nothing + // GAME ROM ($800000 - $DFFEFF) 6M - 256 bytes + else if (address <= 0xDFFEFF) + ; // Do nothing + // CDROM ($DFFF00 - $DFFFFF) 256 bytes + else if (address <= 0xDFFFFF) + { + cdRAM[address & 0xFF] = byte; +#ifdef CDROM_LOG + if ((address & 0xFF) < 12 * 4) + WriteLog("[%s] ", BReg[(address & 0xFF) / 4]); + WriteLog("CDROM: %s writing byte $%02X at $%08X [68K PC=$%08X]\n", whoName[who], data, offset, m68k_get_reg(NULL, M68K_REG_PC)); +#endif + } + // BIOS ROM ($E00000 - $E3FFFF) 256K + else if (address <= 0xE3FFFF) + ; // Do nothing + // hole ($E40000 - $EFFFFF) 768K + else if (address <= 0xEFFFFF) + ; // Do nothing + // TOM ($F00000 - $F0FFFF) 64K + else if (address <= 0xF0FFFF) +// ; // Do nothing + { + if (address == 0xF00050) + { + tomTimerPrescaler = (tomTimerPrescaler & 0x00FF) | ((uint16)byte << 8); + TOMResetPIT(); + return; + } + else if (address == 0xF00051) + { + tomTimerPrescaler = (tomTimerPrescaler & 0xFF00) | byte; + TOMResetPIT(); + return; + } + else if (address == 0xF00052) + { + tomTimerDivider = (tomTimerDivider & 0x00FF) | ((uint16)byte << 8); + TOMResetPIT(); + return; + } + else if (address == 0xF00053) + { + tomTimerDivider = (tomTimerDivider & 0xFF00) | byte; + TOMResetPIT(); + return; + } + else if (address >= 0xF00400 && address <= 0xF007FF) // CLUT (A & B) + { + // Writing to one CLUT writes to the other + address &= 0x5FF; // Mask out $F00600 (restrict to $F00400-5FF) + tomRAM[address] = tomRAM[address + 0x200] = byte; + return; + } + //What about LBUF writes??? + else if ((address >= 0xF02100) && (address <= 0xF0211F)) // GPU CONTROL + { + GPUWriteByte(address, byte, who); + return; + } + else if ((address >= 0xF02200) && (address <= 0xF0229F)) // BLITTER + { + BlitterWriteByte(address, byte, who); + return; + } + else if ((address >= 0xF03000) && (address <= 0xF03FFF)) // GPU RAM + { + GPUWriteByte(address, byte, who); + return; + } + + tomRAM[address & 0x3FFF] = byte; + } + // JERRY ($F10000 - $F1FFFF) 64K + else if (address <= 0xF1FFFF) +// ; // Do nothing + { +#ifdef JERRY_DEBUG + WriteLog("jerry: writing byte %.2x at 0x%.6x\n", byte, address); +#endif + if ((address >= DSP_CONTROL_RAM_BASE) && (address < DSP_CONTROL_RAM_BASE+0x20)) + { + DSPWriteByte(address, byte, who); + return; + } + else if ((address >= DSP_WORK_RAM_BASE) && (address < DSP_WORK_RAM_BASE+0x2000)) + { + DSPWriteByte(address, byte, who); + return; + } + // SCLK ($F1A150--8 bits wide) +//NOTE: This should be taken care of in DAC... + else if ((address >= 0xF1A152) && (address <= 0xF1A153)) + { +// WriteLog("JERRY: Writing %02X to SCLK...\n", data); + if ((address & 0x03) == 2) + JERRYI2SInterruptDivide = (JERRYI2SInterruptDivide & 0x00FF) | ((uint32)byte << 8); + else + JERRYI2SInterruptDivide = (JERRYI2SInterruptDivide & 0xFF00) | (uint32)byte; + + JERRYI2SInterruptTimer = -1; +#ifndef NEW_TIMER_SYSTEM + jerry_i2s_exec(0); +#else + RemoveCallback(JERRYI2SCallback); + JERRYI2SCallback(); +#endif +// return; + } + // LTXD/RTXD/SCLK/SMODE $F1A148/4C/50/54 (really 16-bit registers...) + else if (address >= 0xF1A148 && address <= 0xF1A157) + { + DACWriteByte(address, byte, who); + return; + } + else if (address >= 0xF10000 && address <= 0xF10007) + { +#ifndef NEW_TIMER_SYSTEM + switch (address & 0x07) + { + case 0: + JERRYPIT1Prescaler = (JERRYPIT1Prescaler & 0x00FF) | (byte << 8); + JERRYResetPIT1(); + break; + case 1: + JERRYPIT1Prescaler = (JERRYPIT1Prescaler & 0xFF00) | byte; + JERRYResetPIT1(); + break; + case 2: + JERRYPIT1Divider = (JERRYPIT1Divider & 0x00FF) | (byte << 8); + JERRYResetPIT1(); + break; + case 3: + JERRYPIT1Divider = (JERRYPIT1Divider & 0xFF00) | byte; + JERRYResetPIT1(); + break; + case 4: + JERRYPIT2Prescaler = (JERRYPIT2Prescaler & 0x00FF) | (byte << 8); + JERRYResetPIT2(); + break; + case 5: + JERRYPIT2Prescaler = (JERRYPIT2Prescaler & 0xFF00) | byte; + JERRYResetPIT2(); + break; + case 6: + JERRYPIT2Divider = (JERRYPIT2Divider & 0x00FF) | (byte << 8); + JERRYResetPIT2(); + break; + case 7: + JERRYPIT2Divider = (JERRYPIT2Divider & 0xFF00) | byte; + JERRYResetPIT2(); + } +#else +WriteLog("JERRY: Unhandled timer write (BYTE) at %08X...\n", address); +#endif + return; + } +/* else if ((offset >= 0xF10010) && (offset <= 0xF10015)) + { + clock_byte_write(offset, byte); + return; + }//*/ + // JERRY -> 68K interrupt enables/latches (need to be handled!) + else if (address >= 0xF10020 && address <= 0xF10023) + { +WriteLog("JERRY: (68K int en/lat - Unhandled!) Tried to write $%02X to $%08X!\n", byte, address); + } +/* else if ((offset >= 0xF17C00) && (offset <= 0xF17C01)) + { + anajoy_byte_write(offset, byte); + return; + }*/ + else if ((address >= 0xF14000) && (address <= 0xF14003)) + { + JoystickWriteByte(address, byte); + EepromWriteByte(address, byte); + return; + } + else if ((address >= 0xF14004) && (address <= 0xF1A0FF)) + { + EepromWriteByte(address, byte); + return; + } +//Need to protect write attempts to Wavetable ROM (F1D000-FFF) + else if (address >= 0xF1D000 && address <= 0xF1DFFF) + return; + + jerryRAM[address & 0xFFFF] = byte; + } + // hole ($F20000 - $FFFFFF) 1M - 128K + else + ; // Do nothing +} + +void WriteWord(uint32 adddress, uint16 word) +{ +} + +void WriteDWord(uint32 adddress, uint32 dword) +{ +} + +uint8 ReadByte(uint32 adddress) +{ +} + +uint16 ReadWord(uint32 adddress) +{ +} + +uint32 ReadDWord(uint32 adddress) +{ +} +#endif + // // Musashi 68000 read/write/IRQ functions // @@ -638,7 +961,7 @@ uint32 JaguarGetHandler(uint32 i) bool JaguarInterruptHandlerIsValid(uint32 i) // Debug use only... { uint32 handler = JaguarGetHandler(i); - return (handler && (handler != 0xFFFFFFFF) ? 1 : 0); + return (handler && (handler != 0xFFFFFFFF) ? true : false); } void M68K_show_context(void) @@ -1036,10 +1359,6 @@ void JaguarInit(void) memset(writeMemMin, 0xFF, 0x400000); memset(writeMemMax, 0x00, 0x400000); #endif - memory_malloc_secure((void **)&jaguarMainRam, 0x400000, "Jaguar 68K CPU RAM"); - memory_malloc_secure((void **)&jaguarMainRom, 0x600000, "Jaguar 68K CPU ROM"); - memory_malloc_secure((void **)&jaguarBootRom, 0x040000, "Jaguar 68K CPU BIOS ROM"); // Only uses half of this! - memory_malloc_secure((void **)&jaguarCDBootROM, 0x040000, "Jaguar 68K CPU CD BIOS ROM"); memset(jaguarMainRam, 0x00, 0x400000); // memset(jaguar_mainRom, 0xFF, 0x200000); // & set it to all Fs... // memset(jaguar_mainRom, 0x00, 0x200000); // & set it to all 0s... @@ -1171,11 +1490,6 @@ void JaguarDone(void) DSPDone(); TOMDone(); JERRYDone(); - - memory_free(jaguarMainRom); - memory_free(jaguarMainRam); - memory_free(jaguarBootRom); - memory_free(jaguarCDBootROM); } // @@ -1197,14 +1511,13 @@ void JaguarExecute(uint32 * backbuffer, bool render) // uint16 vde = TOMReadWord(0xF00048); uint16 refreshRate = (vjs.hardwareTypeNTSC ? 60 : 50); + uint32 m68kCockRate = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL); //Not sure the above is correct, since the number of lines and timings given in the JTRM //seem to indicate the refresh rate is *half* the above... // uint16 refreshRate = (vjs.hardwareTypeNTSC ? 30 : 25); // Should these be hardwired or read from VP? Yes, from VP! - uint32 M68KCyclesPerScanline - = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL) / (vp * refreshRate); - uint32 RISCCyclesPerScanline - = (vjs.hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL) / (vp * refreshRate); + uint32 M68KCyclesPerScanline = m68kClockRate / (vp * refreshRate); + uint32 RISCCyclesPerScanline = m68kClockRate / (vp * refreshRate); TOMResetBackbuffer(backbuffer); /*extern int effect_start; diff --git a/src/jaguar.h b/src/jaguar.h index 73f37bb..d4bb738 100644 --- a/src/jaguar.h +++ b/src/jaguar.h @@ -23,10 +23,10 @@ void JaguarExecuteNew(void); // Exports from JAGUAR.CPP -extern uint8 * jaguarMainRam; -extern uint8 * jaguarMainRom; -extern uint8 * jaguarBootRom; -extern uint8 * jaguarCDBootROM; +extern uint8 jaguarMainRam[]; +extern uint8 jaguarMainRom[]; +extern uint8 jaguarBootRom[]; +extern uint8 jaguarCDBootROM[]; extern bool BIOSLoaded; extern bool CDBIOSLoaded; extern int32 jaguarCPUInExec; diff --git a/src/jerry.cpp b/src/jerry.cpp index 4f2d37b..c564d43 100644 --- a/src/jerry.cpp +++ b/src/jerry.cpp @@ -175,8 +175,8 @@ static uint32 JERRYPIT2Divider; static int32 jerry_timer_1_counter; static int32 jerry_timer_2_counter; -static uint32 jerry_i2s_interrupt_divide = 8; -static int32 jerry_i2s_interrupt_timer = -1; +uint32 JERRYI2SInterruptDivide = 8; +int32 JERRYI2SInterruptTimer = -1; uint32 jerryI2SCycles; uint32 jerryIntPending; diff --git a/src/jerry.h b/src/jerry.h index c1f1f7a..684b55f 100644 --- a/src/jerry.h +++ b/src/jerry.h @@ -26,4 +26,13 @@ enum { IRQ2_EXTERNAL = 0, IRQ2_DSP, IRQ2_TIMER1, IRQ2_TIMER2, IRQ2_ASI, IRQ2_SSI bool JERRYIRQEnabled(int irq); void JERRYSetPendingIRQ(int irq); +// This should stay inside this file, but it's here for now... +// Need to set up an interface function so that this can go back +void JERRYI2SCallback(void); + +// External variables + +extern uint32 JERRYI2SInterruptDivide; +extern int32 JERRYI2SInterruptTimer; + #endif diff --git a/src/tom.cpp b/src/tom.cpp index 5c236a0..36f3d8b 100644 --- a/src/tom.cpp +++ b/src/tom.cpp @@ -316,9 +316,9 @@ uint8 tomRam8[0x4000]; uint32 tomWidth, tomHeight; -static uint32 tom_timer_prescaler; -static uint32 tom_timer_divider; -static int32 tom_timer_counter; +uint32 tomTimerPrescaler; +uint32 tomTimerDivider; +int32 tomTimerCounter; //uint32 tom_scanline; //uint32 hblankWidthInPixels = 0; uint16 tom_jerry_int_pending, tom_timer_int_pending, tom_object_int_pending, diff --git a/src/tom.h b/src/tom.h index 0c9511e..ea7ce35 100644 --- a/src/tom.h +++ b/src/tom.h @@ -56,5 +56,8 @@ void TOMResetBackbuffer(uint32 * backbuffer); extern uint32 tomWidth; extern uint32 tomHeight; extern uint8 tomRam8[]; +extern uint32 tomTimerPrescaler; +extern uint32 tomTimerDivider; +extern int32 tomTimerCounter; #endif // __TOM_H__ diff --git a/src/video.cpp b/src/video.cpp index e7ed63f..4f33d66 100644 --- a/src/video.cpp +++ b/src/video.cpp @@ -22,6 +22,19 @@ Uint32 mainSurfaceFlags; //int16 * backbuffer; uint32 * backbuffer; +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + #define RMASK 0xFF000000 + #define GMASK 0x00FF0000 + #define BMASK 0x0000FF00 + #define AMASK 0x000000FF +#else + #define RMASK 0x000000FF + #define GMASK 0x0000FF00 + #define BMASK 0x00FF0000 + #define AMASK 0xFF000000 +#endif + + // One of the reasons why OpenGL is slower then normal SDL rendering, is because // the data is being pumped into the buffer every frame with a overflow as result. // So, we going tot render every 1 frame instead of every 0 frame. @@ -111,12 +124,7 @@ bool VideoInit(void) // vsWidth = 1280; //24BPP // surface = SDL_CreateRGBSurface(SDL_SWSURFACE, VIRTUAL_SCREEN_WIDTH, - surface = SDL_CreateRGBSurface(SDL_SWSURFACE, vsWidth, vsHeight, 32, -#if SDL_BYTEORDER == SDL_BIG_ENDIAN - 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF); -#else - 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000); -#endif//*/ + surface = SDL_CreateRGBSurface(SDL_SWSURFACE, vsWidth, vsHeight, 32, RMASK, GMASK, BMASK, AMASK); if (surface == NULL) { @@ -226,12 +234,7 @@ void RenderBackbuffer(void) void ResizeScreen(uint32 width, uint32 height) { SDL_FreeSurface(surface); - surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, -#if SDL_BYTEORDER == SDL_BIG_ENDIAN - 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF); -#else - 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000); -#endif//*/ + surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, RMASK, GMASK, BMASK, AMASK); if (surface == NULL) {