xiaoqi
/
SHADE_Y3
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects Releases 9 Wiki Activity

Fixed and Enhanced Input Binding Management #298

Merged
mushgunAX merged 9 commits from SP3-10-input-management into main 2023-01-01 12:35:50 +08:00
Conversation 0 Commits 9 Files Changed 2 +225 -92
2 changed files with 225 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit ee4ec83f7a - Show all commits

188
SHADE_Engine/src/Input/SHInputManager.cpp
View File

@ -159,7 +159,7 @@ namespace SHADE
}
}
//Mouse Positioning/////////////////////////////////////
//Mouse Positioning/////////////////////////////////////////////////////////
//https://stackoverflow.com/a/6423739
//Set last positioning
@ -181,7 +181,7 @@ namespace SHADE
mouseWheelVerticalDelta = mouseWheelVerticalDeltaPoll;
mouseWheelVerticalDeltaPoll = 0;
//Controllers//////////////////////////////////////////////////////////////
//Controllers///////////////////////////////////////////////////////////////
controllersConnectedCount = 0;
@ -447,6 +447,137 @@ namespace SHADE
}
}
}
//Bindings//////////////////////////////////////////////////////////////////
for (std::pair<std::string, SHLogicalBindingData> binding : bindings)
{
SHLogicalBindingData& data = binding.second;
if (data.bindingType == SHLogicalBindingData::SH_BINDINGTYPE::MOUSE_X)
{
double velX = 0.0;
GetMouseVelocity(&velX, nullptr);
data.value = velX * data.sensitivity * (data.inverted ? -1.0 : 1.0);
}
else if (data.bindingType == SHLogicalBindingData::SH_BINDINGTYPE::MOUSE_Y)
{
double velY = 0.0;
GetMouseVelocity(nullptr, &velY);
data.value = velY * data.sensitivity * (data.inverted ? -1.0 : 1.0);
}
else if (data.bindingType == SHLogicalBindingData::SH_BINDINGTYPE::MOUSE_SCROLL)
{
data.value = mouseWheelVerticalDelta * data.sensitivity * (data.inverted ? -1.0 : 1.0);
}
else if (data.bindingType == SHLogicalBindingData::SH_BINDINGTYPE::KB_MB_CONTROLLER)
{
//Prioritise the largest magnitude
double largestMagnitude = 0.0;
//If digital input was in, use sensitivity
bool digitalInput = false;
//If data was read
bool positiveInputRead = false;
bool negativeInputRead = false;
//Over keycodes
for (SH_KEYCODE k : data.positiveKeyCodes)
{
if (GetKey(k))
{
if (std::abs(1.0) > std::abs(largestMagnitude)) largestMagnitude = 1.0;
digitalInput = true;
positiveInputRead = true;
}
}
for (SH_KEYCODE k : data.negativeKeyCodes)
{
if (GetKey(k))
{
if (std::abs(-1.0) > std::abs(largestMagnitude)) largestMagnitude = -1.0;
digitalInput = true;
negativeInputRead = true;
}
}
//Over controllerCodes
for (SH_CONTROLLERCODE c : data.positiveControllerCodes)
{
double newValue = 0.0;
if (GetControllerInput(c, &newValue))
{
positiveInputRead = true;
if (static_cast<size_t>(c) < NUM_CONTROLLER_BUTTON)
{
digitalInput = true;
}
if (std::abs(newValue) > std::abs(largestMagnitude))
largestMagnitude = newValue * data.sensitivity * (data.inverted ? -1.0 : 1.0);
}
}
for (SH_CONTROLLERCODE c : data.negativeControllerCodes)
{
double newValue = 0.0;
if (GetControllerInput(c, &newValue))
{
negativeInputRead = true;
if (static_cast<size_t>(c) < NUM_CONTROLLER_BUTTON)
{
digitalInput = true;
}
if (std::abs(newValue) > std::abs(largestMagnitude))
largestMagnitude = -newValue * data.sensitivity * (data.inverted ? -1.0 : 1.0);
}
}
//If both positive and negative inputs read, do not modify value
if (positiveInputRead && negativeInputRead)
{
data.value = data.value;
}
else
{
//If no data received, use gravity
if (!positiveInputRead && !negativeInputRead)
{
if (data.value > 0.0)
{
data.value -= data.gravity * dt;
if (data.value < 0.0) data.value = 0.0;
}
if (data.value < 0.0)
{
data.value += data.gravity * dt;
if (data.value > 0.0) data.value = 0.0;
}
}
else //Either positive OR negative input was read
{
//If digital input was in, use sensitivity
if (digitalInput)
{
data.value += data.sensitivity * largestMagnitude * dt;
if (data.value > 1.0) data.value = 1.0;
else if (data.value < -1.0) data.value = -1.0;
}
else
{
data.value = largestMagnitude;
}
if (data.snap) //Snapping
{
if (data.value > 0.0 && negativeInputRead)
data.value = 0.0;
if (data.value < 0.0 && positiveInputRead)
data.value = 0.0;
}
}
}
}
}
}
bool SHInputManager::AnyKeyDown(SH_KEYCODE* firstDetected) noexcept
@ -574,60 +705,9 @@ namespace SHADE
return false;
}
//Only get of largest magnitude
double SHInputManager::GetBindingAxis(std::string const& bindingName, size_t cNum) noexcept
{
if (cNum >= XUSER_MAX_COUNT) return 0.0f;
//Over mouse movement, if used for this axis
if (bindings[bindingName].bindingType == SHLogicalBindingData::SH_BINDINGTYPE::MOUSE_X)
{
double velX = 0.0f;
GetMouseVelocity(&velX, nullptr);
return velX;
}
if (bindings[bindingName].bindingType == SHLogicalBindingData::SH_BINDINGTYPE::MOUSE_Y)
{
double velY = 0.0f;
GetMouseVelocity(nullptr, &velY);
return velY;
}
//Over mouse scroll, if used for this axis
if (bindings[bindingName].bindingType == SHLogicalBindingData::SH_BINDINGTYPE::MOUSE_SCROLL)
{
return mouseWheelVerticalDelta;
}
//The largest magnitude recorded so far
double largestMagnitude = 0.0;
//Over keycodes, prioritise positive
for (SH_KEYCODE k : bindings[bindingName].positiveKeyCodes)
{
if (GetKey(k)) if (std::abs(1.0f) > std::abs(largestMagnitude)) largestMagnitude = 1.0f;
}
for (SH_KEYCODE k : bindings[bindingName].negativeKeyCodes)
{
if (GetKey(k)) if (std::abs(-1.0f) > std::abs(largestMagnitude)) largestMagnitude = -1.0f;
}
//Over controllerCodes
for (SH_CONTROLLERCODE c : bindings[bindingName].positiveControllerCodes)
{
double newValue = 0.0;
if (GetControllerInput(c, &newValue, nullptr, nullptr, cNum))
if (std::abs(newValue) > std::abs(largestMagnitude)) largestMagnitude = newValue;
}
for (SH_CONTROLLERCODE c : bindings[bindingName].negativeControllerCodes)
{
double newValue = 0.0;
if (GetControllerInput(c, &newValue, nullptr, nullptr, cNum))
if (std::abs(newValue) > std::abs(largestMagnitude)) largestMagnitude = -newValue;
}
return largestMagnitude;
return bindings[bindingName].value;
}
bool SHInputManager::GetBindingPositiveButton(std::string const& bindingName, size_t cNum) noexcept

