int angrylionRomOpen (void)
{
/* TODO/FIXME: For now just force it to 640x480.
*
* Later on we might want a low-res mode (320x240)
* for better performance as well in case screen_width
* is 320 and height is 240.
*/
if (screen_width < 640)
screen_width = 640;
if (screen_width > 640)
screen_width = 640;
if (screen_height < 480)
screen_height = 480;
if (screen_height > 480)
screen_height = 480;
pitchindwords = PRESCALE_WIDTH / 1; /* sizeof(DWORD) == sizeof(pixel) == 4 */
screen_pitch = PRESCALE_WIDTH << 2;
rdp_init();
overlay = ConfigGetParamBool(l_ConfigAngrylion, "VIOverlay");
return 1;
}
PackedScreenResolution Config_ReadScreenSettings()
{
PackedScreenResolution packedResolution;
packedResolution.width = ConfigGetParamInt(video_general_section, "ScreenWidth");
packedResolution.height = ConfigGetParamInt(video_general_section, "ScreenHeight");
packedResolution.fullscreen = ConfigGetParamBool(video_general_section, "Fullscreen");
return packedResolution;
}
EXPORT m64p_error CALL ConfigGetParameter(m64p_handle ConfigSectionHandle, const char *ParamName, m64p_type ParamType, void *ParamValue, int MaxSize)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL || (int) ParamType < 1 || (int) ParamType > 4)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
return M64ERR_INPUT_NOT_FOUND;
/* call the specific Get function to translate the parameter to the desired type */
switch(ParamType)
{
case M64TYPE_INT:
if (MaxSize < sizeof(int)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_INT && var->type != M64TYPE_FLOAT) return M64ERR_WRONG_TYPE;
*((int *) ParamValue) = ConfigGetParamInt(ConfigSectionHandle, ParamName);
break;
case M64TYPE_FLOAT:
if (MaxSize < sizeof(float)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_INT && var->type != M64TYPE_FLOAT) return M64ERR_WRONG_TYPE;
*((float *) ParamValue) = ConfigGetParamFloat(ConfigSectionHandle, ParamName);
break;
case M64TYPE_BOOL:
if (MaxSize < sizeof(int)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_BOOL && var->type != M64TYPE_INT) return M64ERR_WRONG_TYPE;
*((int *) ParamValue) = ConfigGetParamBool(ConfigSectionHandle, ParamName);
break;
case M64TYPE_STRING:
{
const char *string;
if (MaxSize < 1) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_STRING && var->type != M64TYPE_BOOL) return M64ERR_WRONG_TYPE;
string = ConfigGetParamString(ConfigSectionHandle, ParamName);
strncpy((char *) ParamValue, string, MaxSize);
*((char *) ParamValue + MaxSize - 1) = 0;
break;
}
default:
/* this is logically impossible because of the ParamType check at the top of this function */
break;
}
return M64ERR_SUCCESS;
}
BOOL Config_ReadInt(const char *itemname, const char *desc, int def_value, int create, int isBoolean)
{
VLOG("Getting value %s", itemname);
if (isBoolean)
{
ConfigSetDefaultBool(video_glide64_section, itemname, def_value, desc);
return ConfigGetParamBool(video_glide64_section, itemname);
}
else
{
ConfigSetDefaultInt(video_glide64_section, itemname, def_value, desc);
return ConfigGetParamInt(video_glide64_section, itemname);
}
}
void main_message(m64p_msg_level level, unsigned int corner, const char *format, ...)
{
va_list ap;
char buffer[2049];
va_start(ap, format);
vsnprintf(buffer, 2047, format, ap);
buffer[2048]='\0';
va_end(ap);
/* send message to on-screen-display if enabled */
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
osd_new_message((enum osd_corner) corner, buffer);
/* send message to front-end */
DebugMessage(level, buffer);
}
void video_plugin_render_callback(void)
{
// if the flag is set to take a screenshot, then grab it now
if (g_TakeScreenshot != 0)
{
TakeScreenshot(g_TakeScreenshot - 1); // current frame number +1 is in g_TakeScreenshot
g_TakeScreenshot = 0; // reset flag
}
// if the OSD is enabled, then draw it now
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
osd_render();
}
}
int angrylionRomOpen (void)
{
/* TODO/FIXME: For now just force it to 640x480.
*
* Later on we might want a low-res mode (320x240)
* for better performance as well in case screen_width
* is 320 and height is 240.
*/
if (screen_width < 640)
screen_width = 640;
if (screen_width > 640)
screen_width = 640;
if (screen_height < 480)
screen_height = 480;
if (screen_height > 480)
screen_height = 480;
screen_pitch = PRESCALE_WIDTH << 2;
rdp_init();
angrylion_set_vi((int)ConfigGetParamBool(l_ConfigAngrylion, "VIOverlay"));
return 1;
}
void Config_LoadConfig()
{
const u32 hacks = config.generalEmulation.hacks;
if (!Config_SetDefault()) {
config.generalEmulation.hacks = hacks;
return;
}
config.version = ConfigGetParamInt(g_configVideoGliden64, "configVersion");
if (config.version != CONFIG_VERSION_CURRENT) {
m64p_error res = ConfigDeleteSection("Video-GLideN64");
assert(res == M64ERR_SUCCESS);
ConfigSaveFile();
if (!Config_SetDefault()) {
config.generalEmulation.hacks = hacks;
return;
}
}
config.video.fullscreen = ConfigGetParamBool(g_configVideoGeneral, "Fullscreen");
config.video.windowedWidth = ConfigGetParamInt(g_configVideoGeneral, "ScreenWidth");
config.video.windowedHeight = ConfigGetParamInt(g_configVideoGeneral, "ScreenHeight");
config.video.verticalSync = ConfigGetParamBool(g_configVideoGeneral, "VerticalSync");
#ifdef GL_MULTISAMPLING_SUPPORT
config.video.multisampling = ConfigGetParamInt(g_configVideoGliden64, "MultiSampling");
#else
config.video.multisampling = 0;
#endif
config.frameBufferEmulation.aspect = ConfigGetParamInt(g_configVideoGliden64, "AspectRatio");
config.frameBufferEmulation.bufferSwapMode = ConfigGetParamInt(g_configVideoGliden64, "BufferSwapMode");
config.frameBufferEmulation.nativeResFactor = ConfigGetParamInt(g_configVideoGliden64, "UseNativeResolutionFactor");
//#Texture Settings
config.texture.bilinearMode = ConfigGetParamBool(g_configVideoGliden64, "bilinearMode");
config.texture.maxAnisotropy = ConfigGetParamInt(g_configVideoGliden64, "MaxAnisotropy");
config.texture.maxBytes = ConfigGetParamInt(g_configVideoGliden64, "CacheSize") * uMegabyte;
//#Emulation Settings
config.generalEmulation.enableNoise = ConfigGetParamBool(g_configVideoGliden64, "EnableNoise");
config.generalEmulation.enableLOD = ConfigGetParamBool(g_configVideoGliden64, "EnableLOD");
config.generalEmulation.enableHWLighting = ConfigGetParamBool(g_configVideoGliden64, "EnableHWLighting");
config.generalEmulation.enableShadersStorage = ConfigGetParamBool(g_configVideoGliden64, "EnableShadersStorage");
config.generalEmulation.correctTexrectCoords = ConfigGetParamInt(g_configVideoGliden64, "CorrectTexrectCoords");
config.generalEmulation.enableNativeResTexrects = ConfigGetParamBool(g_configVideoGliden64, "enableNativeResTexrects");
#ifdef ANDROID
config.generalEmulation.forcePolygonOffset = ConfigGetParamBool(g_configVideoGliden64, "ForcePolygonOffset");
config.generalEmulation.polygonOffsetFactor = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetFactor");
config.generalEmulation.polygonOffsetUnits = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetUnits");
#endif
//#Frame Buffer Settings:"
config.frameBufferEmulation.enable = ConfigGetParamBool(g_configVideoGliden64, "EnableFBEmulation");
config.frameBufferEmulation.copyAuxToRDRAM = ConfigGetParamBool(g_configVideoGliden64, "EnableCopyAuxiliaryToRDRAM");
config.frameBufferEmulation.copyToRDRAM = ConfigGetParamInt(g_configVideoGliden64, "EnableCopyColorToRDRAM");
config.frameBufferEmulation.copyDepthToRDRAM = ConfigGetParamInt(g_configVideoGliden64, "EnableCopyDepthToRDRAM");
config.frameBufferEmulation.copyFromRDRAM = ConfigGetParamBool(g_configVideoGliden64, "EnableCopyColorFromRDRAM");
config.frameBufferEmulation.N64DepthCompare = ConfigGetParamBool(g_configVideoGliden64, "EnableN64DepthCompare");
config.frameBufferEmulation.fbInfoDisabled = ConfigGetParamBool(g_configVideoGliden64, "DisableFBInfo");
config.frameBufferEmulation.fbInfoReadColorChunk = ConfigGetParamBool(g_configVideoGliden64, "FBInfoReadColorChunk");
config.frameBufferEmulation.fbInfoReadDepthChunk = ConfigGetParamBool(g_configVideoGliden64, "FBInfoReadDepthChunk");
//#Texture filter settings
config.textureFilter.txFilterMode = ConfigGetParamInt(g_configVideoGliden64, "txFilterMode");
config.textureFilter.txEnhancementMode = ConfigGetParamInt(g_configVideoGliden64, "txEnhancementMode");
config.textureFilter.txDeposterize = ConfigGetParamInt(g_configVideoGliden64, "txDeposterize");
config.textureFilter.txFilterIgnoreBG = ConfigGetParamBool(g_configVideoGliden64, "txFilterIgnoreBG");
config.textureFilter.txCacheSize = ConfigGetParamInt(g_configVideoGliden64, "txCacheSize") * uMegabyte;
config.textureFilter.txHiresEnable = ConfigGetParamBool(g_configVideoGliden64, "txHiresEnable");
config.textureFilter.txHiresFullAlphaChannel = ConfigGetParamBool(g_configVideoGliden64, "txHiresFullAlphaChannel");
config.textureFilter.txHresAltCRC = ConfigGetParamBool(g_configVideoGliden64, "txHresAltCRC");
config.textureFilter.txDump = ConfigGetParamBool(g_configVideoGliden64, "txDump");
config.textureFilter.txForce16bpp = ConfigGetParamBool(g_configVideoGliden64, "txForce16bpp");
config.textureFilter.txCacheCompression = ConfigGetParamBool(g_configVideoGliden64, "txCacheCompression");
config.textureFilter.txSaveCache = ConfigGetParamBool(g_configVideoGliden64, "txSaveCache");
::mbstowcs(config.textureFilter.txPath, ConfigGetParamString(g_configVideoGliden64, "txPath"), PLUGIN_PATH_SIZE);
//#Font settings
config.font.name = ConfigGetParamString(g_configVideoGliden64, "fontName");
if (config.font.name.empty())
config.font.name = "arial.ttf";
char buf[16];
sprintf(buf, "0x%s", ConfigGetParamString(g_configVideoGliden64, "fontColor"));
long int uColor = strtol(buf, nullptr, 16);
if (uColor != 0) {
config.font.color[0] = _SHIFTR(uColor, 16, 8);
config.font.color[1] = _SHIFTR(uColor, 8, 8);
config.font.color[2] = _SHIFTR(uColor, 0, 8);
config.font.color[3] = 0xFF;
config.font.colorf[0] = _FIXED2FLOAT(config.font.color[0], 8);
config.font.colorf[1] = _FIXED2FLOAT(config.font.color[1], 8);
config.font.colorf[2] = _FIXED2FLOAT(config.font.color[2], 8);
config.font.colorf[3] = 1.0f;
}
config.font.size = ConfigGetParamInt(g_configVideoGliden64, "fontSize");
if (config.font.size == 0)
config.font.size = 30;
//#Bloom filter settings
config.bloomFilter.enable = ConfigGetParamBool(g_configVideoGliden64, "EnableBloom");
config.bloomFilter.thresholdLevel = ConfigGetParamInt(g_configVideoGliden64, "bloomThresholdLevel");
config.bloomFilter.blendMode = ConfigGetParamInt(g_configVideoGliden64, "bloomBlendMode");
config.bloomFilter.blurAmount = ConfigGetParamInt(g_configVideoGliden64, "blurAmount");
config.bloomFilter.blurStrength = ConfigGetParamInt(g_configVideoGliden64, "blurStrength");
//#Gamma correction settings
config.gammaCorrection.force = ConfigGetParamBool(g_configVideoGliden64, "ForceGammaCorrection");
config.gammaCorrection.level = ConfigGetParamFloat(g_configVideoGliden64, "GammaCorrectionLevel");
config.generalEmulation.hacks = hacks;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_run(void)
{
VILimit = (float) GetVILimit();
VILimitMilliseconds = (double) 1000.0/VILimit;
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
/* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
event_initialize();
// initialize memory, and do byte-swapping if it's not been done yet
if (g_MemHasBeenBSwapped == 0)
{
init_memory(1);
g_MemHasBeenBSwapped = 1;
}
else
{
init_memory(0);
}
// Attach rom to plugins
if (!romOpen_gfx())
{
free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (!romOpen_audio())
{
romClosed_gfx(); free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (!romOpen_input())
{
romClosed_audio(); romClosed_gfx(); free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
// init on-screen display
int width = 640, height = 480;
readScreen(NULL, &width, &height, 0); // read screen to get width and height
osd_init(width, height);
}
// setup rendering callback from video plugin to the core, for screenshots and On-Screen-Display
setRenderingCallback(video_plugin_render_callback);
#ifdef WITH_LIRC
lircStart();
#endif // WITH_LIRC
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
/* Startup message on the OSD */
osd_new_message(OSD_MIDDLE_CENTER, "Mupen64Plus Started...");
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
r4300_execute();
#ifdef WITH_LIRC
lircStop();
#endif // WITH_LIRC
#ifdef DBG
if (g_DebuggerActive)
destroy_debugger();
#endif
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
osd_exit();
}
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
free_memory();
// clean up
g_EmulatorRunning = 0;
StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
SDL_Quit();
return M64ERR_SUCCESS;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_init(void)
{
size_t i;
unsigned int disable_extra_mem;
static int channels[] = { 0, 1, 2, 3 };
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
disable_extra_mem = ConfigGetParamInt(g_CoreConfig, "DisableExtraMem");
#if 0
count_per_op = ConfigGetParamInt(g_CoreConfig, "CountPerOp");
#endif
if (count_per_op <= 0)
count_per_op = 2;
/* do byte-swapping if it's not been done yet */
if (g_MemHasBeenBSwapped == 0)
{
swap_buffer(g_rom, 4, g_rom_size / 4);
g_MemHasBeenBSwapped = 1;
}
if (g_DDMemHasBeenBSwapped == 0)
{
swap_buffer(g_ddrom, 4, g_ddrom_size / 4);
g_DDMemHasBeenBSwapped = 1;
}
connect_all(&g_r4300, &g_dp, &g_sp,
&g_ai, &g_pi, &g_ri, &g_si, &g_vi, &g_dd,
g_rdram, (disable_extra_mem == 0) ? 0x800000 : 0x400000,
g_rom, g_rom_size, g_ddrom, g_ddrom_size, g_dd_disk, g_dd_disk_size);
init_memory();
// Attach rom to plugins
printf("Gfx RomOpen.\n");
if (!gfx.romOpen())
{
printf("Gfx RomOpen failed.\n");
return M64ERR_PLUGIN_FAIL;
}
printf("Input RomOpen.\n");
if (!input.romOpen())
{
printf("Input RomOpen failed.\n");
gfx.romClosed();
return M64ERR_PLUGIN_FAIL;
}
/* connect external time source to AF_RTC component */
g_si.pif.af_rtc.user_data = NULL;
g_si.pif.af_rtc.get_time = get_time_using_C_localtime;
/* connect external game controllers */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].user_data = &channels[i];
g_si.pif.controllers[i].is_connected = egcvip_is_connected;
g_si.pif.controllers[i].get_input = egcvip_get_input;
}
/* connect external rumblepaks */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].rumblepak.user_data = &channels[i];
g_si.pif.controllers[i].rumblepak.rumble = rvip_rumble;
}
/* connect saved_memory.mempacks to mempaks */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].mempak.user_data = NULL;
g_si.pif.controllers[i].mempak.save = dummy_save;
g_si.pif.controllers[i].mempak.data = &saved_memory.mempack[i][0];
}
/* connect saved_memory.eeprom to eeprom */
g_si.pif.eeprom.user_data = NULL;
g_si.pif.eeprom.save = dummy_save;
g_si.pif.eeprom.data = saved_memory.eeprom;
if (ROM_SETTINGS.savetype != EEPROM_16KB)
{
/* 4kbits EEPROM */
g_si.pif.eeprom.size = 0x200;
g_si.pif.eeprom.id = 0x8000;
}
else
{
/* 16kbits EEPROM */
g_si.pif.eeprom.size = 0x800;
g_si.pif.eeprom.id = 0xc000;
}
/* connect saved_memory.flashram to flashram */
g_pi.flashram.user_data = NULL;
g_pi.flashram.save = dummy_save;
g_pi.flashram.data = saved_memory.flashram;
/* connect saved_memory.sram to SRAM */
g_pi.sram.user_data = NULL;
g_pi.sram.save = dummy_save;
g_pi.sram.data = saved_memory.sram;
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
r4300_init();
return M64ERR_SUCCESS;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_run(void)
{
DebugMessage(M64MSG_STATUS, "Main Run!");
VILimit = (float) GetVILimit();
VILimitMilliseconds = (double) 1000.0/VILimit;
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
/* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
event_initialize();
// initialize memory, and do byte-swapping if it's not been done yet
if (g_MemHasBeenBSwapped == 0)
{
init_memory(1);
g_MemHasBeenBSwapped = 1;
}
else
{
init_memory(0);
}
// Attach rom to plugins
if (!romOpen_gfx())
{
free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Graphics Plugin Opened!");
if (!romOpen_audio())
{
romClosed_gfx(); free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Audio Plugin Opened!");
if (!romOpen_input())
{
romClosed_audio(); romClosed_gfx(); free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Input Plugin Opened!");
printf("Plugins opened!\n");fflush(stdout);
#ifdef WITH_LIRC
lircStart();
#endif // WITH_LIRC
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
//PumpEvents();
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
DebugMessage(M64MSG_STATUS, "Starting to reset r4300!");fflush(stdout);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
DebugMessage(M64MSG_STATUS, "About to execute!");
fflush(stdout);
r4300_execute();
#ifdef WITH_LIRC
lircStop();
#endif // WITH_LIRC
#ifdef DBG
if (g_DebuggerActive)
destroy_debugger();
#endif
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
free_memory();
// clean up
g_EmulatorRunning = 0;
StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
//PDL_Quit();
SDL_Quit();
return M64ERR_SUCCESS;
}