Skip to content

replace deprecated SteamController calls with Steam Input ones #17

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
RollinBarrel wants to merge 1 commit into
base: master
Choose a base branch
from
Open

replace deprecated SteamController calls with Steam Input ones #17

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
144 changes: 77 additions & 67 deletions native/controller.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ void CallbackHandler::OnGamepadTextInputDismissed( GamepadTextInputDismissed_t *
//side never needs to know the actual values. So we just store the full 64-bit values locally and pass back
//0-based index values which easily fit into a regular int.
class steamHandleMap{
//TODO: figure out templating or whatever so I can make typed versions of this like in Haxe (steamHandleMap<ControllerHandle_t>)
//TODO: figure out templating or whatever so I can make typed versions of this like in Haxe (steamHandleMap<InputHandle_t>)
// all the steam handle typedefs are just renamed uint64's, but this could always change so to be 100% super safe I should
// figure out the templating stuff.

Expand Down Expand Up @@ -60,28 +60,38 @@ class steamHandleMap{

static steamHandleMap mapControllers;

HL_PRIM bool HL_NAME(init_controllers)(){
if (!SteamController()) return false;
HL_PRIM bool HL_NAME(init_controllers)(bool explicitlyCallRunFrame){
if (!SteamInput()) return false;

bool result = SteamController()->Init();
bool result = SteamInput()->Init(explicitlyCallRunFrame);
if( result )
mapControllers.init();
return result;
}
DEFINE_PRIM(_BOOL, init_controllers, _NO_ARG);
DEFINE_PRIM(_BOOL, init_controllers, _BOOL);

HL_PRIM bool HL_NAME(shutdown_controllers)(){
bool result = SteamController()->Shutdown();
bool result = SteamInput()->Shutdown();
if (result)
mapControllers.init();
return result;
}
DEFINE_PRIM(_BOOL, shutdown_controllers, _NO_ARG);

HL_PRIM void HL_NAME(run_frame_controllers)(){
SteamInput()->RunFrame(false);
}
DEFINE_PRIM(_VOID, run_frame_controllers, _NO_ARG);

HL_PRIM bool HL_NAME(new_data_available_controllers)(){
return SteamInput()->BNewDataAvailable();
}
DEFINE_PRIM(_BOOL, new_data_available_controllers, _NO_ARG);

HL_PRIM bool HL_NAME(show_binding_panel)(int controller){
ControllerHandle_t c_handle = controller != -1 ? mapControllers.get(controller) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
InputHandle_t c_handle = controller != -1 ? mapControllers.get(controller) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;

return SteamController()->ShowBindingPanel(c_handle);
return SteamInput()->ShowBindingPanel(c_handle);
}
DEFINE_PRIM(_BOOL, show_binding_panel, _I32);

Expand All @@ -105,13 +115,13 @@ HL_PRIM vbyte *HL_NAME(get_entered_gamepad_text_input)(){
DEFINE_PRIM(_BYTES, get_entered_gamepad_text_input, _NO_ARG);

HL_PRIM varray *HL_NAME(get_connected_controllers)(varray *arr){
SteamController()->RunFrame();
SteamInput()->RunFrame();

ControllerHandle_t handles[STEAM_CONTROLLER_MAX_COUNT];
int result = SteamController()->GetConnectedControllers(handles);
InputHandle_t handles[STEAM_INPUT_MAX_COUNT];
int result = SteamInput()->GetConnectedControllers(handles);

if( !arr )
arr = hl_alloc_array(&hlt_i32, STEAM_CONTROLLER_MAX_COUNT);
arr = hl_alloc_array(&hlt_i32, STEAM_INPUT_MAX_COUNT);
int *cur = hl_aptr(arr, int);
for(int i = 0; i < result; i++) {
int index = mapControllers.find(handles[i]);
Expand All @@ -120,34 +130,34 @@ HL_PRIM varray *HL_NAME(get_connected_controllers)(varray *arr){
cur[i] = index;
}

for (int i = result; i < STEAM_CONTROLLER_MAX_COUNT; i++)
for (int i = result; i < STEAM_INPUT_MAX_COUNT; i++)
cur[i] = -1;

return arr;
}
DEFINE_PRIM(_ARR, get_connected_controllers, _ARR);

HL_PRIM int HL_NAME(get_action_set_handle)(vbyte *actionSetName){
return (int)SteamController()->GetActionSetHandle((char*)actionSetName);
return (int)SteamInput()->GetActionSetHandle((char*)actionSetName);
}
DEFINE_PRIM(_I32, get_action_set_handle, _BYTES);

HL_PRIM int HL_NAME(get_digital_action_handle)(vbyte *actionName){
return (int)SteamController()->GetDigitalActionHandle((char*)actionName);
return (int)SteamInput()->GetDigitalActionHandle((char*)actionName);
}
DEFINE_PRIM(_I32, get_digital_action_handle, _BYTES);

HL_PRIM int HL_NAME(get_analog_action_handle)(vbyte *actionName){
return (int)SteamController()->GetAnalogActionHandle((char*)actionName);
return (int)SteamInput()->GetAnalogActionHandle((char*)actionName);
}
DEFINE_PRIM(_I32, get_analog_action_handle, _BYTES);

//-----------------------------------------------------------------------------------------------------------
HL_PRIM int HL_NAME(get_digital_action_data)(int controllerHandle, int actionHandle){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
ControllerDigitalActionHandle_t a_handle = actionHandle;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
InputDigitalActionHandle_t a_handle = actionHandle;

ControllerDigitalActionData_t data = SteamController()->GetDigitalActionData(c_handle, a_handle);
InputDigitalActionData_t data = SteamInput()->GetDigitalActionData(c_handle, a_handle);

int result = 0;

Expand Down Expand Up @@ -175,10 +185,10 @@ typedef struct {
} analog_action_data;

HL_PRIM void HL_NAME(get_analog_action_data)(int controllerHandle, int actionHandle, analog_action_data *data){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
ControllerAnalogActionHandle_t a_handle = actionHandle;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
InputAnalogActionHandle_t a_handle = actionHandle;

ControllerAnalogActionData_t d = SteamController()->GetAnalogActionData(c_handle, a_handle);
InputAnalogActionData_t d = SteamInput()->GetAnalogActionData(c_handle, a_handle);

data->bActive = d.bActive;
data->eMode = d.eMode;
Expand All @@ -188,39 +198,39 @@ HL_PRIM void HL_NAME(get_analog_action_data)(int controllerHandle, int actionHan
DEFINE_PRIM(_VOID, get_analog_action_data, _I32 _I32 _OBJ(_BOOL _I32 _F64 _F64));

HL_PRIM varray *HL_NAME(get_digital_action_origins)(int controllerHandle, int actionSetHandle, int digitalActionHandle){
ControllerHandle_t c_handle = mapControllers.get(controllerHandle);
ControllerActionSetHandle_t s_handle = actionSetHandle;
ControllerDigitalActionHandle_t a_handle = digitalActionHandle;
InputHandle_t c_handle = mapControllers.get(controllerHandle);
InputActionSetHandle_t s_handle = actionSetHandle;
InputDigitalActionHandle_t a_handle = digitalActionHandle;

EControllerActionOrigin origins[STEAM_CONTROLLER_MAX_ORIGINS];
for(int i = 0; i < STEAM_CONTROLLER_MAX_ORIGINS; i++)
origins[i] = k_EControllerActionOrigin_None;
EInputActionOrigin origins[STEAM_INPUT_MAX_ORIGINS];
for(int i = 0; i < STEAM_INPUT_MAX_ORIGINS; i++)
origins[i] = k_EInputActionOrigin_None;

int result = SteamController()->GetDigitalActionOrigins(c_handle, s_handle, a_handle, origins);
int result = SteamInput()->GetDigitalActionOrigins(c_handle, s_handle, a_handle, origins);
varray *arr = hl_alloc_array(&hlt_i32, result);
int *cur = hl_aptr(arr, int);
for(int i = 0; i < STEAM_CONTROLLER_MAX_ORIGINS; i++)
for(int i = 0; i < STEAM_INPUT_MAX_ORIGINS; i++)
cur[i] = origins[i];
return arr;
}
DEFINE_PRIM(_ARR, get_digital_action_origins, _I32 _I32 _I32);

//-----------------------------------------------------------------------------------------------------------
HL_PRIM varray *HL_NAME(get_analog_action_origins)(int controllerHandle, int actionSetHandle, int analogActionHandle){
ControllerHandle_t c_handle = mapControllers.get(controllerHandle);
ControllerActionSetHandle_t s_handle = actionSetHandle;
ControllerAnalogActionHandle_t a_handle = analogActionHandle;
InputHandle_t c_handle = mapControllers.get(controllerHandle);
InputActionSetHandle_t s_handle = actionSetHandle;
InputAnalogActionHandle_t a_handle = analogActionHandle;

EControllerActionOrigin origins[STEAM_CONTROLLER_MAX_ORIGINS];
EInputActionOrigin origins[STEAM_INPUT_MAX_ORIGINS];

//Initialize the whole thing to None to avoid garbage
for(int i = 0; i < STEAM_CONTROLLER_MAX_ORIGINS; i++)
origins[i] = k_EControllerActionOrigin_None;
for(int i = 0; i < STEAM_INPUT_MAX_ORIGINS; i++)
origins[i] = k_EInputActionOrigin_None;

int result = SteamController()->GetAnalogActionOrigins(c_handle, s_handle, a_handle, origins);
int result = SteamInput()->GetAnalogActionOrigins(c_handle, s_handle, a_handle, origins);
varray *arr = hl_alloc_array(&hlt_i32, result);
int *cur = hl_aptr(arr, int);
for(int i = 0; i < STEAM_CONTROLLER_MAX_ORIGINS; i++)
for(int i = 0; i < STEAM_INPUT_MAX_ORIGINS; i++)
cur[i] = origins[i];
return arr;
}
Expand All @@ -230,12 +240,12 @@ DEFINE_PRIM(_ARR, get_analog_action_origins, _I32 _I32 _I32);
HL_PRIM vbyte *HL_NAME(get_glyph_for_action_origin)(int origin){
if (!CheckInit()) return NULL;

if (origin >= k_EControllerActionOrigin_Count)
if (origin >= k_EInputActionOrigin_Count)
return NULL;

EControllerActionOrigin eOrigin = static_cast<EControllerActionOrigin>(origin);
EInputActionOrigin eOrigin = static_cast<EInputActionOrigin>(origin);

const char * result = SteamController()->GetGlyphForActionOrigin(eOrigin);
const char * result = SteamInput()->GetGlyphForActionOrigin_Legacy(eOrigin);
return (vbyte*)result;
}
DEFINE_PRIM(_BYTES, get_glyph_for_action_origin, _I32);
Expand All @@ -244,34 +254,34 @@ DEFINE_PRIM(_BYTES, get_glyph_for_action_origin, _I32);
HL_PRIM vbyte *HL_NAME(get_string_for_action_origin)(int origin){
if (!CheckInit()) return NULL;

if (origin >= k_EControllerActionOrigin_Count)
if (origin >= k_EInputActionOrigin_Count)
return NULL;

EControllerActionOrigin eOrigin = static_cast<EControllerActionOrigin>(origin);
EInputActionOrigin eOrigin = static_cast<EInputActionOrigin>(origin);

const char * result = SteamController()->GetStringForActionOrigin(eOrigin);
const char * result = SteamInput()->GetStringForActionOrigin(eOrigin);
return (vbyte*)result;
}
DEFINE_PRIM(_BYTES, get_string_for_action_origin, _I32);

//-----------------------------------------------------------------------------------------------------------
HL_PRIM void HL_NAME(activate_action_set)(int controllerHandle, int actionSetHandle){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
ControllerActionSetHandle_t a_handle = actionSetHandle;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
InputActionSetHandle_t a_handle = actionSetHandle;

SteamController()->ActivateActionSet(c_handle, a_handle);
SteamInput()->ActivateActionSet(c_handle, a_handle);
}
DEFINE_PRIM(_VOID, activate_action_set, _I32 _I32);

//-----------------------------------------------------------------------------------------------------------
HL_PRIM int HL_NAME(get_current_action_set)(int controllerHandle){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
return (int)SteamController()->GetCurrentActionSet(c_handle);
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
return (int)SteamInput()->GetCurrentActionSet(c_handle);
}
DEFINE_PRIM(_I32, get_current_action_set, _I32);

HL_PRIM void HL_NAME(trigger_haptic_pulse)(int controllerHandle, int targetPad, int durationMicroSec){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
ESteamControllerPad eTargetPad;
switch(targetPad) {
case 0: eTargetPad = k_ESteamControllerPad_Left;
Expand All @@ -280,12 +290,12 @@ HL_PRIM void HL_NAME(trigger_haptic_pulse)(int controllerHandle, int targetPad,
}
unsigned short usDurationMicroSec = durationMicroSec;

SteamController()->TriggerHapticPulse(c_handle, eTargetPad, usDurationMicroSec);
SteamInput()->Legacy_TriggerHapticPulse(c_handle, eTargetPad, usDurationMicroSec);
}
DEFINE_PRIM(_VOID, trigger_haptic_pulse, _I32 _I32 _I32);

HL_PRIM void HL_NAME(trigger_repeated_haptic_pulse)(int controllerHandle, int targetPad, int durationMicroSec, int offMicroSec, int repeat, int flags){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
ESteamControllerPad eTargetPad;
switch(targetPad) {
case 0: eTargetPad = k_ESteamControllerPad_Left;
Expand All @@ -297,19 +307,19 @@ HL_PRIM void HL_NAME(trigger_repeated_haptic_pulse)(int controllerHandle, int ta
unsigned short unRepeat = repeat;
unsigned short nFlags = flags;

SteamController()->TriggerRepeatedHapticPulse(c_handle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
SteamInput()->Legacy_TriggerRepeatedHapticPulse(c_handle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
}
DEFINE_PRIM(_VOID, trigger_repeated_haptic_pulse, _I32 _I32 _I32 _I32 _I32 _I32);

HL_PRIM void HL_NAME(trigger_vibration)(int controllerHandle, int leftSpeed, int rightSpeed){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
SteamController()->TriggerVibration(c_handle, (unsigned short)leftSpeed, (unsigned short)rightSpeed);
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
SteamInput()->TriggerVibration(c_handle, (unsigned short)leftSpeed, (unsigned short)rightSpeed);
}
DEFINE_PRIM(_VOID, trigger_vibration, _I32 _I32 _I32);

HL_PRIM void HL_NAME(set_led_color)(int controllerHandle, int r, int g, int b, int flags){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
SteamController()->SetLEDColor(c_handle, (uint8)r, (uint8)g, (uint8)b, (unsigned int) flags);
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
SteamInput()->SetLEDColor(c_handle, (uint8)r, (uint8)g, (uint8)b, (unsigned int) flags);
}
DEFINE_PRIM(_VOID, set_led_color, _I32 _I32 _I32 _I32 _I32);

Expand All @@ -329,8 +339,8 @@ typedef struct {
} motion_data;

HL_PRIM void HL_NAME(get_motion_data)(int controllerHandle, motion_data *data){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
ControllerMotionData_t d = SteamController()->GetMotionData(c_handle);
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
InputMotionData_t d = SteamInput()->GetMotionData(c_handle);

data->rotQuatX = d.rotQuatX;
data->rotQuatY = d.rotQuatY;
Expand All @@ -346,46 +356,46 @@ HL_PRIM void HL_NAME(get_motion_data)(int controllerHandle, motion_data *data){
DEFINE_PRIM(_VOID, get_motion_data, _I32 _OBJ(_F64 _F64 _F64 _F64 _F64 _F64 _F64 _F64 _F64 _F64));

HL_PRIM bool HL_NAME(show_digital_action_origins)(int controllerHandle, int digitalActionHandle, double scale, double xPosition, double yPosition){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
return false; //SteamController()->ShowDigitalActionOrigins(c_handle, digitalActionHandle, (float)scale, (float)xPosition, (float)yPosition);
}
DEFINE_PRIM(_BOOL, show_digital_action_origins, _I32 _I32 _F64 _F64 _F64);

HL_PRIM bool HL_NAME(show_analog_action_origins)(int controllerHandle, int analogActionHandle, double scale, double xPosition, double yPosition){
ControllerHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS;
InputHandle_t c_handle = controllerHandle != -1 ? mapControllers.get(controllerHandle) : STEAM_INPUT_HANDLE_ALL_CONTROLLERS;
return false; //SteamController()->ShowAnalogActionOrigins(c_handle, analogActionHandle, (float)scale, (float)xPosition, (float)yPosition);
}
DEFINE_PRIM(_BOOL, show_analog_action_origins, _I32 _I32 _F64 _F64 _F64);


//-----------------------------------------------------------------------------------------------------------
HL_PRIM int HL_NAME(get_controller_max_count)(){
return STEAM_CONTROLLER_MAX_COUNT;
return STEAM_INPUT_MAX_COUNT;
}
DEFINE_PRIM(_I32, get_controller_max_count, _NO_ARG);

HL_PRIM int HL_NAME(get_controller_max_analog_actions)(){
return STEAM_CONTROLLER_MAX_ANALOG_ACTIONS;
return STEAM_INPUT_MAX_ANALOG_ACTIONS;
}
DEFINE_PRIM(_I32, get_controller_max_analog_actions, _NO_ARG);

HL_PRIM int HL_NAME(get_controller_max_digital_actions)(){
return STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS;
return STEAM_INPUT_MAX_DIGITAL_ACTIONS;
}
DEFINE_PRIM(_I32, get_controller_max_digital_actions, _NO_ARG);

HL_PRIM int HL_NAME(get_controller_max_origins)(){
return STEAM_CONTROLLER_MAX_ORIGINS;
return STEAM_INPUT_MAX_ORIGINS;
}
DEFINE_PRIM(_I32, get_controller_max_origins, _NO_ARG);

HL_PRIM double HL_NAME(get_controller_min_analog_action_data)(){
return STEAM_CONTROLLER_MIN_ANALOG_ACTION_DATA;
return STEAM_INPUT_MIN_ANALOG_ACTION_DATA;
}
DEFINE_PRIM(_F64, get_controller_min_analog_action_data, _NO_ARG);

HL_PRIM double HL_NAME(get_controller_max_analog_action_data)(){
return STEAM_CONTROLLER_MAX_ANALOG_ACTION_DATA;
return STEAM_INPUT_MAX_ANALOG_ACTION_DATA;
}
DEFINE_PRIM(_F64, get_controller_max_analog_action_data, _NO_ARG);

Loading