s32 CALLBACK PADinit(u32 flags) {
#ifdef PAD_LOG
if (padLog == NULL) {
padLog = fopen("logs/padLog.txt", "w");
if (padLog) setvbuf(padLog, NULL, _IONBF, 0);
}
PAD_LOG("PADinit\n");
#endif
pads|= flags;
status[0] = 0xffff;
status[1] = 0xffff;
#ifdef __LINUX__
char strcurdir[256];
getcwd(strcurdir, 256);
s_strIniPath = strcurdir;
s_strIniPath += "/inis/zeropad.ini";
#endif
LoadConfig();
PADsetMode(0, 0);
PADsetMode(1, 0);
pressure = 100;
for(int i = 0; i < 2; ++i) {
g_ranalog[i].x = 0x80;
g_ranalog[i].y = 0x80;
g_lanalog[i].x = 0x80;
g_lanalog[i].y = 0x80;
}
return 0;
}
static int StartRecord()
{
fpMovie = fopen(Movie.movieFilename,"w+b");
Movie.bytesPerFrame = SetBytesPerFrame(Movie);
PadDataS epadd; //empty pad;
epadd.buttonStatus = 0xffff;
epadd.padding = 0;
epadd.leftJoyX = 128;
epadd.leftJoyY = 128;
epadd.rightJoyX = 128;
epadd.rightJoyY = 128;
epadd.moveX = 0;
epadd.moveY = 0;
for (int i = 0; i < 4; i++)
{
memcpy(&Movie.lastPads1[i], &epadd, sizeof(epadd));
memcpy(&Movie.lastPads2[i], &epadd, sizeof(epadd));
}
Movie.rerecordCount = 0;
Movie.readOnly = 0;
Movie.CdromCount = 1;
sprintf(Movie.CdromIds, "%9.9s", CdromId);
WriteMovieHeader();
Movie.inputBufferPtr = Movie.inputBuffer;
ResetPads();
PADsetMode (0, (Movie.padType1 == 7) ? 1:0);
PADsetMode (1, (Movie.padType2 == 7) ? 1:0);
return 1;
}
long PADinit(long flags) {
LoadPADConfig();
PADsetMode(0, 0);
PADsetMode(1, 0);
gpuVisualVibration = NULL;
return PSE_PAD_ERR_SUCCESS;
}
static int StartReplay()
{
uint32 toRead;
Movie.bytesPerFrame = SetBytesPerFrame(Movie);
Config.PsxType = Movie.palTiming;
if (Movie.saveStateIncluded)
LoadStateEmbed(Movie.movieFilename);
if (Movie.cheatListIncluded)
CHT_LoadCheatFileEmbed(Movie.movieFilename);
else
CHT_ClearCheatFileEmbed();
if (Movie.memoryCardIncluded)
SIO_LoadMemoryCardsEmbed(Movie.movieFilename);
else
SIO_ClearMemoryCardsEmbed();
// fill input buffer
fpMovie = fopen(Movie.movieFilename,"r+b");
{
fseek(fpMovie, Movie.inputOffset, SEEK_SET);
Movie.inputBufferPtr = Movie.inputBuffer;
toRead = Movie.bytesPerFrame * (Movie.totalFrames);
ReserveInputBufferSpace(toRead);
fread(Movie.inputBufferPtr, 1, toRead, fpMovie);
if (Movie.inputBufferPtr == 0)
return 0;
}
if (Movie.UsingAnalogHack)
{
Config.UsingAnalogHack = true;
}
else
{
Config.UsingAnalogHack = false;
}
if (Movie.UsingRCntFix)
{
Config.RCntFix = 1;
}
else
{
Config.RCntFix = 0;
}
ResetPads();
PADsetMode (0, (Movie.padType1 == 7)? 1:0);
PADsetMode (1, (Movie.padType2 == 7)? 1:0);
return 1;
}
long SSS_PADopen (void *p)
{
if (!pad_initialized)
{
memset (&global, 0, sizeof (global));
memset( &lastport1, 0, sizeof(lastport1) ) ;
memset( &lastport2, 0, sizeof(lastport2) ) ;
global.padStat[0] = 0xffff;
global.padStat[1] = 0xffff;
PADsetMode (0, controllerType == CONTROLLERTYPE_ANALOG ? 1 : 0); //port 0, analog
PADsetMode (1, controllerType == CONTROLLERTYPE_ANALOG ? 1 : 0); //port 1, analog
}
return 0;
}
static void UpdateInput(void) {
int pad;
if (!g.cfg.Threaded) CheckJoy();
for(pad = 0; pad < 2; pad++) {
if(g.PadState[pad].PadModeSwitch) {
g.PadState[pad].PadModeSwitch = 0;
PADsetMode(pad, 1 - g.PadState[pad].PadMode);
}
}
CheckKeyboard();
}
static void UpdateState (const int pad) //Note: pad = 0 or 1
{
const int vib0 = global.padVibF[pad][0] ? 1 : 0;
const int vib1 = global.padVibF[pad][1] ? 1 : 0;
static BUTTONS PAD_Data;
//TODO: Rework/simplify the following code & reset BUTTONS when no controller in use
int Control = pad;
#if defined(WII) && !defined(NO_BT)
//Need to switch between Classic and WiimoteNunchuck if user swapped extensions
if (padType[virtualControllers[Control].number] == PADTYPE_WII)
{
if (virtualControllers[Control].control == &controller_Classic &&
!controller_Classic.available[virtualControllers[Control].number] &&
controller_WiimoteNunchuk.available[virtualControllers[Control].number])
assign_controller(Control, &controller_WiimoteNunchuk, virtualControllers[Control].number);
else if (virtualControllers[Control].control == &controller_WiimoteNunchuk &&
!controller_WiimoteNunchuk.available[virtualControllers[Control].number] &&
controller_Classic.available[virtualControllers[Control].number])
assign_controller(Control, &controller_Classic, virtualControllers[Control].number);
}
#endif
if (global.padMode1[pad] != controllerType)
PADsetMode( pad, controllerType == CONTROLLERTYPE_ANALOG ? 1 : 0);
if(virtualControllers[Control].inUse)
{
if(DO_CONTROL(Control, GetKeys, (BUTTONS*)&PAD_Data, virtualControllers[Control].config))
stop = 1;
}
else
{ //TODO: Emulate no controller present in this case.
//Reset buttons & sticks if PAD is not in use
PAD_Data.btns.All = 0xFFFF;
PAD_Data.leftStickX = PAD_Data.leftStickY = PAD_Data.rightStickX = PAD_Data.rightStickY = 128;
}
global.padStat[pad] = (((PAD_Data.btns.All>>8)&0xFF) | ( (PAD_Data.btns.All<<8) & 0xFF00 )) &0xFFFF;
if (pad==0)
{
lastport1.leftJoyX = PAD_Data.leftStickX; lastport1.leftJoyY = PAD_Data.leftStickY;
lastport1.rightJoyX = PAD_Data.rightStickX; lastport1.rightJoyY = PAD_Data.rightStickY;
lastport1.buttonStatus = global.padStat[pad];
}
else
{
lastport2.leftJoyX = PAD_Data.leftStickX; lastport2.leftJoyY = PAD_Data.leftStickY;
lastport2.rightJoyX = PAD_Data.rightStickX; lastport2.rightJoyY = PAD_Data.rightStickY;
lastport2.buttonStatus = global.padStat[pad];
}
/* Small Motor */
if ((global.padVibF[pad][2] != vib0) )
{
global.padVibF[pad][2] = vib0;
DO_CONTROL(pad, rumble, global.padVibF[pad][0]);
}
/* Big Motor */
if ((global.padVibF[pad][3] != vib1) )
{
global.padVibF[pad][3] = vib1;
DO_CONTROL(pad, rumble, global.padVibF[pad][1]);
}
}
unsigned char SSS_PADpoll (const unsigned char value)
{
const int pad = global.curPad;
const int cur = global.curByte;
static u8 buf[20];
if (cur == 0)
{
global.curByte++;
global.curCmd = value;
switch (value)
{
case 0x40:
global.cmdLen = sizeof (cmd40);
memcpy (buf, cmd40, sizeof (cmd40));
return 0xf3;
case 0x41:
global.cmdLen = sizeof (cmd41);
memcpy (buf, cmd41, sizeof (cmd41));
return 0xf3;
case 0x42:
case 0x43:
if (value == 0x42) UpdateState (pad);
global.cmdLen = 2 + 2 * (global.padID[pad] & 0x0f);
buf[1] = global.padModeC[pad] ? 0x00 : 0x5a;
*(u16*)&buf[2] = global.padStat[pad];
if (value == 0x43 && global.padModeE[pad])
{
buf[4] = 0;
buf[5] = 0;
buf[6] = 0;
buf[7] = 0;
return 0xf3;
}
else
{
buf[ 4] = pad ? lastport2.rightJoyX : lastport1.rightJoyX ;
buf[ 5] = pad ? lastport2.rightJoyY : lastport1.rightJoyY ;
buf[ 6] = pad ? lastport2.leftJoyX : lastport1.leftJoyX ;
buf[ 7] = pad ? lastport2.leftJoyY : lastport1.leftJoyY ;
if (global.padID[pad] == 0x79)
{
// do some pressure stuff (this is for PS2 only!)
}
return (u8)global.padID[pad];
}
break;
case 0x44:
global.cmdLen = sizeof (cmd44);
memcpy (buf, cmd44, sizeof (cmd44));
return 0xf3;
case 0x45:
global.cmdLen = sizeof (cmd45);
memcpy (buf, cmd45, sizeof (cmd45));
buf[4] = (u8)global.padMode1[pad];
return 0xf3;
case 0x46:
global.cmdLen = sizeof (cmd46);
memcpy (buf, cmd46, sizeof (cmd46));
return 0xf3;
case 0x47:
global.cmdLen = sizeof (cmd47);
memcpy (buf, cmd47, sizeof (cmd47));
return 0xf3;
case 0x4c:
global.cmdLen = sizeof (cmd4c);
memcpy (buf, cmd4c, sizeof (cmd4c));
return 0xf3;
case 0x4d:
global.cmdLen = sizeof (cmd4d);
memcpy (buf, cmd4d, sizeof (cmd4d));
return 0xf3;
case 0x4f:
global.padID[pad] = 0x79;
global.padMode2[pad] = 1;
global.cmdLen = sizeof (cmd4f);
memcpy (buf, cmd4f, sizeof (cmd4f));
return 0xf3;
}
}
switch (global.curCmd)
{
case 0x42:
if (cur == global.padVib0[pad])
global.padVibF[pad][0] = value;
if (cur == global.padVib1[pad])
global.padVibF[pad][1] = value;
break;
case 0x43:
if (cur == 2)
{
global.padModeE[pad] = value; // cmd[3]==1 ? enter : exit escape mode
global.padModeC[pad] = 0;
}
break;
case 0x44:
if (cur == 2)
PADsetMode (pad, value); // cmd[3]==1 ? analog : digital
if (cur == 3)
global.padModeF[pad] = (value == 3); //cmd[4]==3 ? lock : don't log analog/digital button
break;
case 0x46:
if (cur == 2)
{
switch(value)
{
case 0:
buf[5] = 0x02;
buf[6] = 0x00;
buf[7] = 0x0A;
break;
case 1:
buf[5] = 0x01;
buf[6] = 0x01;
buf[7] = 0x14;
break;
}
}
break;
case 0x4c:
if (cur == 2)
{
static const u8 buf5[] = { 0x04, 0x07, 0x02, 0x05 };
buf[5] = buf5[value & 3];
}
break;
case 0x4d:
if (cur >= 2)
{
if (cur == global.padVib0[pad])
buf[cur] = 0x00;
if (cur == global.padVib1[pad])
buf[cur] = 0x01;
if (value == 0x00)
{
global.padVib0[pad] = cur;
if ((global.padID[pad] & 0x0f) < (cur - 1) / 2)
global.padID[pad] = (global.padID[pad] & 0xf0) + (cur - 1) / 2;
}
else if (value == 0x01)
{
global.padVib1[pad] = cur;
if ((global.padID[pad] & 0x0f) < (cur - 1) / 2)
global.padID[pad] = (global.padID[pad] & 0xf0) + (cur - 1) / 2;
}
}
break;
}
if (cur >= global.cmdLen)
return 0;
return buf[global.curByte++];
}
