ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/libmupen64plus/mupen64plus-input-bkm/plugin.c

450 lines
15 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Mupen64plus-input-bkm - plugin.c *
* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
* Edited 2014 null_ptr *
* Copyright (C) 2008-2011 Richard Goedeken *
* Copyright (C) 2008 Tillin9 *
* Copyright (C) 2002 Blight *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M64P_PLUGIN_PROTOTYPES 1
#include "m64p_types.h"
#include "m64p_plugin.h"
#include "m64p_common.h"
#include "m64p_config.h"
#include "plugin.h"
#include "config.h"
#include "version.h"
#include "osal_dynamiclib.h"
#include <errno.h>
/* global data definitions */
SController controller[4]; // 4 controllers
/* static data definitions */
static void (*l_DebugCallback)(void *, int, const char *) = NULL;
static void *l_DebugCallContext = NULL;
static int l_PluginInit = 0;
/* Callbacks for data flow out of mupen */
static int (*l_inputCallback)(int i) = NULL;
static int (*l_setrumbleCallback)(int i, int on) = NULL;
static int romopen = 0; // is a rom opened
/* Global functions */
void DebugMessage(int level, const char *message, ...)
{
char msgbuf[1024];
va_list args;
if (l_DebugCallback == NULL)
return;
va_start(args, message);
vsprintf(msgbuf, message, args);
(*l_DebugCallback)(l_DebugCallContext, level, msgbuf);
va_end(args);
}
#pragma region (De-)Initialization
/* Mupen64Plus plugin functions */
EXPORT m64p_error CALL PluginStartup(m64p_dynlib_handle CoreLibHandle, void *Context,
void (*DebugCallback)(void *, int, const char *))
{
ptr_CoreGetAPIVersions CoreAPIVersionFunc;
int ConfigAPIVersion, DebugAPIVersion, VidextAPIVersion;
if (l_PluginInit)
return M64ERR_ALREADY_INIT;
/* first thing is to set the callback function for debug info */
l_DebugCallback = DebugCallback;
l_DebugCallContext = Context;
/* attach and call the CoreGetAPIVersions function, check Config API version for compatibility */
CoreAPIVersionFunc = (ptr_CoreGetAPIVersions) osal_dynlib_getproc(CoreLibHandle, "CoreGetAPIVersions");
if (CoreAPIVersionFunc == NULL)
{
DebugMessage(M64MSG_ERROR, "Core emulator broken; no CoreAPIVersionFunc() function found.");
return M64ERR_INCOMPATIBLE;
}
(*CoreAPIVersionFunc)(&ConfigAPIVersion, &DebugAPIVersion, &VidextAPIVersion, NULL);
if ((ConfigAPIVersion & 0xffff0000) != (CONFIG_API_VERSION & 0xffff0000))
{
DebugMessage(M64MSG_ERROR, "Emulator core Config API (v%i.%i.%i) incompatible with plugin (v%i.%i.%i)",
VERSION_PRINTF_SPLIT(ConfigAPIVersion), VERSION_PRINTF_SPLIT(CONFIG_API_VERSION));
return M64ERR_INCOMPATIBLE;
}
/* reset controllers */
memset(controller, 0, sizeof(controller));
l_PluginInit = 1;
return M64ERR_SUCCESS;
}
EXPORT m64p_error CALL PluginShutdown(void)
{
if (!l_PluginInit)
return M64ERR_NOT_INIT;
/* reset some local variables */
l_DebugCallback = NULL;
l_DebugCallContext = NULL;
l_PluginInit = 0;
memset(controller, 0, sizeof(controller));
return M64ERR_SUCCESS;
}
/******************************************************************
Function: InitiateControllers
Purpose: This function initialises how each of the controllers
should be handled.
input: - The handle to the main window.
- A controller structure that needs to be filled for
the emulator to know how to handle each controller.
output: none
*******************************************************************/
EXPORT void CALL InitiateControllers(CONTROL_INFO ControlInfo)
{
int i;
memset( controller, 0, sizeof(controller) );
for( i = 0; i < 4; i++ )
{
controller[i].control = ControlInfo.Controls + i;
controller[i].control->Plugin = PLUGIN_MEMPAK;
controller[i].control->Present = 1;
controller[i].control->RawData = 0;
}
DebugMessage(M64MSG_INFO, "%s version %i.%i.%i initialized.", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION));
}
/******************************************************************
Function: RomClosed
Purpose: This function is called when a rom is closed.
input: none
output: none
*******************************************************************/
EXPORT void CALL RomClosed(void)
{
romopen = 0;
}
/******************************************************************
Function: RomOpen
Purpose: This function is called when a rom is open. (from the
emulation thread)
input: none
output: none
*******************************************************************/
EXPORT int CALL RomOpen(void)
{
romopen = 1;
return 1;
}
#pragma endregion
EXPORT m64p_error CALL PluginGetVersion(m64p_plugin_type *PluginType, int *PluginVersion, int *APIVersion, const char **PluginNamePtr, int *Capabilities)
{
/* set version info */
if (PluginType != NULL)
*PluginType = M64PLUGIN_INPUT;
if (PluginVersion != NULL)
*PluginVersion = PLUGIN_VERSION;
if (APIVersion != NULL)
*APIVersion = INPUT_PLUGIN_API_VERSION;
if (PluginNamePtr != NULL)
*PluginNamePtr = PLUGIN_NAME;
if (Capabilities != NULL)
{
*Capabilities = 0;
}
return M64ERR_SUCCESS;
}
#pragma region Raw read and write
/* ----------------------------------------------------------------------
-------------------------- Controller CRC ----------------------------
---------------------------------------------------------------------- */
static unsigned char DataCRC( unsigned char *Data, int iLenght )
{
unsigned char Remainder = Data[0];
int iByte = 1;
unsigned char bBit = 0;
while( iByte <= iLenght )
{
int HighBit = ((Remainder & 0x80) != 0);
Remainder = Remainder << 1;
Remainder += ( iByte < iLenght && Data[iByte] & (0x80 >> bBit )) ? 1 : 0;
Remainder ^= (HighBit) ? 0x85 : 0;
bBit++;
iByte += bBit/8;
bBit %= 8;
}
return Remainder;
}
/******************************************************************
Function: ControllerCommand
Purpose: To process the raw data that has just been sent to a
specific controller.
input: - Controller Number (0 to 3) and -1 signalling end of
processing the pif ram.
- Pointer of data to be processed.
output: none
note: This function is only needed if the DLL is allowing raw
data, or the plugin is set to raw
the data that is being processed looks like this:
initilize controller: 01 03 00 FF FF FF
read controller: 01 04 01 FF FF FF FF
*******************************************************************/
EXPORT void CALL ControllerCommand(int Control, unsigned char *Command)
{
if( Control == -1)
return;
}
/* ----------------------------------------------------------------------
----------- Handles raw data read from a rumble pak -------------
----------- Data read at address C01B is 32x the status -------------
----------- Data read at address 8001 is 32x 0x80 -------------
---------------------------------------------------------------------- */
void DoRumblePakRead(int Control, unsigned char* Command)
{
if(Command[3] == 0x80 && Command[4] == 0x01)
memset(Command+5, 0x80, 32);
else if(Command[3] == 0xC0 && Command[4] == 0x1B)
memset(Command+5, controller[Control].rumbling, 32);
else
memset(Command+5, 0x00, 32);
}
/* ----------------------------------------------------------------------
----------- Writes data to rumble pak -------------
----------- If writes 0x01 to address 0xC01B rumble on -------------
----------- If writes 0x00 to address 0xC01B rumble off -------------
---------------------------------------------------------------------- */
void DoRumblePakWrite(int Control, unsigned char* Command)
{
if(Command[3] == 0xC0 && Command[4] == 0x1B)
{
controller[Control].rumbling = Command[5];
if(l_setrumbleCallback != NULL)
l_setrumbleCallback(Control, Command[5]);
}
}
/* ----------------------------------------------------------------------
----------- Does a raw read of a controller pak -------------
----------- Currently only handles rumble paks -------------
---------------------------------------------------------------------- */
void DoRawRead(int Control, unsigned char* Command)
{
switch(controller[Control].control->Plugin)
{
case PLUGIN_RUMBLE_PAK:
DoRumblePakRead(Control, Command);
break;
case PLUGIN_NONE:
case PLUGIN_RAW:
case PLUGIN_MEMPAK:
case PLUGIN_TRANSFER_PAK:
default:
break;
}
}
/* ----------------------------------------------------------------------
----------- Handles raw write to the controller pak -------------
----------- Currently only handles rumble paks -------------
---------------------------------------------------------------------- */
void DoRawWrite(int Control, unsigned char* Command)
{
switch(controller[Control].control->Plugin)
{
case PLUGIN_RUMBLE_PAK:
DoRumblePakWrite(Control, Command);
break;
case PLUGIN_NONE:
case PLUGIN_RAW:
case PLUGIN_MEMPAK:
case PLUGIN_TRANSFER_PAK:
default:
break;
}
}
/******************************************************************
Function: ReadController
Purpose: To process the raw data in the pif ram that is about to
be read.
input: - Controller Number (0 to 3) and -1 signalling end of
processing the pif ram.
- Pointer of data to be processed.
output: none
note: This function is only needed if the DLL is allowing raw
data.
*******************************************************************/
EXPORT void CALL ReadController(int Control, unsigned char *Command)
{
unsigned char * Data = Command + 5;
int value;
if(Control == -1)
return;
switch(Command[2])
{
case RD_RESETCONTROLLER:
case RD_GETSTATUS:
Command[3] = RD_GAMEPAD | RD_ABSOLUTE;
Command[4] = RD_NOEEPROM;
Command[5] = controller[Control].control->Plugin != PLUGIN_NONE;
break;
case RD_READKEYS:
value = l_inputCallback(Control);
*((int*)(Command+3)) = value;
break;
case RD_READPAK:
DoRawRead(Control, Command);
Data[32] = DataCRC(Data, 32);
break;
case RD_WRITEPAK:
DoRawWrite(Control, Command);
Data[32] = DataCRC(Data, 32);
break;
case RD_READEEPROM:
case RD_WRITEEPROM:
default:
break;
}
}
#pragma endregion
#pragma region Useless stubs
/* ----------------------------------------------------------------------
-------------------- This functions are not used --------------------
-------------------- Plugin api just expects them --------------------
-------------------- to exist --------------------
---------------------------------------------------------------------- */
/******************************************************************
Function: SDL_KeyDown
Purpose: To pass the SDL_KeyDown message from the emulator to the
plugin.
input: keymod and keysym of the SDL_KEYDOWN message.
output: none
*******************************************************************/
EXPORT void CALL SDL_KeyDown(int keymod, int keysym)
{
}
/******************************************************************
Function: SDL_KeyUp
Purpose: To pass the SDL_KeyUp message from the emulator to the
plugin.
input: keymod and keysym of the SDL_KEYUP message.
output: none
*******************************************************************/
EXPORT void CALL SDL_KeyUp(int keymod, int keysym)
{
}
#pragma endregion
/******************************************************************
Function: GetKeys
Purpose: To get the current state of the controllers buttons.
input: - Controller Number (0 to 3)
- A pointer to a BUTTONS structure to be filled with
the controller state.
output: none
*******************************************************************/
EXPORT void CALL GetKeys( int Control, BUTTONS *Keys )
{
Keys->Value = (*l_inputCallback)(Control);
}
/* ----------------------------------------------------------------------
----------- Sets callback to retrieve button and axis data -----------
---------------------------------------------------------------------- */
EXPORT void CALL SetInputCallback(int (*inputCallback)(int i))
{
l_inputCallback = inputCallback;
}
/* ----------------------------------------------------------------------
----------- Sets a callback to set rumble on and off -------------
---------------------------------------------------------------------- */
EXPORT void CALL SetRumbleCallback(void (*rumbleCallback)(int Control, int on))
{
}
/* ----------------------------------------------------------------------
----------- Sets the type of the controller pak -------------
----------- Possible values for type: -------------
----------- 1 - No pak inserted -------------
----------- 2 - Memory card -------------
----------- 3 - Rumble pak (no default implementation) -------------
----------- 4 - Transfer pak (no default implementation) -------------
----------- 5 - Raw data -------------
---------------------------------------------------------------------- */
EXPORT void CALL SetControllerPakType(int idx, int type)
{
controller[idx].control->Plugin = type;
controller[idx].control->RawData = (type != PLUGIN_MEMPAK);
}
/* ----------------------------------------------------------------------
----------- Sets if a controller is connected -------------
---------------------------------------------------------------------- */
EXPORT void CALL SetControllerConnected(int idx, int connected)
{
controller[idx].control->Present = connected;
}
Reference in New Issue View Git Blame Copy Permalink