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

Implemented Input Functions via C# #358

Merged
mushgunAX merged 5 commits from SP3-10-input-management into main 2023-02-23 14:00:26 +08:00
Conversation 0 Commits 5 Files Changed 5 +464 -1
5 changed files with 464 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
SHADE_Engine/src/Editor/EditorWindow/InputBindings/SHInputBindingsPanel.cpp
View File

@ -47,6 +47,8 @@ namespace SHADE
if (SHEditorWindow::Begin())
{
//ImGui::ShowDemoWindow();
if (bindingRenames.size() != SHInputManager::CountBindings())
resizeVectors(SHInputManager::CountBindings());
//Binding count
ImGui::Text("Binding Count: %d", SHInputManager::CountBindings());
@ -127,6 +129,8 @@ namespace SHADE
{
SHInputManager::RenameBinding(binding.first, bindingRenames[entryNumber]);
bindingRenames[entryNumber].clear();
ImGui::End();
return;
}
if (ImGui::Button(labelConcat("Delete Binding##", entryNumber).c_str()))

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

@ -14,6 +14,9 @@
#include <fstream>
#include "SHInputManager.h"
#include "../Tools/SHException.h"
#include <Graphics/Windowing/SHWindow.h>
#include <Graphics/MiddleEnd/Interface/SHGraphicsSystem.h>
#include <Graphics/MiddleEnd/Interface/SHGraphicsSystemInterface.h>
namespace SHADE
{
@ -21,6 +24,7 @@ namespace SHADE
/* Static defines */
/*------------------------------------------------------------------------*/
bool SHInputManager::mouseCentering = false;
bool SHInputManager::controllerInUse = false;
std::map<std::string, SHInputManager::SHLogicalBindingData> SHInputManager::bindings;
@ -751,6 +755,7 @@ namespace SHADE
{
++keyCount;
keys[i] = true;
controllerInUse = false;
}
else keys[i] = false;
@ -801,6 +806,25 @@ namespace SHADE
mouseVelocityX = static_cast<double>(mouseScreenX - mouseScreenXLast) / dt;
mouseVelocityY = static_cast<double>(mouseScreenY - mouseScreenYLast) / dt;
//Mouse Centering
if (mouseCentering)
{
uint32_t width = SHADE::SHGraphicsSystemInterface::GetWindowWidth();
uint32_t height = SHADE::SHGraphicsSystemInterface::GetWindowHeight();
SetMouseWindowPosition(width / 2, height / 2);
//These four lines help a lot
POINT p;
GetCursorPos(&p);
mouseVelocityX -= static_cast<double>(p.x - mouseScreenX) / dt;
mouseVelocityY -= static_cast<double>(p.y - mouseScreenY) / dt;
}
if (mouseVelocityX != 0.0 || mouseVelocityY != 0.0)
controllerInUse = false;
//Mouse wheel vertical delta updating
mouseWheelVerticalDelta = 0;
mouseWheelVerticalDelta = mouseWheelVerticalDeltaPoll;

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

@ -1074,6 +1074,18 @@ namespace SHADE
SetCursorPos(p.x, p.y);
}
//Call to set the flag to start mouse centering every frame
static inline void SetMouseCentering(bool state) noexcept
{
mouseCentering = state;
}
//Get the flag whether mouse centering is on or not
static inline bool GetMouseCentering() noexcept
{
return mouseCentering;
}
private:
/*------------------------------------------------------------------------*/
/* Constants */
@ -1097,6 +1109,9 @@ namespace SHADE
/* Data Members */
/*------------------------------------------------------------------------*/
//Whether mouse centering will be called every frame or not
static bool mouseCentering;
//If the last input is from controller(s) or KB/M
//True if from controller(s), False if from KB/M
//Useful for switching control hints between controllers and KB/M

297
SHADE_Managed/src/Input/Input.cxx
View File

@ -30,10 +30,29 @@ namespace SHADE
{
return SHInputManager::GetMouseWheelVerticalDelta();
}
bool Input::ControllerInUse::get()
{
return SHInputManager::GetControllerInUse();
}
/*---------------------------------------------------------------------------------*/
/* Usage Functions */
/*---------------------------------------------------------------------------------*/
bool Input::AnyKey()
{
return SHInputManager::AnyKey();
}
bool Input::AnyKeyDown()
{
return SHInputManager::AnyKeyDown();
}
bool Input::AnyKeyUp()
{
return SHInputManager::AnyKeyUp();
}
bool Input::GetKey(KeyCode key)
{
return SHInputManager::GetKey(static_cast<SHInputManager::SH_KEYCODE>(key));
@ -64,6 +83,50 @@ namespace SHADE
return SHInputManager::GetKeyUp(static_cast<SHInputManager::SH_KEYCODE>(mouseButton));
}
bool Input::AnyControllerInput()
{
return SHInputManager::AnyControllerInput();
}
bool Input::AnyControllerInputDown()
{
return SHInputManager::AnyControllerInputDown();
}
bool Input::AnyControllerInputUp()
{
return SHInputManager::AnyControllerInputUp();
}
bool Input::AnyControllerButton()
{
return SHInputManager::AnyControllerButton();
}
bool Input::AnyControllerButtonDown()
{
return SHInputManager::AnyControllerButtonDown();
}
bool Input::AnyControllerButtonUp()
{
return SHInputManager::AnyControllerButtonUp();
}
bool Input::GetControllerInput(Input::ControllerCode code)
{
return SHInputManager::GetControllerInput(static_cast<SHInputManager::SH_CONTROLLERCODE>(code));
}
double Input::GetControllerInputNormalisedValue(Input::ControllerCode code)
{
double toReturn = 0.0;
SHInputManager::GetControllerInput(static_cast<SHInputManager::SH_CONTROLLERCODE>(code), &toReturn);
return toReturn;
}
bool Input::GetControllerInputDown(Input::ControllerCode code)
{
return SHInputManager::GetControllerInputDown(static_cast<SHInputManager::SH_CONTROLLERCODE>(code));
}
bool Input::GetControllerInputUp(Input::ControllerCode code)
{
return SHInputManager::GetControllerInputUp(static_cast<SHInputManager::SH_CONTROLLERCODE>(code));
}
/*---------------------------------------------------------------------------------*/
/* Cursor Functions */
/*---------------------------------------------------------------------------------*/
@ -76,6 +139,24 @@ namespace SHADE
);
}
Vector2 Input::GetMousePosition()
{
int x = 0;
int y = 0;
SHInputManager::GetMouseWindowPosition(&x, &y);
return Convert::ToCLI(SHVec2{ (float)x,(float)y });
}
void Input::SetMouseCentering(bool state)
{
SHInputManager::SetMouseCentering(state);
}
bool Input::GetMouseCentering()
{
return SHInputManager::GetMouseCentering();
}
/*---------------------------------------------------------------------------------*/
/* Time Functions */
/*---------------------------------------------------------------------------------*/
@ -106,4 +187,220 @@ namespace SHADE
return Convert::ToCLI(SHVec2{ (float)velX,(float)velY });
}
double Input::GetControllerInputHeldTime(Input::ControllerCode code)
{
return SHInputManager::GetControllerInputHeldTime(static_cast<SHInputManager::SH_CONTROLLERCODE>(code));
}
double Input::GetControllerInputReleasedTime(Input::ControllerCode code)
{
return SHInputManager::GetControllerInputReleasedTime(static_cast<SHInputManager::SH_CONTROLLERCODE>(code));
}
/*-----------------------------------------------------------------------------*/
/* Binding Functions */
/*-----------------------------------------------------------------------------*/
void Input::SaveBindings()
{
SHInputManager::SaveBindings();
}
void Input::SaveBindings(System::String^ targetFile)
{
SHInputManager::SaveBindings(Convert::ToNative(targetFile));
}
void Input::LoadBindings()
{
SHInputManager::LoadBindings();
}
void Input::LoadBindings(System::String^ sourceFile)
{
SHInputManager::LoadBindings(Convert::ToNative(sourceFile));
}
bool Input::GetBindingInverted(System::String^ bindingName)
{
return SHInputManager::GetBindingInverted(Convert::ToNative(bindingName));
}
void Input::SetBindingInverted(System::String^ bindingName, bool newValue)
{
SHInputManager::SetBindingInverted(Convert::ToNative(bindingName), newValue);
}
double Input::GetBindingGravity(System::String^ bindingName)
{
return SHInputManager::GetBindingGravity(Convert::ToNative(bindingName));
}
void Input::SetBindingGravity(System::String^ bindingName, double newValue)
{
SHInputManager::SetBindingGravity(Convert::ToNative(bindingName), newValue);
}
double Input::GetBindingDead(System::String^ bindingName)
{
return SHInputManager::GetBindingDead(Convert::ToNative(bindingName));
}
void Input::SetBindingDead(System::String^ bindingName, double newValue)
{
SHInputManager::SetBindingDead(Convert::ToNative(bindingName), newValue);
}
double Input::GetBindingSensitivity(System::String^ bindingName)
{
return SHInputManager::GetBindingSensitivity(Convert::ToNative(bindingName));
}
void Input::SetBindingSensitivity(System::String^ bindingName, double newValue)
{
SHInputManager::SetBindingSensitivity(Convert::ToNative(bindingName), newValue);
}
bool Input::GetBindingSnap(System::String^ bindingName)
{
return SHInputManager::GetBindingSnap(Convert::ToNative(bindingName));
}
void Input::SetBindingSnap(System::String^ bindingName, bool newValue)
{
SHInputManager::SetBindingSnap(Convert::ToNative(bindingName), newValue);
}
System::Collections::Generic::HashSet<Input::KeyCode>^ Input::GetBindingPositiveKeyCodes(System::String^ bindingName)
{
System::Collections::Generic::HashSet<Input::KeyCode>^ toReturn = gcnew System::Collections::Generic::HashSet<Input::KeyCode>();
std::set<SHInputManager::SH_KEYCODE> list = SHInputManager::GetBindingPositiveKeyCodes(Convert::ToNative(bindingName));
for (auto kc : list)
{
toReturn->Add(static_cast<Input::KeyCode>(kc));
}
return toReturn;
}
void Input::AddBindingPositiveKeyCode(System::String^ bindingName, Input::KeyCode toAdd)
{
SHInputManager::AddBindingPositiveKeyCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_KEYCODE>(toAdd));
}
void Input::RemoveBindingPositiveKeyCode(System::String^ bindingName, Input::KeyCode toRemove)
{
SHInputManager::RemoveBindingPositiveKeyCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_KEYCODE>(toRemove));
}
void Input::ClearBindingPositiveKeyCodes(System::String^ bindingName)
{
SHInputManager::ClearBindingPositiveKeyCodes(Convert::ToNative(bindingName));
}
System::Collections::Generic::HashSet<Input::KeyCode>^ Input::GetBindingNegativeKeyCodes(System::String^ bindingName)
{
System::Collections::Generic::HashSet<Input::KeyCode>^ toReturn = gcnew System::Collections::Generic::HashSet<Input::KeyCode>();
std::set<SHInputManager::SH_KEYCODE> list = SHInputManager::GetBindingNegativeKeyCodes(Convert::ToNative(bindingName));
for (auto kc : list)
{
toReturn->Add(static_cast<Input::KeyCode>(kc));
}
return toReturn;
}
void Input::AddBindingNegativeKeyCode(System::String^ bindingName, Input::KeyCode toAdd)
{
SHInputManager::AddBindingNegativeKeyCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_KEYCODE>(toAdd));
}
void Input::RemoveBindingNegativeKeyCode(System::String^ bindingName, Input::KeyCode toRemove)
{
SHInputManager::RemoveBindingNegativeKeyCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_KEYCODE>(toRemove));
}
void Input::ClearBindingNegativeKeyCodes(System::String^ bindingName)
{
SHInputManager::ClearBindingNegativeKeyCodes(Convert::ToNative(bindingName));
}
System::Collections::Generic::HashSet<Input::ControllerCode>^ Input::GetBindingPositiveControllerCodes(System::String^ bindingName)
{
System::Collections::Generic::HashSet<Input::ControllerCode>^ toReturn = gcnew System::Collections::Generic::HashSet<Input::ControllerCode>();
std::set<SHInputManager::SH_CONTROLLERCODE> list = SHInputManager::GetBindingPositiveControllerCodes(Convert::ToNative(bindingName));
for (auto kc : list)
{
toReturn->Add(static_cast<Input::ControllerCode>(kc));
}
return toReturn;
}
void Input::AddBindingPositiveControllerCode(System::String^ bindingName, Input::ControllerCode toAdd)
{
SHInputManager::AddBindingPositiveControllerCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_CONTROLLERCODE>(toAdd));
}
void Input::RemoveBindingPositiveControllerCode(System::String^ bindingName, Input::ControllerCode toRemove)
{
SHInputManager::RemoveBindingPositiveControllerCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_CONTROLLERCODE>(toRemove));
}
void Input::ClearBindingPositiveControllerCodes(System::String^ bindingName)
{
SHInputManager::ClearBindingPositiveControllerCodes(Convert::ToNative(bindingName));
}
System::Collections::Generic::HashSet<Input::ControllerCode>^ Input::GetBindingNegativeControllerCodes(System::String^ bindingName)
{
System::Collections::Generic::HashSet<Input::ControllerCode>^ toReturn = gcnew System::Collections::Generic::HashSet<Input::ControllerCode>();
std::set<SHInputManager::SH_CONTROLLERCODE> list = SHInputManager::GetBindingNegativeControllerCodes(Convert::ToNative(bindingName));
for (auto kc : list)
{
toReturn->Add(static_cast<Input::ControllerCode>(kc));
}
return toReturn;
}
void Input::AddBindingNegativeControllerCode(System::String^ bindingName, Input::ControllerCode toAdd)
{
SHInputManager::AddBindingNegativeControllerCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_CONTROLLERCODE>(toAdd));
}
void Input::RemoveBindingNegativeControllerCode(System::String^ bindingName, Input::ControllerCode toRemove)
{
SHInputManager::RemoveBindingNegativeControllerCode(Convert::ToNative(bindingName), static_cast<SHInputManager::SH_CONTROLLERCODE>(toRemove));
}
void Input::ClearBindingNegativeControllerCodes(System::String^ bindingName)
{
SHInputManager::ClearBindingNegativeControllerCodes(Convert::ToNative(bindingName));
}
double Input::GetBindingAxis(System::String^ bindingName)
{
return SHInputManager::GetBindingAxis(Convert::ToNative(bindingName));
}
double Input::GetBindingAxisRaw(System::String^ bindingName)
{
return SHInputManager::GetBindingAxisRaw(Convert::ToNative(bindingName));
}
bool Input::GetBindingPositiveButton(System::String^ bindingName)
{
return SHInputManager::GetBindingPositiveButton(Convert::ToNative(bindingName));
}
bool Input::GetBindingNegativeButton(System::String^ bindingName)
{
return SHInputManager::GetBindingNegativeButton(Convert::ToNative(bindingName));
}
bool Input::GetBindingPositiveButtonDown(System::String^ bindingName)
{
return SHInputManager::GetBindingPositiveButtonDown(Convert::ToNative(bindingName));
}
bool Input::GetBindingNegativeButtonDown(System::String^ bindingName)
{
return SHInputManager::GetBindingNegativeButtonDown(Convert::ToNative(bindingName));
}
bool Input::GetBindingPositiveButtonUp(System::String^ bindingName)
{
return SHInputManager::GetBindingPositiveButtonUp(Convert::ToNative(bindingName));
}
bool Input::GetBindingNegativeButtonUp(System::String^ bindingName)
{
return SHInputManager::GetBindingNegativeButtonUp(Convert::ToNative(bindingName));
}
double Input::GetBindingPositiveHeldTime(System::String^ bindingName)
{
return SHInputManager::GetBindingPositiveHeldTime(Convert::ToNative(bindingName));
}
double Input::GetBindingNegativeHeldTime(System::String^ bindingName)
{
return SHInputManager::GetBindingNegativeHeldTime(Convert::ToNative(bindingName));
}
double Input::GetBindingPositiveReleasedTime(System::String^ bindingName)
{
return SHInputManager::GetBindingPositiveReleasedTime(Convert::ToNative(bindingName));
}
double Input::GetBindingNegativeReleasedTime(System::String^ bindingName)
{
return SHInputManager::GetBindingNegativeReleasedTime(Convert::ToNative(bindingName));
}
}