129
SHADE_Engine/src/Input/SHInputManager.h
View File

@ -335,7 +335,7 @@ namespace SHADE
//VALUES//////////////////////////////////////////////////////////////////
//The current value of the axis binding
double value = 0.0f;
double value = 0.0;
//Whether the input is inverted,
//If so, positive bindings will make the value negative,
@ -345,15 +345,16 @@ namespace SHADE
bool inverted = false;
//When no input is present, how fast does the value fall back to neutral?
double gravity = 1.0f;
//Best to be non-negative
double gravity = 1.0;
//How far the user needs to move an analog stick before application
//registers the movement
double dead = 0.1f;
double dead = 0.1;
//Speed in units per second that the axis will move toward target value
//For digital inputs only
double sensitivity = 1.0f;
//Speed in units per second that the axis will move toward target value for digital
//For mouse movement / scrolling, serves as multiplier
double sensitivity = 1.0;
//If enabled, axis value will reset to zero when pressing a button
//that corresponds in the opposite direction
@ -388,7 +389,7 @@ namespace SHADE
}
//Get if controller or KB/M is presently being used
static inline bool const GetControllerInUse() noexcept
static inline bool GetControllerInUse() noexcept
{
return controllerInUse;
}
@ -678,9 +679,9 @@ namespace SHADE
//Remove a binding and all its associated inputs from the list
//Returns 1 if found and removed, 0 if not found
static inline size_t BindingsRemove(std::string const& targetBindingName) noexcept
static inline size_t BindingsRemove(std::string const& bindingName) noexcept
{
return bindings.erase(targetBindingName);
return bindings.erase(bindingName);
}
//Clears all bindings from the list
@ -695,16 +696,68 @@ namespace SHADE
return bindings.size();
}
//BINDING TYPE//////////////////////////////////////////////////////////////
//BINDING VALUES////////////////////////////////////////////////////////////
static inline void BindingsSetType(std::string const& targetBindingName, SHLogicalBindingData::SH_BINDINGTYPE const newType)
static inline bool BindingsGetInverted(std::string const& bindingName)
{
bindings[targetBindingName].bindingType = newType;
return bindings[bindingName].inverted;
}
static inline SHLogicalBindingData::SH_BINDINGTYPE const BindingsGetType(std::string const& targetBindingName)
static inline void BindingsSetInverted(std::string const& bindingName, bool const newValue)
{
return bindings[targetBindingName].bindingType;
bindings[bindingName].inverted = newValue;
}
static inline double BindingsGetGravity(std::string const& bindingName)
{
return bindings[bindingName].gravity;
}
static inline void BindingsSetGravity(std::string const& bindingName, double const newValue)
{
bindings[bindingName].gravity = newValue;
}
static inline double BindingsGetDead(std::string const& bindingName)
{
return bindings[bindingName].dead;
}
static inline void BindingsSetDead(std::string const& bindingName, double const newValue)
{
bindings[bindingName].dead = newValue;
}
static inline double BindingsGetSensitivity(std::string const& bindingName)
{
return bindings[bindingName].sensitivity;
}
static inline void BindingsSetSensitivity(std::string const& bindingName, double const newValue)
{
bindings[bindingName].sensitivity = newValue;
}
static inline bool BindingsGetSnap(std::string const& bindingName)
{
return bindings[bindingName].snap;
}
static inline void BindingsSetSnap(std::string const& bindingName, bool const newValue)
{
bindings[bindingName].snap = newValue;
}
//BINDING TYPE//////////////////////////////////////////////////////////////
static inline SHLogicalBindingData::SH_BINDINGTYPE BindingsGetType(std::string const& bindingName)
{
return bindings[bindingName].bindingType;
}
static inline void BindingsSetType(std::string const& bindingName, SHLogicalBindingData::SH_BINDINGTYPE const newType)
{
bindings[bindingName].bindingType = newType;
}
//POSITIVE KEYCODES/////////////////////////////////////////////////////////
@ -716,24 +769,24 @@ namespace SHADE
}
//Add positive SH_KEYCODE to binding
static inline void BindingsAddPositiveKeyCode(std::string const& targetBindingName,
static inline void BindingsAddPositiveKeyCode(std::string const& bindingName,
SH_KEYCODE toAdd) noexcept
{
bindings[targetBindingName].positiveKeyCodes.insert(toAdd);
bindings[bindingName].positiveKeyCodes.insert(toAdd);
}
//Remove positive SH_KEYCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0.
static inline size_t BindingsRemovePositiveKeyCode(std::string const& targetBindingName,
static inline size_t BindingsRemovePositiveKeyCode(std::string const& bindingName,
SH_KEYCODE toRemove) noexcept
{
return bindings[targetBindingName].positiveKeyCodes.erase(toRemove);
return bindings[bindingName].positiveKeyCodes.erase(toRemove);
}
//Clear all positive SH_KEYCODEs from binding
static inline void BindingsClearPositiveKeyCodes(std::string const& targetBindingName) noexcept
static inline void BindingsClearPositiveKeyCodes(std::string const& bindingName) noexcept
{
bindings[targetBindingName].positiveKeyCodes.clear();
bindings[bindingName].positiveKeyCodes.clear();
}
//NEGATIVE KEYCODES/////////////////////////////////////////////////////////
@ -745,24 +798,24 @@ namespace SHADE
}
//Add negative SH_KEYCODE to binding
static inline void BindingsAddNegativeKeyCode(std::string const& targetBindingName,
static inline void BindingsAddNegativeKeyCode(std::string const& bindingName,
SH_KEYCODE toAdd) noexcept
{
bindings[targetBindingName].negativeKeyCodes.insert(toAdd);
bindings[bindingName].negativeKeyCodes.insert(toAdd);
}
//Remove negative SH_KEYCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0.
static inline size_t BindingsRemoveNegativeKeyCode(std::string const& targetBindingName,
static inline size_t BindingsRemoveNegativeKeyCode(std::string const& bindingName,
SH_KEYCODE toRemove) noexcept
{
return bindings[targetBindingName].negativeKeyCodes.erase(toRemove);
return bindings[bindingName].negativeKeyCodes.erase(toRemove);
}
//Clear all negative SH_KEYCODEs from binding
static inline void BindingsClearNegativeKeyCodes(std::string const& targetBindingName) noexcept
static inline void BindingsClearNegativeKeyCodes(std::string const& bindingName) noexcept
{
bindings[targetBindingName].negativeKeyCodes.clear();
bindings[bindingName].negativeKeyCodes.clear();
}
//POSITIVE CONTROLLERCODES//////////////////////////////////////////////////
@ -774,24 +827,24 @@ namespace SHADE
}
//Add positive SH_CONTROLLERCODE to binding
static inline void BindingsAddPositiveControllerCode(std::string const& targetBindingName,
static inline void BindingsAddPositiveControllerCode(std::string const& bindingName,
SH_CONTROLLERCODE toAdd) noexcept
{
bindings[targetBindingName].positiveControllerCodes.insert(toAdd);
bindings[bindingName].positiveControllerCodes.insert(toAdd);
}
//Remove positive SH_CONTROLLERCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0.
static inline size_t BindingsRemovePositiveControllerCode(std::string const& targetBindingName,
static inline size_t BindingsRemovePositiveControllerCode(std::string const& bindingName,
SH_CONTROLLERCODE toRemove) noexcept
{
return bindings[targetBindingName].positiveControllerCodes.erase(toRemove);
return bindings[bindingName].positiveControllerCodes.erase(toRemove);
}
//Clear all positive SH_CONTROLLERCODEs from binding
static inline void BindingsClearPositiveControllerCodes(std::string const& targetBindingName) noexcept
static inline void BindingsClearPositiveControllerCodes(std::string const& bindingName) noexcept
{
bindings[targetBindingName].positiveControllerCodes.clear();
bindings[bindingName].positiveControllerCodes.clear();
}
//NEGATIVE CONTROLLERCODES//////////////////////////////////////////////////
@ -803,24 +856,24 @@ namespace SHADE
}
//Add negative SH_CONTROLLERCODE to binding
static inline void BindingsAddNegativeControllerCode(std::string const& targetBindingName,
static inline void BindingsAddNegativeControllerCode(std::string const& bindingName,
SH_CONTROLLERCODE toAdd) noexcept
{
bindings[targetBindingName].negativeControllerCodes.insert(toAdd);
bindings[bindingName].negativeControllerCodes.insert(toAdd);
}
//Remove negative SH_CONTROLLERCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0.
static inline size_t BindingsRemoveNegativeControllerCode(std::string const& targetBindingName,
static inline size_t BindingsRemoveNegativeControllerCode(std::string const& bindingName,
SH_CONTROLLERCODE toRemove) noexcept
{
return bindings[targetBindingName].negativeControllerCodes.erase(toRemove);
return bindings[bindingName].negativeControllerCodes.erase(toRemove);
}
//Clear all negative SH_CONTROLLERCODEs from binding
static inline void BindingsClearNegativeControllerCodes(std::string const& targetBindingName) noexcept
static inline void BindingsClearNegativeControllerCodes(std::string const& bindingName) noexcept
{
bindings[targetBindingName].negativeControllerCodes.clear();
bindings[bindingName].negativeControllerCodes.clear();
}
//Get the axis value of binding, between -1 and 1 for non-mouse