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

Progress on Input Manager Fixes

This commit is contained in:
mushgunAX 2022-12-25 14:13:21 +08:00
parent 605d408a3a
commit ee4ec83f7a
2 changed files with 225 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -159,7 +159,7 @@ namespace SHADE
} }
} }
//Mouse Positioning///////////////////////////////////// //Mouse Positioning/////////////////////////////////////////////////////////
//https://stackoverflow.com/a/6423739 //https://stackoverflow.com/a/6423739
//Set last positioning //Set last positioning
@ -181,7 +181,7 @@ namespace SHADE
mouseWheelVerticalDelta = mouseWheelVerticalDeltaPoll; mouseWheelVerticalDelta = mouseWheelVerticalDeltaPoll;
mouseWheelVerticalDeltaPoll = 0; mouseWheelVerticalDeltaPoll = 0;
//Controllers////////////////////////////////////////////////////////////// //Controllers///////////////////////////////////////////////////////////////
controllersConnectedCount = 0; 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 bool SHInputManager::AnyKeyDown(SH_KEYCODE* firstDetected) noexcept
@ -574,60 +705,9 @@ namespace SHADE
return false; return false;
} }
//Only get of largest magnitude
double SHInputManager::GetBindingAxis(std::string const& bindingName, size_t cNum) noexcept double SHInputManager::GetBindingAxis(std::string const& bindingName, size_t cNum) noexcept
{ {
if (cNum >= XUSER_MAX_COUNT) return 0.0f; return bindings[bindingName].value;
//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;
} }
bool SHInputManager::GetBindingPositiveButton(std::string const& bindingName, size_t cNum) noexcept 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////////////////////////////////////////////////////////////////// //VALUES//////////////////////////////////////////////////////////////////
//The current value of the axis binding //The current value of the axis binding
double value = 0.0f; double value = 0.0;
//Whether the input is inverted, //Whether the input is inverted,
//If so, positive bindings will make the value negative, //If so, positive bindings will make the value negative,
@ -345,15 +345,16 @@ namespace SHADE
bool inverted = false; bool inverted = false;
//When no input is present, how fast does the value fall back to neutral? //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 //How far the user needs to move an analog stick before application
//registers the movement //registers the movement
double dead = 0.1f; double dead = 0.1;
//Speed in units per second that the axis will move toward target value //Speed in units per second that the axis will move toward target value for digital
//For digital inputs only //For mouse movement / scrolling, serves as multiplier
double sensitivity = 1.0f; double sensitivity = 1.0;
//If enabled, axis value will reset to zero when pressing a button //If enabled, axis value will reset to zero when pressing a button
//that corresponds in the opposite direction //that corresponds in the opposite direction
@ -388,7 +389,7 @@ namespace SHADE
} }
//Get if controller or KB/M is presently being used //Get if controller or KB/M is presently being used
static inline bool const GetControllerInUse() noexcept static inline bool GetControllerInUse() noexcept
{ {
return controllerInUse; return controllerInUse;
} }
@ -678,9 +679,9 @@ namespace SHADE
//Remove a binding and all its associated inputs from the list //Remove a binding and all its associated inputs from the list
//Returns 1 if found and removed, 0 if not found //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 //Clears all bindings from the list
@ -695,16 +696,68 @@ namespace SHADE
return bindings.size(); 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///////////////////////////////////////////////////////// //POSITIVE KEYCODES/////////////////////////////////////////////////////////
@ -716,24 +769,24 @@ namespace SHADE
} }
//Add positive SH_KEYCODE to binding //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 SH_KEYCODE toAdd) noexcept
{ {
bindings[targetBindingName].positiveKeyCodes.insert(toAdd); bindings[bindingName].positiveKeyCodes.insert(toAdd);
} }
//Remove positive SH_KEYCODE from binding //Remove positive SH_KEYCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0. //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 SH_KEYCODE toRemove) noexcept
{ {
return bindings[targetBindingName].positiveKeyCodes.erase(toRemove); return bindings[bindingName].positiveKeyCodes.erase(toRemove);
} }
//Clear all positive SH_KEYCODEs from binding //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///////////////////////////////////////////////////////// //NEGATIVE KEYCODES/////////////////////////////////////////////////////////
@ -745,24 +798,24 @@ namespace SHADE
} }
//Add negative SH_KEYCODE to binding //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 SH_KEYCODE toAdd) noexcept
{ {
bindings[targetBindingName].negativeKeyCodes.insert(toAdd); bindings[bindingName].negativeKeyCodes.insert(toAdd);
} }
//Remove negative SH_KEYCODE from binding //Remove negative SH_KEYCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0. //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 SH_KEYCODE toRemove) noexcept
{ {
return bindings[targetBindingName].negativeKeyCodes.erase(toRemove); return bindings[bindingName].negativeKeyCodes.erase(toRemove);
} }
//Clear all negative SH_KEYCODEs from binding //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////////////////////////////////////////////////// //POSITIVE CONTROLLERCODES//////////////////////////////////////////////////
@ -774,24 +827,24 @@ namespace SHADE
} }
//Add positive SH_CONTROLLERCODE to binding //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 SH_CONTROLLERCODE toAdd) noexcept
{ {
bindings[targetBindingName].positiveControllerCodes.insert(toAdd); bindings[bindingName].positiveControllerCodes.insert(toAdd);
} }
//Remove positive SH_CONTROLLERCODE from binding //Remove positive SH_CONTROLLERCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0. //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 SH_CONTROLLERCODE toRemove) noexcept
{ {
return bindings[targetBindingName].positiveControllerCodes.erase(toRemove); return bindings[bindingName].positiveControllerCodes.erase(toRemove);
} }
//Clear all positive SH_CONTROLLERCODEs from binding //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////////////////////////////////////////////////// //NEGATIVE CONTROLLERCODES//////////////////////////////////////////////////
@ -803,24 +856,24 @@ namespace SHADE
} }
//Add negative SH_CONTROLLERCODE to binding //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 SH_CONTROLLERCODE toAdd) noexcept
{ {
bindings[targetBindingName].negativeControllerCodes.insert(toAdd); bindings[bindingName].negativeControllerCodes.insert(toAdd);
} }
//Remove negative SH_CONTROLLERCODE from binding //Remove negative SH_CONTROLLERCODE from binding
//If toRemove found and removed, returns 1. Otherwise, 0. //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 SH_CONTROLLERCODE toRemove) noexcept
{ {
return bindings[targetBindingName].negativeControllerCodes.erase(toRemove); return bindings[bindingName].negativeControllerCodes.erase(toRemove);
} }
//Clear all negative SH_CONTROLLERCODEs from binding //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 //Get the axis value of binding, between -1 and 1 for non-mouse