125
SHADE_Managed/src/Input/Input.hxx
View File

@ -181,7 +181,6 @@ namespace SHADE
//Break
//Menu
//Mouse buttons use mouse codes, which are enums declared later
//TODO Controller input
#if 0
Space = static_cast<int>(SHInputManager::SH_KEYCODE::SPACE),
//Apostrophe = static_cast<int>(SHInputManager::SH_KEYCODE::APOSTROPHE),
@ -355,6 +354,35 @@ namespace SHADE
Button3 = static_cast<int>(SHInputManager::SH_KEYCODE::XMB1),
Button4 = static_cast<int>(SHInputManager::SH_KEYCODE::XMB2)
};
enum class ControllerCode : int
{
DpadUp = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::DPAD_UP),
DpadDown = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::DPAD_DOWN),
DpadLeft = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::DPAD_LEFT),
DpadRight = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::DPAD_RIGHT),
Start = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::START),
Back = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::BACK),
LeftThumbstickButton = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::LEFT_THUMBSTICK),
RightThumbstickButton = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::RIGHT_THUMBSTICK),
LeftShoulder = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::LEFT_SHOULDER),
RightShoulder = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::RIGHT_SHOULDER),
AButton = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::A),
BButton = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::B),
XButton = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::X),
YButton = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::Y),
LeftTrigger = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::LEFT_TRIGGER),
RightTrigger = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::RIGHT_TRIGGER),
LeftThumbStickX = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::LEFT_THUMBSTICK_X),
LeftThumbStickY = static_cast<int>(SHInputManager::SH_CONTROLLERCODE::LEFT_THUMBSTICK_Y)
};
enum class BindingType : int
{
KbMbController = static_cast<int>(SHInputManager::SH_BINDINGTYPE::KB_MB_CONTROLLER),
mouseX = static_cast<int>(SHInputManager::SH_BINDINGTYPE::MOUSE_X),
mouseY = static_cast<int>(SHInputManager::SH_BINDINGTYPE::MOUSE_Y),
mouseScroll = static_cast<int>(SHInputManager::SH_BINDINGTYPE::MOUSE_SCROLL)
};
/*-----------------------------------------------------------------------------*/
/* Properites */
@ -376,9 +404,25 @@ namespace SHADE
int get();
}
static property bool ControllerInUse
{
bool get();
}
/*-----------------------------------------------------------------------------*/
/* Usage Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Checks if any key is being held down.
/// This will also be true if GetKeyDown() is true.
/// </summary>
/// <param name="firstKey">KeyCode of the first key that was detected to be pressed.</param>
/// <returns>True while the user holds down the key specified.</returns>
static bool AnyKey();
static bool AnyKeyDown();
static bool AnyKeyUp();
/// <summary>
/// Checks if a specified key is being held down.
/// This will also be true if GetKeyDown() is true.
@ -427,6 +471,20 @@ namespace SHADE
/// True during the frame the user releases the given mouse button.
/// </returns>
static bool GetMouseButtonUp(MouseCode mouseButton);
//For controller
static bool AnyControllerInput();
static bool AnyControllerInputDown();
static bool AnyControllerInputUp();
static bool AnyControllerButton();
static bool AnyControllerButtonDown();
static bool AnyControllerButtonUp();
static bool GetControllerInput(ControllerCode code);
static double GetControllerInputNormalisedValue(ControllerCode code);
static bool GetControllerInputDown(ControllerCode code);
static bool GetControllerInputUp(ControllerCode code);
/*-----------------------------------------------------------------------------*/
/* Cursor Functions */
@ -440,6 +498,11 @@ namespace SHADE
/// </param>
static void SetMousePosition(Vector2 pos);
static Vector2 GetMousePosition();
static void SetMouseCentering(bool state);
static bool GetMouseCentering();
/*-----------------------------------------------------------------------------*/
/* Timing Functions */
/*-----------------------------------------------------------------------------*/
@ -472,6 +535,66 @@ namespace SHADE
/// <returns>Time in seconds that the key was held.</returns>
static double GetMouseReleasedTime(MouseCode mouseButton);
static double GetControllerInputHeldTime(ControllerCode code);
static double GetControllerInputReleasedTime(ControllerCode code);
static Vector2 GetMouseVelocity();
/*-----------------------------------------------------------------------------*/
/* Binding Functions */
/*-----------------------------------------------------------------------------*/
static void SaveBindings(); //To default file
static void SaveBindings(System::String^ targetFile);
static void LoadBindings(); //From default file
static void LoadBindings(System::String^ sourceFile);
static bool GetBindingInverted(System::String^ bindingName);
static void SetBindingInverted(System::String^ bindingName, bool newValue);
static double GetBindingGravity(System::String^ bindingName);
static void SetBindingGravity(System::String^ bindingName, double newValue);
static double GetBindingDead(System::String^ bindingName);
static void SetBindingDead(System::String^ bindingName, double newValue);
static double GetBindingSensitivity(System::String^ bindingName);
static void SetBindingSensitivity(System::String^ bindingName, double newValue);
static bool GetBindingSnap(System::String^ bindingName);
static void SetBindingSnap(System::String^ bindingName, bool newValue);
static System::Collections::Generic::HashSet<KeyCode>^ GetBindingPositiveKeyCodes(System::String^ bindingName);
static void AddBindingPositiveKeyCode(System::String^ bindingName, Input::KeyCode toAdd);
static void RemoveBindingPositiveKeyCode(System::String^ bindingName, Input::KeyCode toRemove);
static void ClearBindingPositiveKeyCodes(System::String^ bindingName);
static System::Collections::Generic::HashSet<KeyCode>^ GetBindingNegativeKeyCodes(System::String^ bindingName);
static void AddBindingNegativeKeyCode(System::String^ bindingName, Input::KeyCode toAdd);
static void RemoveBindingNegativeKeyCode(System::String^ bindingName, Input::KeyCode toRemove);
static void ClearBindingNegativeKeyCodes(System::String^ bindingName);
static System::Collections::Generic::HashSet<ControllerCode>^ GetBindingPositiveControllerCodes(System::String^ bindingName);
static void AddBindingPositiveControllerCode(System::String^ bindingName, Input::ControllerCode toAdd);
static void RemoveBindingPositiveControllerCode(System::String^ bindingName, Input::ControllerCode toRemove);
static void ClearBindingPositiveControllerCodes(System::String^ bindingName);
static System::Collections::Generic::HashSet<ControllerCode>^ GetBindingNegativeControllerCodes(System::String^ bindingName);
static void AddBindingNegativeControllerCode(System::String^ bindingName, Input::ControllerCode toAdd);
static void RemoveBindingNegativeControllerCode(System::String^ bindingName, Input::ControllerCode toRemove);
static void ClearBindingNegativeControllerCodes(System::String^ bindingName);
//Binding states
static double GetBindingAxis(System::String^ bindingName);
static double GetBindingAxisRaw(System::String^ bindingName);
static bool GetBindingPositiveButton(System::String^ bindingName);
static bool GetBindingNegativeButton(System::String^ bindingName);
static bool GetBindingPositiveButtonDown(System::String^ bindingName);
static bool GetBindingNegativeButtonDown(System::String^ bindingName);
static bool GetBindingPositiveButtonUp(System::String^ bindingName);
static bool GetBindingNegativeButtonUp(System::String^ bindingName);
//Binding times
static double GetBindingPositiveHeldTime(System::String^ bindingName);
static double GetBindingNegativeHeldTime(System::String^ bindingName);
static double GetBindingPositiveReleasedTime(System::String^ bindingName);
static double GetBindingNegativeReleasedTime(System::String^ bindingName);
};
}