void event_initialize(void)
{
const char *event_str = NULL;
int i;
/* set initial state of all joystick commands to 'off' */
for (i = 0; i < NumJoyCommands; i++)
JoyCmdActive[i] = 0;
/* activate any joysticks which are referenced in the joystick event command strings */
for (i = 0; i < NumJoyCommands; i++)
{
event_str = ConfigGetParamString(g_CoreConfig, JoyCmdName[i]);
if (event_str != NULL && strlen(event_str) >= 4 && event_str[0] == 'J' && event_str[1] >= '0' && event_str[1] <= '9')
{
int device = event_str[1] - '0';
if (!SDL_WasInit(SDL_INIT_JOYSTICK))
SDL_InitSubSystem(SDL_INIT_JOYSTICK);
if (!SDL_JoystickOpened(device))
SDL_JoystickOpen(device);
}
}
/* set up SDL event filter and disable key repeat */
SDL_EnableKeyRepeat(0, 0);
SDL_SetEventFilter(event_sdl_filter);
}
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;
}
static char *GetNextScreenshotPath(void)
{
char *ScreenshotPath;
char ScreenshotFileName[20 + 8 + 1];
// generate the base name of the screenshot
// add the ROM name, convert to lowercase, convert spaces to underscores
strcpy(ScreenshotFileName, ROM_PARAMS.headername);
for (char *pch = ScreenshotFileName; *pch != '\0'; pch++)
*pch = (*pch == ' ') ? '_' : tolower(*pch);
strcat(ScreenshotFileName, "-###.png");
// add the base path to the screenshot file name
const char *SshotDir = ConfigGetParamString(g_CoreConfig, "ScreenshotPath");
if (SshotDir == NULL || *SshotDir == '\0')
{
// note the trick to avoid an allocation. we add a NUL character
// instead of the separator, call mkdir, then add the separator
ScreenshotPath = formatstr("%sscreenshot%c%s", ConfigGetUserDataPath(), '\0', ScreenshotFileName);
if (ScreenshotPath == NULL)
return NULL;
osal_mkdirp(ScreenshotPath, 0700);
ScreenshotPath[strlen(ScreenshotPath)] = OSAL_DIR_SEPARATORS[0];
}
else
{
ScreenshotPath = combinepath(SshotDir, ScreenshotFileName);
if (ScreenshotPath == NULL)
return NULL;
}
// patch the number part of the name (the '###' part) until we find a free spot
char *NumberPtr = ScreenshotPath + strlen(ScreenshotPath) - 7;
for (; CurrentShotIndex < 1000; CurrentShotIndex++)
{
sprintf(NumberPtr, "%03i.png", CurrentShotIndex);
FILE *pFile = fopen(ScreenshotPath, "r");
if (pFile == NULL)
break;
fclose(pFile);
}
if (CurrentShotIndex >= 1000)
{
DebugMessage(M64MSG_ERROR, "Can't save screenshot; folder already contains 1000 screenshots for this ROM");
return NULL;
}
CurrentShotIndex++;
return ScreenshotPath;
}
EXPORT const char * CALL ConfigGetSharedDataFilepath(const char *filename)
{
const char *configsharepath = NULL;
m64p_handle CoreHandle = NULL;
/* check input parameter */
if (filename == NULL) return NULL;
/* try to get the SharedDataPath string variable in the Core configuration section */
if (ConfigOpenSection("Core", &CoreHandle) == M64ERR_SUCCESS)
{
configsharepath = ConfigGetParamString(CoreHandle, "SharedDataPath");
}
return osal_get_shared_filepath(filename, l_DataDirOverride, configsharepath);
}
static void GetBaseFilepath(char *filepath, int maxlen)
{
const char *SshotDir = ConfigGetParamString(g_CoreConfig, "ScreenshotPath");
// sanity check input
if (filepath == NULL)
return;
if (maxlen < 32)
{
filepath[0] = 0;
return;
}
/* get the path to store screenshots */
strncpy(filepath, SshotDir, maxlen - 24);
filepath[maxlen-24] = 0;
if (strlen(filepath) == 0)
{
snprintf(filepath, maxlen - 24, "%sscreenshot%c", ConfigGetUserDataPath(), OSAL_DIR_SEPARATOR);
osal_mkdirp(filepath, 0700);
}
/* make sure there is a slash on the end of the pathname */
int pathlen = strlen(filepath);
if (pathlen > 0 && filepath[pathlen-1] != OSAL_DIR_SEPARATOR)
{
filepath[pathlen] = OSAL_DIR_SEPARATOR;
filepath[pathlen+1] = 0;
}
// add the game's name to the end, convert to lowercase, convert spaces to underscores
char *pch = filepath + strlen(filepath);
char ch;
strncpy(pch, (char*) ROM_HEADER->nom, 20);
pch[20] = '\0';
do
{
ch = *pch;
if (ch == ' ')
*pch++ = '_';
else
*pch++ = tolower(ch);
} while (ch != 0);
return;
}
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;
}
/** MatchJoyCommand
* This function processes an SDL event and updates the JoyCmdActive array if the
* event matches with the given command.
*
* If the event activates a joystick command which was not previously active, then
* a 1 is returned. If the event de-activates an command, a -1 is returned. Otherwise
* (if the event does not match the command or active status didn't change), a 0 is returned.
*/
static int MatchJoyCommand(const SDL_Event *event, eJoyCommand cmd)
{
const char *event_str = ConfigGetParamString(g_CoreConfig, JoyCmdName[cmd]);
int dev_number, input_number, input_value;
char axis_direction;
/* Empty string or non-joystick command */
if (event_str == NULL || strlen(event_str) < 4 || event_str[0] != 'J')
return 0;
/* Evaluate event based on type of joystick input expected by the given command */
switch (event_str[2])
{
/* Axis */
case 'A':
if (event->type != SDL_JOYAXISMOTION)
return 0;
if (sscanf(event_str, "J%dA%d%c", &dev_number, &input_number, &axis_direction) != 3)
return 0;
if (dev_number != event->jaxis.which || input_number != event->jaxis.axis)
return 0;
if (axis_direction == '+')
{
if (event->jaxis.value >= 15000 && JoyCmdActive[cmd] == 0)
{
JoyCmdActive[cmd] = 1;
return 1;
}
else if (event->jaxis.value <= 8000 && JoyCmdActive[cmd] == 1)
{
JoyCmdActive[cmd] = 0;
return -1;
}
return 0;
}
else if (axis_direction == '-')
{
if (event->jaxis.value <= -15000 && JoyCmdActive[cmd] == 0)
{
JoyCmdActive[cmd] = 1;
return 1;
}
else if (event->jaxis.value >= -8000 && JoyCmdActive[cmd] == 1)
{
JoyCmdActive[cmd] = 0;
return -1;
}
return 0;
}
else return 0; /* invalid axis direction in configuration parameter */
break;
/* Hat */
case 'H':
if (event->type != SDL_JOYHATMOTION)
return 0;
if (sscanf(event_str, "J%dH%dV%d", &dev_number, &input_number, &input_value) != 3)
return 0;
if (dev_number != event->jhat.which || input_number != event->jhat.hat)
return 0;
if ((event->jhat.value & input_value) == input_value && JoyCmdActive[cmd] == 0)
{
JoyCmdActive[cmd] = 1;
return 1;
}
else if ((event->jhat.value & input_value) != input_value && JoyCmdActive[cmd] == 1)
{
JoyCmdActive[cmd] = 0;
return -1;
}
return 0;
break;
/* Button. */
case 'B':
if (event->type != SDL_JOYBUTTONDOWN && event->type != SDL_JOYBUTTONUP)
return 0;
if (sscanf(event_str, "J%dB%d", &dev_number, &input_number) != 2)
return 0;
if (dev_number != event->jbutton.which || input_number != event->jbutton.button)
return 0;
if (event->type == SDL_JOYBUTTONDOWN && JoyCmdActive[cmd] == 0)
{
JoyCmdActive[cmd] = 1;
return 1;
}
else if (event->type == SDL_JOYBUTTONUP && JoyCmdActive[cmd] == 1)
{
JoyCmdActive[cmd] = 0;
return -1;
}
return 0;
break;
default:
/* bad configuration parameter */
return 0;
}
/* impossible to reach this point */
return 0;
}
