Glenn Maynard
269 lines
7.3 KiB
C++
269 lines
7.3 KiB
C++
#include "global.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
Class: InputFilter
|
|
|
|
Desc: See header.
|
|
|
|
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "InputFilter.h"
|
|
#include "RageLog.h"
|
|
#include "RageInput.h"
|
|
#include "RageThreads.h"
|
|
|
|
|
|
InputFilter* INPUTFILTER = NULL; // global and accessable from anywhere in our program
|
|
|
|
static const float TIME_BEFORE_SLOW_REPEATS = 0.25f;
|
|
static const float TIME_BEFORE_FAST_REPEATS = 1.5f;
|
|
|
|
static const float SLOW_REPEATS_PER_SEC = 8;
|
|
static const float FAST_REPEATS_PER_SEC = 8;
|
|
|
|
static float g_fTimeBeforeSlow, g_fTimeBeforeFast, g_fTimeBetweenSlow, g_fTimeBetweenFast;
|
|
|
|
|
|
InputFilter::InputFilter()
|
|
{
|
|
queuemutex = new RageMutex("InputFilter");
|
|
memset( m_BeingHeld, 0, sizeof(m_BeingHeld) );
|
|
memset( m_BeingForced, 0, sizeof(m_BeingForced) );
|
|
memset( m_fSecsHeld, 0, sizeof(m_fSecsHeld) );
|
|
for( int d=0; d<NUM_INPUT_DEVICES; d++ ) // foreach InputDevice
|
|
for( int b=0; b < NUM_DEVICE_BUTTONS[d]; b++ ) // foreach button
|
|
m_fSecsToForce[d][b] = -1;
|
|
|
|
Reset();
|
|
ResetRepeatRate();
|
|
}
|
|
|
|
InputFilter::~InputFilter()
|
|
{
|
|
delete queuemutex;
|
|
}
|
|
|
|
void InputFilter::Reset()
|
|
{
|
|
for( int i=0; i<NUM_INPUT_DEVICES; i++ )
|
|
ResetDevice( InputDevice(i) );
|
|
}
|
|
|
|
void InputFilter::SetRepeatRate( float fSlowDelay, float fSlowRate, float fFastDelay, float fFastRate )
|
|
{
|
|
g_fTimeBeforeSlow = fSlowDelay;
|
|
g_fTimeBeforeFast = fFastDelay;
|
|
g_fTimeBetweenSlow = 1/fSlowRate;
|
|
g_fTimeBetweenFast = 1/fFastRate;
|
|
}
|
|
|
|
void InputFilter::ResetRepeatRate()
|
|
{
|
|
SetRepeatRate( TIME_BEFORE_SLOW_REPEATS, SLOW_REPEATS_PER_SEC, TIME_BEFORE_FAST_REPEATS, FAST_REPEATS_PER_SEC );
|
|
}
|
|
|
|
void InputFilter::ButtonPressed( DeviceInput di, bool Down )
|
|
{
|
|
LockMut(*queuemutex);
|
|
|
|
if(m_BeingHeld[di.device][di.button] == Down)
|
|
return;
|
|
|
|
const bool WasBeingPressed = IsBeingPressed( di );
|
|
|
|
m_BeingHeld[di.device][di.button] = Down;
|
|
m_fSecsHeld[di.device][di.button] = 0;
|
|
#if 0
|
|
if( 1 ) // PREFSMAN->m_bJoytechInput && di.IsJoystick() )
|
|
{
|
|
/* If this is a release of the right button, force it down for a little while, so
|
|
* the axis motion has a chance to come in before we register the right arrow release. */
|
|
const int RightButton = 'd';//JOY_13;
|
|
// const int LeftButton = 'a';//JOY_15;
|
|
if( !Down && di.button == RightButton )
|
|
{
|
|
LOG->Trace("temp force d");
|
|
ForceKey( DeviceInput(di.device, RightButton), 1 );
|
|
}
|
|
}
|
|
#endif
|
|
if( WasBeingPressed != IsBeingPressed(di) )
|
|
{
|
|
InputEventType iet = IsBeingPressed(di)? IET_FIRST_PRESS:IET_RELEASE;
|
|
queue.push_back( InputEvent(di,iet) );
|
|
}
|
|
#if 0
|
|
if( 1 ) // PREFSMAN->m_bJoytechInput && di.IsJoystick() )
|
|
{
|
|
const int RightButton = 'd';//JOY_13;
|
|
const int LeftButton = 'a';//JOY_15;
|
|
bool NeedToForceBothButtons =
|
|
IsBeingPressed( DeviceInput(di.device, 'e'/*JOY_RIGHT*/) ) &&
|
|
!IsBeingPressed( DeviceInput(di.device, RightButton) );
|
|
LOG->Trace("--- %i", NeedToForceBothButtons );
|
|
if( NeedToForceBothButtons )
|
|
{
|
|
ForceKey( DeviceInput(di.device, RightButton), 0 );
|
|
ForceKey( DeviceInput(di.device, LeftButton), 0 );
|
|
} else {
|
|
StopForcingKey( DeviceInput(di.device, RightButton) );
|
|
StopForcingKey( DeviceInput(di.device, LeftButton) );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* Force a key down. Duration is the amount of time to force the key, or 0 to force
|
|
* it until we explicitly call StopForcingKey. */
|
|
void InputFilter::ForceKey( DeviceInput di, float duration )
|
|
{
|
|
LockMut(*queuemutex);
|
|
|
|
if( m_BeingForced[di.device][di.button] )
|
|
return;
|
|
|
|
const bool WasBeingPressed = IsBeingPressed( di );
|
|
|
|
m_BeingForced[di.device][di.button] = true;
|
|
m_fSecsToForce[di.device][di.button] = duration;
|
|
m_fSecsHeld[di.device][di.button] = 0;
|
|
|
|
/* Send an IET_FIRST_PRESS event if the key wasn't already down. */
|
|
if( WasBeingPressed != IsBeingPressed( di ) )
|
|
{
|
|
InputEventType iet = IsBeingPressed(di)? IET_FIRST_PRESS:IET_RELEASE;
|
|
queue.push_back( InputEvent(di,iet) );
|
|
}
|
|
}
|
|
|
|
void InputFilter::StopForcingKey( DeviceInput di )
|
|
{
|
|
LockMut(*queuemutex);
|
|
|
|
if( !m_BeingForced[di.device][di.button] )
|
|
return;
|
|
|
|
const bool WasBeingPressed = IsBeingPressed( di );
|
|
|
|
m_BeingForced[di.device][di.button] = false;
|
|
m_fSecsToForce[di.device][di.button] = 0;
|
|
m_fSecsHeld[di.device][di.button] = 0;
|
|
|
|
/* Send an IET_RELEASE event if the key is no longer down. */
|
|
if( WasBeingPressed != IsBeingPressed(di) )
|
|
{
|
|
InputEventType iet = IsBeingPressed(di)? IET_FIRST_PRESS:IET_RELEASE;
|
|
queue.push_back( InputEvent(di,iet) );
|
|
}
|
|
}
|
|
|
|
/* Release all buttons on the given device. */
|
|
void InputFilter::ResetDevice( InputDevice dev )
|
|
{
|
|
for( int button = 0; button < NUM_DEVICE_BUTTONS[dev]; ++button )
|
|
ButtonPressed( DeviceInput(dev, button), false );
|
|
}
|
|
|
|
void InputFilter::Update(float fDeltaTime)
|
|
{
|
|
// static float AutoStartTime=0;
|
|
// AutoStartTime -= fDeltaTime;
|
|
// if( AutoStartTime <= 0 )
|
|
// {
|
|
// AutoStartTime = 0.5f;
|
|
// ButtonPressed( DeviceInput(DEVICE_KEYBOARD, 'a'), true );
|
|
// ButtonPressed( DeviceInput(DEVICE_KEYBOARD, 'a'), false );
|
|
// }
|
|
RageTimer now;
|
|
|
|
// Constructing the DeviceInput inside the nested loops caues terrible
|
|
// performance. So, construct it once outside the loop, then change
|
|
// .device and .button inside the loop. I have no idea what is causing
|
|
// the slowness. DeviceInput is a very small and simple structure, but
|
|
// it's constructor was being called NUM_INPUT_DEVICES*NUM_DEVICE_BUTTONS
|
|
// (>2000) times per Update().
|
|
/* This should be fixed: DeviceInput's ctor uses an init list, so RageTimer
|
|
* isn't initialized each time. */
|
|
// DeviceInput di( (InputDevice)0,0,now);
|
|
|
|
INPUTMAN->Update( fDeltaTime );
|
|
|
|
/* Make sure that nothing gets inserted while we do this, to prevent
|
|
* things like "key pressed, key release, key repeat". */
|
|
LockMut(*queuemutex);
|
|
|
|
// Don't reconstruct "di" inside the loop. This line alone is
|
|
// taking 4% of the CPU on a P3-666.
|
|
DeviceInput di( (InputDevice)0,0,now);
|
|
|
|
for( int d=0; d<NUM_INPUT_DEVICES; d++ ) // foreach InputDevice
|
|
{
|
|
di.device = (InputDevice)d;
|
|
|
|
for( int b=0; b < NUM_DEVICE_BUTTONS[d]; b++ ) // foreach button
|
|
{
|
|
di.button = b;
|
|
|
|
if( m_fSecsToForce[d][b] > 0 )
|
|
{
|
|
m_fSecsToForce[d][b] -= fDeltaTime;
|
|
if( m_fSecsToForce[d][b] <= 0 )
|
|
StopForcingKey( di );
|
|
}
|
|
|
|
if( !IsBeingPressed(di) )
|
|
continue;
|
|
|
|
const float fOldHoldTime = m_fSecsHeld[d][b];
|
|
m_fSecsHeld[d][b] += fDeltaTime;
|
|
const float fNewHoldTime = m_fSecsHeld[d][b];
|
|
|
|
float fTimeBetweenRepeats;
|
|
InputEventType iet;
|
|
if( fOldHoldTime > g_fTimeBeforeSlow )
|
|
{
|
|
if( fOldHoldTime > g_fTimeBeforeFast )
|
|
{
|
|
fTimeBetweenRepeats = g_fTimeBetweenFast;
|
|
iet = IET_FAST_REPEAT;
|
|
}
|
|
else
|
|
{
|
|
fTimeBetweenRepeats = g_fTimeBetweenSlow;
|
|
iet = IET_SLOW_REPEAT;
|
|
}
|
|
if( int(fOldHoldTime/fTimeBetweenRepeats) != int(fNewHoldTime/fTimeBetweenRepeats) )
|
|
{
|
|
queue.push_back( InputEvent(di,iet) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool InputFilter::IsBeingPressed( DeviceInput di )
|
|
{
|
|
return m_BeingHeld[di.device][di.button] || m_BeingForced[di.device][di.button];
|
|
}
|
|
|
|
float InputFilter::GetSecsHeld( DeviceInput di )
|
|
{
|
|
return m_fSecsHeld[di.device][di.button];
|
|
}
|
|
|
|
void InputFilter::ResetKeyRepeat( DeviceInput di )
|
|
{
|
|
m_fSecsHeld[di.device][di.button] = 0;
|
|
}
|
|
|
|
void InputFilter::GetInputEvents( InputEventArray &array )
|
|
{
|
|
LockMut(*queuemutex);
|
|
array = queue;
|
|
queue.clear();
|
|
}
|