ref: 27c74d8b6747a01ae353e06f64e54f017382be6c
dir: /Game/src/control.c/
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
This file is part of Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D 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
aint32_t with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
*/
//-------------------------------------------------------------------------
#include "duke3d.h"
#include "control.h"
#include "mouse.h"
#include "joystick.h"
//***************************************************************************
//
// GLOBALS
//
//***************************************************************************
// FIX_00018: Removed the "smoothmouse" option. This was just a bad fix. Mouse is now faster,
// smoother.
// extern int g_CV_EnableSmoothMouse;
// extern int g_CV_SmoothMouseSensX;
// extern int g_CV_SmoothMouseSensY;
uint32 CONTROL_RudderEnabled;
boolean CONTROL_MousePresent;
boolean CONTROL_JoysPresent[ MaxJoys ];
boolean CONTROL_MouseEnabled;
boolean CONTROL_JoystickEnabled;
byte CONTROL_JoystickPort;
uint32 CONTROL_MouseButtonState1;
uint32 CONTROL_MouseButtonState2;
// FIX_00019: DigitalAxis Handling now supported. (cool for medkit use)
uint32 CONTROL_MouseDigitalAxisState1;
uint32 CONTROL_MouseDigitalAxisState2;
//uint32 CONTROL_ButtonHeldState1;
//uint32 CONTROL_ButtonHeldState2;
uint32 CONTROL_JoyButtonState1;
uint32 CONTROL_JoyButtonState2;
uint32 CONTROL_JoyHatState1; //[MAXJOYHATS];
uint32 CONTROL_JoyHatState2; //[MAXJOYHATS];
static short mouseButtons = 0;
static short lastmousebuttons = 0;
static short joyHats[MAXJOYHATS];
static short lastjoyHats[MAXJOYHATS];
static int32 mousePositionX = 0;
static int32 mousePositionY = 0;
static int32 mouseRelativeX = 0;
static int32 mouseRelativeY = 0;
//***************************************************************************
//
// FUNCTIONS
//
//***************************************************************************
// Joystick/Gamepad bindings
static int32 JoyAxisMapping[MAXJOYAXES];
static int32 JoyHatMapping[MAXJOYHATS][8];
static int32 JoyButtonMapping[MAXJOYBUTTONS];
static float JoyAnalogScale[MAXJOYAXES];
static int32 JoyAnalogDeadzone[MAXJOYAXES];
int ACTION(int i)
{
//Keyboard input
if( (KB_KeyDown[KeyMapping[i].key1]) ||
(KB_KeyDown[KeyMapping[i].key2])
)
{
return 1;
}
// Check mouse
if((ControllerType == controltype_keyboardandmouse) ||
(ControllerType == controltype_joystickandmouse))
{
//Mouse buttons
if ((i)>31)
{
if((CONTROL_MouseButtonState2>>( (i) - 32) ) & 1)
{
return 1;
}
}
else
{
if((CONTROL_MouseButtonState1>> (i) ) & 1)
{
return 1;
}
}
// FIX_00019: DigitalAxis Handling now supported. (cool for medkit use)
//Mouse Digital Axes
if ((i)>31)
{
if((CONTROL_MouseDigitalAxisState2>>( (i) - 32) ) & 1)
{
return 1;
}
}
else
{
if((CONTROL_MouseDigitalAxisState1>> (i) ) & 1)
{
return 1;
}
}
}
// Check joystick
if((ControllerType == controltype_keyboardandjoystick) ||
(ControllerType == controltype_joystickandmouse)
)
{
if ((i)>31)
{
// Check the joystick
if( (CONTROL_JoyButtonState2 >> (i - 32)) & 1)
{
return 1;
}
// Check the hats
if( (CONTROL_JoyHatState2 >> (i - 32)) & 1)
{
return 1;
}
}
else
{
if( (CONTROL_JoyButtonState1 >> i) & 1)
{
return 1;
}
// Check the hats
if( (CONTROL_JoyHatState1 >> i) & 1)
{
return 1;
}
}
}
return 0;
}
int RESET_ACTION(int i)
{
KB_KeyDown[KeyMapping[i].key1] = 0;
KB_KeyDown[KeyMapping[i].key2] = 0;
return 0;
}
static void SETMOUSEBUTTON(int i)
{
//CONTROL_MouseButtonState1 |= (1<<i);
int b;
if (i < 32)
{
b = 1 << i;
CONTROL_MouseButtonState1 |= b;
}
else
{
i -= 32;
b = 1 << i;
CONTROL_MouseButtonState2 |= b;
}
}
void RESMOUSEBUTTON(int i)
{
//CONTROL_MouseButtonState1 &= ~(1<<i);
int b;
if (i < 32) {
b = 1 << i;
CONTROL_MouseButtonState1 &= ~b;
} else {
i -= 32;
b = 1 << i;
CONTROL_MouseButtonState2 &= ~b;
}
}
// FIX_00019: DigitalAxis Handling now supported. (cool for medkit use)
void SETMOUSEDIGITALAXIS(int i)
{
int b;
if (i<0)
return;
if (i < 32)
{
b = 1 << i;
CONTROL_MouseDigitalAxisState1 |= b;
}
else
{
i -= 32;
b = 1 << i;
CONTROL_MouseDigitalAxisState2 |= b;
}
}
void RESMOUSEDIGITALAXIS(int i)
{
int b;
if (i<0)
return;
if (i < 32)
{
b = 1 << i;
CONTROL_MouseDigitalAxisState1 &= ~b;
}
else
{
i -= 32;
b = 1 << i;
CONTROL_MouseDigitalAxisState2 &= ~b;
}
}
static void SETJOYBUTTON(int i)
{
//CONTROL_JoyButtonState |= (1<<i);
int b;
if (i < 32)
{
b = 1 << i;
CONTROL_JoyButtonState1 |= b;
}
else
{
i -= 32;
b = 1 << i;
CONTROL_JoyButtonState2 |= b;
}
}
static void RESJOYBUTTON(int i)
{
int b;
if (i < 32) {
b = 1 << i;
CONTROL_JoyButtonState1 &= ~b;
} else {
i -= 32;
b = 1 << i;
CONTROL_JoyButtonState2 &= ~b;
}
}
static void SETHATBUTTON(int i)
{
//CONTROL_JoyHatState1 |= (1<<i);
int b;
if (i < 32)
{
b = 1 << i;
CONTROL_JoyHatState1 |= b;
}
else
{
i -= 32;
b = 1 << i;
CONTROL_JoyHatState2 |= b;
}
}
static void RESHATBUTTON(int i)
{
//CONTROL_JoyHatState1 &= ~(1<<i);
int b;
if (i < 32) {
b = 1 << i;
CONTROL_JoyHatState1 &= ~b;
} else {
i -= 32;
b = 1 << i;
CONTROL_JoyHatState2 &= ~b;
}
}
void CONTROL_UpdateKeyboardState(int key, int pressed)
{
/*
if(pressed)
{
CONTROL_KeyStates[key] = 1;
}
else
{
CONTROL_KeyStates[key] = 0;
}
*/
/*
int i;
for (i = 0; i < MAXGAMEBUTTONS; i++)
{
if (KeyMapping[i].key_active == false)
{
continue;
}
if (KeyMapping[i].key1 == key ||
KeyMapping[i].key2 == key)
{
if (pressed)
{
SETBUTTON(i);
}
else
{
RESBUTTON(i);
}
}
}
*/
}
void CONTROL_MapKey( int32 which, kb_scancode key1, kb_scancode key2 )
{
// FIX_00020: Protect you from assigning a function to the ESC key through duke3d.cfg
if(key1==sc_Escape || key2==sc_Escape)
{
if(key1==sc_Escape)
key1=0;
else
key2=0;
printf("Discarding ESCAPE key for function : %s\n", gamefunctions[which]);
}
if(key1 || key2)
KeyMapping[which].key_active = true;
else
KeyMapping[which].key_active = false;
KeyMapping[which].key1 = key1;
KeyMapping[which].key2 = key2;
}
void CONTROL_MapButton
(
int32 whichfunction,
int32 whichbutton,
boolean clicked_or_doubleclicked
)
{
if(clicked_or_doubleclicked)
return; // TODO
if(whichbutton < 0 || whichbutton >= MAXMOUSEBUTTONS)
return;
MouseMapping[whichbutton] = whichfunction;
}
void CONTROL_MapJoyButton(int32 whichfunction, int32 whichbutton, boolean doubleclicked)
{
if(whichbutton < 0 || whichbutton >= MAXJOYBUTTONS)
{
return;
}
if(doubleclicked)
return; // TODO
JoyButtonMapping[whichbutton] = whichfunction;
}
void CONTROL_MapJoyHat(int32 whichfunction, int32 whichhat, int32 whichvalue)
{
if(whichhat < 0 || whichhat >= MAXJOYHATS)
{
return;
}
JoyHatMapping[whichhat][whichvalue] = whichfunction;
}
void CONTROL_DefineFlag( int32 which, boolean toggle )
{
// STUBBED("CONTROL_DefineFlag");
}
boolean CONTROL_FlagActive( int32 which )
{
STUBBED("CONTROL_FlagActive");
return false;
}
void CONTROL_ClearAssignments( void )
{
STUBBED("CONTROL_ClearAssignments");
}
void CONTROL_GetUserInput( UserInput *info )
{
STUBBED("CONTROL_GetUserInput");
}
void CONTROL_GetInput( ControlInfo *info )
{
int32 sens_X = CONTROL_GetMouseSensitivity_X();
int32 sens_Y = CONTROL_GetMouseSensitivity_Y();
int32 mx = 0, my = 0;
int i, j;
memset(info, '\0', sizeof (ControlInfo));
//info->dx = info->dz = 0;
_handle_events(); // get the very last mouse position before reading it.
MOUSE_GetDelta(&mx,&my);
//GetCursorPos(&point);
// SDL_GetMouseState(&x, &y);
// SDL_WarpMouse(160, 100);
//mx = (-xx+point.x)<<2;
//my = (-yy+point.y)<<2;
//xx=point.x; yy=point.y;
info->dyaw = (mx * sens_X);
switch(ControllerType)
{
case controltype_keyboardandjoystick:
{
}
break;
case controltype_joystickandmouse:
// Not sure what I was thinking here...
// Commented this out because it totally breaks smooth mouse etc...
/*
{
// Mouse should use pitch instead of forward movement.
info->dpitch = my * sens*2;
}
break;
*/
default:
{
// If mouse aim is active
if( myaimmode )
{
// FIX_00052: Y axis for the mouse is now twice as sensitive as before
info->dpitch = (my * sens_Y * 2);
}
else
{
info->dz = (my * sens_Y * 2);
}
}
break;
}
// TODO: releasing the mouse button does not honor if a keyboard key with
// the same function is still pressed. how should it?
for(i=0; i<MAXMOUSEBUTTONS;++i)
{
if( MouseMapping[i] != -1 )
{
if(!(lastmousebuttons & (1<<i)) && mouseButtons & (1<<i))
{
SETMOUSEBUTTON(MouseMapping[i]); //MouseMapping[i]
//printf("mouse button: %d\n", i);
}
else if(lastmousebuttons & (1<<i) && !(mouseButtons & (1<<i)))
{
RESMOUSEBUTTON(MouseMapping[i]);//MouseMapping[i]
}
}
}
lastmousebuttons = mouseButtons;
// FIX_00019: DigitalAxis Handling now supported. (cool for medkit use)
// update digital axis
RESMOUSEDIGITALAXIS(MouseDigitalAxeMapping[0][0]);
RESMOUSEDIGITALAXIS(MouseDigitalAxeMapping[0][1]);
RESMOUSEDIGITALAXIS(MouseDigitalAxeMapping[1][0]);
RESMOUSEDIGITALAXIS(MouseDigitalAxeMapping[1][1]);
if (mx < 0)
{
SETMOUSEDIGITALAXIS(MouseDigitalAxeMapping[0][0]);
}
else if (mx > 0)
{
SETMOUSEDIGITALAXIS(MouseDigitalAxeMapping[0][1]);
}
if (my < 0)
{
SETMOUSEDIGITALAXIS(MouseDigitalAxeMapping[1][0]);
}
else if (my > 0)
{
SETMOUSEDIGITALAXIS(MouseDigitalAxeMapping[1][1]);
}
// update stick state.
if ((CONTROL_JoystickEnabled) && (_joystick_update()))
{
// Check the hats
JOYSTICK_UpdateHats();
// TODO: make this NOT use the BUTTON() system for storing the hat input. (requires much game code changing)
for(i=0; i<MAXJOYHATS; i++)
{
for(j=0; j<8; j++)
{
if(!(lastjoyHats[i] & (1<<j)) && (joyHats[i] & (1<<j)))
{
SETHATBUTTON(JoyHatMapping[i][j]);
}
else if((lastjoyHats[i] & (1<<j)) && !(joyHats[i] & (1<<j)))
{
RESHATBUTTON(JoyHatMapping[i][j]);
}
}
lastjoyHats[i] = joyHats[i];
}
for(i=0; i<MAXJOYAXES;i++)
{
switch(JoyAxisMapping[i])
{
case analog_turning:
{
info->dyaw += (int32)((float)CONTROL_FilterDeadzone
(
_joystick_axis(i),
JoyAnalogDeadzone[i]
)
* JoyAnalogScale[i]
);
}
break;
case analog_strafing:
{
info->dx += (int32)((float)CONTROL_FilterDeadzone
(
_joystick_axis(i),
JoyAnalogDeadzone[i]
)
* JoyAnalogScale[i]
);
//printf("Joy %d = %d\n", i, info->dx);
}
break;
case analog_lookingupanddown:
info->dpitch += (int32)((float)CONTROL_FilterDeadzone
(
_joystick_axis(i),
JoyAnalogDeadzone[i]
)
* JoyAnalogScale[i]
);
break;
case analog_elevation: //STUB
break;
case analog_rolling: //STUB
break;
case analog_moving:
{
info->dz += (int32)((float)CONTROL_FilterDeadzone
(
_joystick_axis(i),
JoyAnalogDeadzone[i]
)
* JoyAnalogScale[i]
);
}
break;
default:
break;
}
}
// !!! FIXME: Do this.
//SETBUTTON based on _joystick_button().
for(i=0; i<MAXJOYBUTTONS;++i)
{
if(_joystick_button(i))
{
SETJOYBUTTON(JoyButtonMapping[i]);
}
else
{
RESJOYBUTTON(JoyButtonMapping[i]);
}
}
}
}
void CONTROL_ClearAction( int32 whichbutton )
{
//RESBUTTON(whichbutton);
KB_KeyDown[KeyMapping[whichbutton].key1] = 0;
KB_KeyDown[KeyMapping[whichbutton].key2] = 0;
RESJOYBUTTON(whichbutton);
RESHATBUTTON(whichbutton);
RESMOUSEDIGITALAXIS(whichbutton);
}
void CONTROL_ClearUserInput( UserInput *info )
{
STUBBED("CONTROL_ClearUserInput");
}
void CONTROL_WaitRelease( void )
{
STUBBED("CONTROL_WaitRelease");
}
void CONTROL_Ack( void )
{
STUBBED("CONTROL_Ack");
}
void CONTROL_CenterJoystick
(
void ( *CenterCenter )( void ),
void ( *UpperLeft )( void ),
void ( *LowerRight )( void ),
void ( *CenterThrottle )( void ),
void ( *CenterRudder )( void )
)
{
STUBBED("CONTROL_CenterJoystick");
}
int32 CONTROL_GetMouseSensitivity_X( void )
{
return mouseSensitivity_X;
}
void CONTROL_SetMouseSensitivity_X( int32 newsensitivity )
{
mouseSensitivity_X = newsensitivity;
}
// FIX_00014: Added Y cursor setup for mouse sensitivity in the menus
int32 CONTROL_GetMouseSensitivity_Y( void )
{
return mouseSensitivity_Y;
}
void CONTROL_SetMouseSensitivity_Y( int32 newsensitivity )
{
mouseSensitivity_Y = newsensitivity;
}
void CONTROL_Startup
(
controltype which,
int32 ( *TimeFunction )( void ),
int32 ticspersecond
)
{
int i;
// Init the joystick
_joystick_init();
for(i=0; i < MAXJOYHATS; i++)
{
joyHats[i] = 0;
lastjoyHats[i] = 0;
}
CONTROL_MouseButtonState1 = 0;
CONTROL_MouseButtonState2 = 0;
CONTROL_MouseDigitalAxisState1 = 0;
CONTROL_MouseDigitalAxisState2 = 0;
CONTROL_JoyButtonState1 = 0;
CONTROL_JoyButtonState2 = 0;
CONTROL_JoyHatState1 = 0;
CONTROL_JoyHatState2 = 0;
}
void CONTROL_Shutdown( void )
{
_joystick_deinit();
}
void CONTROL_MapAnalogAxis
(
int32 whichaxis,
int32 whichanalog
)
{
//STUBBED("CONTROL_MapAnalogAxis");
if(whichaxis < MAXJOYAXES)
{
JoyAxisMapping[whichaxis] = whichanalog;
}
}
// FIX_00019: DigitalAxis Handling now supported. (cool for medkit use)
void CONTROL_MapDigitalAxis
(
int32 whichaxis,
int32 whichfunction,
int32 direction
)
{
if(whichaxis < 0 || whichaxis >= MAXMOUSEAXES || direction < 0 || direction >= 2)
return;
MouseDigitalAxeMapping[whichaxis][direction] = whichfunction;
}
void CONTROL_SetAnalogAxisScale
(
int32 whichaxis,
float axisscale
)
{
if(whichaxis < MAXJOYAXES)
{
// Set it... make sure we don't let them set it to 0.. div by 0 is bad.
JoyAnalogScale[whichaxis] = (axisscale == 0) ? 1.0f : axisscale;
}
}
void CONTROL_SetAnalogAxisDeadzone
(
int32 whichaxis,
int32 axisdeadzone
)
{
if(whichaxis < MAXJOYAXES)
{
// Set it...
JoyAnalogDeadzone[whichaxis] = axisdeadzone;
}
}
int32 CONTROL_FilterDeadzone
(
int32 axisvalue,
int32 axisdeadzone
)
{
if((axisvalue < axisdeadzone) && (axisvalue > -axisdeadzone))
{
return 0;
}
return axisvalue;
}
int32 CONTROL_GetFilteredAxisValue(int32 axis)
{
return (int32)((float)CONTROL_FilterDeadzone
(
_joystick_axis(axis),
JoyAnalogDeadzone[axis]
)
* JoyAnalogScale[axis]
);
}
void CONTROL_PrintAxes( void )
{
STUBBED("CONTROL_PrintAxes");
}
boolean MOUSE_Init( void )
{
memset(MouseMapping,-1,sizeof(MouseMapping));
memset(MouseDigitalAxeMapping, -1, sizeof(MouseDigitalAxeMapping));
return true;
}
void MOUSE_Shutdown( void )
{
STUBBED("MOUSE_Shutdown");
}
void MOUSE_ShowCursor( void )
{
STUBBED("MOUSE_ShowCursor");
}
void MOUSE_HideCursor( void )
{
STUBBED("MOUSE_HideCursor");
}
static void updateMouse(void)
{
// this is in buildengine.
short x, y;
getmousevalues(&x, &y, &mouseButtons);
mouseRelativeX += x;
mouseRelativeY += y;
mousePositionX += x;
mousePositionY += y;
}
int32 MOUSE_GetButtons( void )
{
//updateMouse();
return ((int32) mouseButtons);
}
void MOUSE_GetPosition( int32*x, int32*y )
{
if (x) *x = mousePositionX;
if (y) *y = mousePositionY;
}
void MOUSE_GetDelta( int32*x, int32*y )
{
updateMouse();
if (x) *x = mouseRelativeX;
if (y) *y = mouseRelativeY;
mouseRelativeX = 0;
mouseRelativeY = 0;
}
void JOYSTICK_UpdateHats()
{
int i;
for(i=0; i<MAXJOYHATS; i++)
{
//for(j=0; j<8; j++)
//{
joyHats[i] = _joystick_hat(i);
//}
}
}