void IN_Frame (void)
{
/*
IN_JoyMove();
if ( cls.keyCatchers || cls.state != CA_ACTIVE ) {
// temporarily deactivate if not in the game and
// running on the desktop
// voodoo always counts as full screen
// if (Cvar_VariableValue ("r_fullscreen") == 0
// && strcmp( Cvar_VariableString("r_glDriver"), _3DFX_DRIVER_NAME ) ) {
// IN_DeactivateMouse ();
// return;
// }
if (dpy && !autorepeaton) {
XAutoRepeatOn(dpy);
autorepeaton = qtrue;
}
} else if (dpy && autorepeaton) {
XAutoRepeatOff(dpy);
autorepeaton = qfalse;
}
*/
IN_ActivateMouse();
// post events to the system que
IN_MouseMove();
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
IN_MouseMove (cmd);
if (ActiveApp)
IN_JoyMove (cmd);
}
/*
==================
IN_Frame
Called every frame, even if not generating commands
==================
*/
void IN_Frame(void)
{
// post joystick events
IN_JoyMove();
if(!s_wmv.mouseInitialized)
{
return;
}
if(cls.keyCatchers & KEYCATCH_CONSOLE)
{
// temporarily deactivate if not in the game and
// running on the desktop
// voodoo always counts as full screen
if(Cvar_VariableValue("r_fullscreen") == 0 && strcmp(Cvar_VariableString("r_glDriver"), _3DFX_DRIVER_NAME))
{
IN_DeactivateMouse();
return;
}
}
if(!in_appactive)
{
IN_DeactivateMouse();
return;
}
IN_ActivateMouse();
// post events to the system que
IN_MouseMove();
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
if (ActiveApp) // jit/Echon - fix mouse recentering when clicking out of game.
{
IN_MouseMove(cmd);
IN_JoyMove(cmd);
}
}
void IN_Move (usercmd_t *cmd)
{
if (ActiveApp && !Minimized)
{
IN_MouseMove (cmd);
IN_JoyMove (cmd);
}
}
/*
===========
IN_Move
===========
*/
void IN_Move ( float frametime, float ioRotationDeltas[3], float ioTranslationDeltas[3])
{
if ( !iMouseInUse && mouseactive )
{
IN_MouseMove ( frametime, ioRotationDeltas, ioTranslationDeltas);
}
IN_JoyMove ( frametime, ioRotationDeltas, ioTranslationDeltas);
}
/*
===========
IN_Move
===========
*/
void IN_Move ( float frametime, usercmd_t *cmd)
{
if ( !iMouseInUse && mouseactive )
{
IN_MouseMove ( frametime, cmd);
}
IN_JoyMove ( frametime, cmd);
}
void IN_Move (usercmd_t *cmd)
{
IN_MouseMove (cmd);
IN_WmoteMove (cmd);
IN_NunchukMove (cmd);
IN_GCPadMove (cmd);
IN_GCPadMainStickMove (cmd);
IN_ClsCtMove (cmd);
IN_ClsCtLeftStickMove (cmd);
}
/*
* CL_UpdateCommandInput
*/
void CL_UpdateCommandInput( void )
{
static unsigned old_keys_frame_time;
usercmd_t *cmd = &cl.cmds[cls.ucmdHead & CMD_MASK];
vec3_t movement;
if( cl.inputRefreshed )
return;
keys_frame_time = ( sys_frame_time - old_keys_frame_time ) & 255;
VectorSet( movement, 0.0f, 0.0f, 0.0f );
// always let the mouse refresh cl.viewangles
IN_MouseMove( cmd );
CL_AddButtonBits( &cmd->buttons );
if( cls.key_dest == key_game )
CL_GameModule_AddViewAngles( cl.viewangles, cls.realframetime, cl_flip->integer != 0 );
if( keys_frame_time )
{
cmd->msec += keys_frame_time;
CL_AddAnglesFromKeys( keys_frame_time );
CL_AddMovementFromKeys( movement );
if( cls.key_dest == key_game )
CL_GameModule_AddMovement( movement );
cmd->sidemove += keys_frame_time * bound( -1.0f, movement[0], 1.0f ) * (cl_flip->integer ? -1.0 : 1.0);
cmd->forwardmove += keys_frame_time * bound( -1.0f, movement[1], 1.0f );
cmd->upmove += keys_frame_time * bound( -1.0f, movement[2], 1.0f );
old_keys_frame_time = sys_frame_time;
}
if( cmd->msec )
{
cmd->forwardfrac = ( (float)cmd->forwardmove/(float)cmd->msec );
cmd->sidefrac = ( (float)cmd->sidemove/(float)cmd->msec );
cmd->upfrac = ( (float)cmd->upmove/(float)cmd->msec );
}
cmd->angles[0] = ANGLE2SHORT( cl.viewangles[0] );
cmd->angles[1] = ANGLE2SHORT( cl.viewangles[1] );
cmd->angles[2] = ANGLE2SHORT( cl.viewangles[2] );
cl.inputRefreshed = true;
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
if (cl.v.cameramode) // Stuck in a different camera so don't move
{
memset (cmd, 0, sizeof(*cmd));
return;
}
if (mouseactive)
{
IN_MouseMove (cmd);
}
if (ActiveApp)
IN_JoyMove (cmd);
}
void IN_Move (usercmd_t *cmd)
{
static struct timeval old_tv = {0, 0};
struct timeval tv;
static long old_mouserate = 0;
long usec, mouserate;
if (m_showrate.value && (mx || my)) {
gettimeofday(&tv, NULL);
usec = (tv.tv_sec - old_tv.tv_sec) * 1000000L + (tv.tv_usec - old_tv.tv_usec);
mouserate = usec ? 1000000L / usec : old_mouserate;
Com_Printf("mouse rate: %4ld\n", (mouserate + old_mouserate) / 2);
old_tv = tv;
old_mouserate = mouserate;
}
IN_MouseMove (cmd);
}
/*
* CL_UpdateCommandInput
*/
void CL_UpdateCommandInput( void )
{
static unsigned old_keys_frame_time;
usercmd_t *cmd = &cl.cmds[cls.ucmdHead & CMD_MASK];
if( cl.inputRefreshed )
return;
keys_frame_time = ( sys_frame_time - old_keys_frame_time ) & 255;
// always let the mouse refresh cl.viewangles
IN_MouseMove( cmd );
CL_AddButtonBits( &cmd->buttons );
CL_GameModule_TouchMove( cmd, cl.viewangles, keys_frame_time );
if( keys_frame_time )
{
cmd->msec += keys_frame_time;
CL_AddAnglesFromKeys( keys_frame_time );
CL_AddMovementFromKeys( &cmd->forwardmove, &cmd->sidemove, &cmd->upmove, keys_frame_time );
IN_JoyMove( cmd, keys_frame_time );
old_keys_frame_time = sys_frame_time;
}
if( cmd->msec )
{
cmd->forwardfrac = ( (float)cmd->forwardmove/(float)cmd->msec );
cmd->sidefrac = ( (float)cmd->sidemove/(float)cmd->msec );
cmd->upfrac = ( (float)cmd->upmove/(float)cmd->msec );
}
cmd->angles[0] = ANGLE2SHORT( cl.viewangles[0] );
cmd->angles[1] = ANGLE2SHORT( cl.viewangles[1] );
cmd->angles[2] = ANGLE2SHORT( cl.viewangles[2] );
cl.inputRefreshed = qtrue;
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
#if USE_JOYSTICK
Uint8 appState = SDL_GetAppState(); // make the one in sys_unix
// global and use??
#endif /* USE_JOYSTICK */
if (cl.v.cameramode) // Stuck in a different camera so don't move
{
memset (cmd, 0, sizeof(*cmd));
return;
}
if (mouseactive)
{
IN_MouseMove (cmd);
}
#if USE_JOYSTICK
if (appState & SDL_APPACTIVE)
IN_JoyMove (cmd);
#endif /* USE_JOYSTICK */
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
if (vid_activewindow && !vid_hiddenwindow)
IN_MouseMove(cmd);
}
static struct InputEvent *IN_KeyboardHandlerFunc()
{
struct InputEvent *moo = (struct InputEvent *)REG_A0;
struct inputdata *id = (struct inputdata *)REG_A1;
#else
HANDLERPROTO(IN_KeyboardHandler, struct InputEvent *, struct InputEvent *moo, APTR id)
{
#endif
struct InputEvent *coin;
ULONG screeninfront;
if (!window || !(window->Flags & WFLG_WINDOWACTIVE))
return moo;
if (window->WScreen)
{
#ifdef __MORPHOS__
if (IntuitionBase->LibNode.lib_Version > 50 || (IntuitionBase->LibNode.lib_Version == 50 && IntuitionBase->LibNode.lib_Revision >= 56))
GetAttr(SA_Displayed, window->WScreen, &screeninfront);
else
#endif
screeninfront = (window->WScreen == IntuitionBase->FirstScreen);
}
else
screeninfront = 1;
for (coin = moo; coin; coin = coin->ie_NextEvent)
{
if (coin->ie_Class == IECLASS_RAWKEY)
{
int code;
// mouse button 4, mouse wheel and keyboard
code = coin->ie_Code & ~IECODE_UP_PREFIX;
if (code >= NM_WHEEL_UP && code <= NM_BUTTON_FOURTH)
{
// we don't need these, they will be handled under IECLASS_NEWMOUSE
/*if (mouseactive && screeninfront)
{
IN_AddEvent(coin);
coin->ie_Code = IECODE_NOBUTTON;
}*/
}
else
{
IN_AddEvent(coin);
}
}
else if (coin->ie_Class == IECLASS_RAWMOUSE && mouseactive && screeninfront)
{
// mouse buttons 1-3
if (coin->ie_Code != IECODE_NOBUTTON)
{
IN_AddEvent(coin);
coin->ie_Code = IECODE_NOBUTTON;
}
// mouse movement
mx += coin->ie_position.ie_xy.ie_x;
my += coin->ie_position.ie_xy.ie_y;
coin->ie_position.ie_xy.ie_x = 0;
coin->ie_position.ie_xy.ie_y = 0;
}
else if (coin->ie_Class == IECLASS_NEWMOUSE && mouseactive && screeninfront)
{
// mouse button 4, mouse wheel
IN_AddEvent(coin);
coin->ie_Code = IECODE_NOBUTTON;
}
}
return moo;
}
//MakeHandlerPri(InputHandler, &IN_KeyboardHandler, "Hexen II input handler", NULL, 100);
/*
===========
IN_Init
===========
*/
void IN_Init (void)
{
static char handler_name[] = "Hexen II input handler";
/* mouse variables */
Cvar_RegisterVariable (&m_filter);
/* joystick variables */
Cvar_RegisterVariable (&in_joystick);
Cvar_RegisterVariable (&joy_index);
Cvar_SetCallback (&in_joystick, IN_Callback_JoyEnable);
Cvar_SetCallback (&joy_index, IN_Callback_JoyIndex);
Cmd_AddCommand ("force_centerview", Force_CenterView_f);
pointermem = (UWORD *) AllocVec(2 * 6, MEMF_CHIP | MEMF_CLEAR);
IN_StartupMouse ();
IN_StartupJoystick ();
imsglow = imsghigh = 0;
inputport = CreateMsgPort();
if (inputport)
{
//inputreq = (struct IOStdReq *) CreateIORequest(inputport, sizeof(*inputreq));
inputreq = CreateStdIO(inputport);
if (inputreq)
{
if (!OpenDevice("input.device", 0, (struct IORequest *)inputreq, 0))
{
InputHandler.is_Node.ln_Type = NT_INTERRUPT;
InputHandler.is_Node.ln_Pri = 100;
InputHandler.is_Node.ln_Name = handler_name;
InputHandler.is_Code = (void (*)())&IN_KeyboardHandler;
inputreq->io_Data = (void *)&InputHandler;
inputreq->io_Command = IND_ADDHANDLER;
DoIO((struct IORequest *)inputreq);
return;
}
//DeleteIORequest(inputreq);
DeleteStdIO(inputreq);
}
DeleteMsgPort(inputport);
}
Sys_Error ("Couldn't install input handler");
}
/*
===========
IN_Shutdown
===========
*/
void IN_Shutdown (void)
{
if (inputreq)
{
inputreq->io_Data = (void *)&InputHandler;
inputreq->io_Command = IND_REMHANDLER;
DoIO((struct IORequest *)inputreq);
CloseDevice((struct IORequest *)inputreq);
//DeleteIORequest(inputreq);
DeleteStdIO(inputreq);
}
if (inputport)
{
DeleteMsgPort(inputport);
}
IN_DeactivateMouse ();
/*IN_ShowMouse ();*/
if (pointermem)
{
FreeVec(pointermem);
}
mouseinitialized = false;
if (LowLevelBase)
{
CloseLibrary(LowLevelBase);
LowLevelBase = NULL;
}
joy_port = -1;
joy_available = 0;
oldjoyflag = 0;
#ifdef __CLIB2__
if (KeymapBase) {
CloseLibrary(KeymapBase);
KeymapBase = NULL;
}
#endif
}
/*
===========
IN_ReInit
===========
*/
void IN_ReInit (void)
{
IN_StartupMouse ();
}
/*
===========
IN_MouseMove
===========
*/
static void IN_MouseMove (usercmd_t *cmd/*, int mx, int my*/)
{
if (m_filter.integer)
{
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
}
else
{
mouse_x = mx;
mouse_y = my;
}
old_mouse_x = mx;
old_mouse_y = my;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
/* add mouse X/Y movement to cmd */
if ( (in_strafe.state & 1) || (lookstrafe.integer && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
if (in_mlook.state & 1)
{
if (mx || my)
V_StopPitchDrift ();
}
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
}
else
{
if ((in_strafe.state & 1) && (cl.v.movetype == MOVETYPE_NOCLIP))
cmd->upmove -= m_forward.value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
}
if (cl.idealroll == 0) /* Did keyboard set it already?? */
{
if (cl.v.movetype == MOVETYPE_FLY)
{
if (mouse_x < 0)
cl.idealroll = -10;
else if (mouse_x > 0)
cl.idealroll = 10;
}
}
}
static void IN_DiscardMove (void)
{
if (mouseinitialized)
{
mx = my = old_mouse_x = old_mouse_y = 0;
}
}
/*
===========
IN_Move
===========
*/
void IN_Move (usercmd_t *cmd)
{
if (cl.v.cameramode)
{
/* stuck in a different camera so don't move */
memset (cmd, 0, sizeof(*cmd));
/* ignore any mouse movements in camera mode */
IN_DiscardMove ();
return;
}
if (mx != 0 || my != 0)
{
IN_MouseMove (cmd/*, x, y*/);
mx = my = 0;
}
}
static const char *JoystickName(int port)
{
ULONG joyflag = ReadJoyPort(port);
switch (joyflag & JP_TYPE_MASK)
{
case JP_TYPE_GAMECTLR:
return "game controller";
case JP_TYPE_JOYSTK:
return "joystick controller";
case JP_TYPE_MOUSE:
return "mouse";
case JP_TYPE_NOTAVAIL:
return "not available";
case JP_TYPE_UNKNOWN:
return "unknown device";
default:
return "<unknown>";
}
}
void IN_Move (usercmd_t *cmd)
{
IN_MouseMove (cmd);
}
void IN_Move (usercmd_t *cmd)
{
#ifdef FLASH
IN_MouseMove(cmd);
#endif
}
