xaymar/BlitzSteam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 4 Wiki Activity

* Fix BlitzSteam.h including uneccessary headers.

Browse Source 
* Rename Callback class to BlitzCallback and add state-aware functionality (Register, RegisterResult, automatic unregistering).
* Add functionality to delete Long pointers.
* Add functionality to create and delete Doubles.
* Add memory management functionality.
* Reimplement SteamController Wrapper.
* Implement SteamHTMLSurface Wrapper.
* Fix up Declaration File and make it more descriptive.
* Add Blitz Examples and Project.
This commit is contained in:
Michael Dirks
2016-02-23 13:25:34 +01:00
parent 0ebbd7e9a0
commit 30beba2ada
27 changed files with 2190 additions and 699 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Wrapper/SteamController.cpp
+101 -16
View File
@@ -17,38 +17,123 @@
#include "BlitzSteam.h"
DLL_FUNCTION(ISteamController*) BS_Controller() {
#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
return SteamController();
}
#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
// Init and Shutdown must be called when starting/ending use of this interface
DLL_FUNCTION(uint32_t) BS_Controller_Init(ISteamController* lpSteamController) {
#pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")
return lpSteamController->Init();
}
#pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")
// Init and Shutdown must be called when starting/ending use of this interface
DLL_FUNCTION(uint32_t) BS_Controller_Shutdown(ISteamController* lpSteamController) {
#pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")
return lpSteamController->Shutdown();
}
#pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")
// Pump callback/callresult events
// Note: SteamAPI_RunCallbacks will do this for you, so you should never need to call this directly.
DLL_FUNCTION(void) BS_Controller_RunFrame(ISteamController* lpSteamController) {
#pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")
lpSteamController->RunFrame();
}
#pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")
#if 0
DLL_FUNCTION(uint32_t) BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) {
return lpSteamController->GetControllerState( unControllerIndex, pState );
// Enumerate currently connected controllers
// handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles
// Returns the number of handles written to handlesOut
DLL_FUNCTION(uint32_t) BS_Controller_GetConnectedControllersEx(ISteamController* lpSteamController, ControllerHandle_t* pHandlesOut) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllersEx=_BS_Controller_GetConnectedControllersEx@8")
return lpSteamController->GetConnectedControllers(pHandlesOut);
}
#pragma comment(linker, "/EXPORT:BS_Controller_GetControllerState=_BS_Controller_GetControllerState@12")
DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) {
lpSteamController->TriggerHapticPulse( unControllerIndex, eTargetPad, usDurationMicroSec );
ControllerHandle_t* pControllerHandles = new ControllerHandle_t[STEAM_CONTROLLER_MAX_COUNT];
DLL_FUNCTION(uint32_t) BS_Controller_GetConnectedControllers(ISteamController* lpSteamController) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllers=_BS_Controller_GetConnectedControllers@4")
return lpSteamController->GetConnectedControllers(pControllerHandles);
}
DLL_FUNCTION(ControllerHandle_t*) BS_Controller_GetConnectedControllers_Index(uint32_t index) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllers_Index=_BS_Controller_GetConnectedControllers_Index@4")
if (index >= STEAM_CONTROLLER_MAX_COUNT)
index = STEAM_CONTROLLER_MAX_COUNT - 1;
return &(pControllerHandles[index]);
}
// Invokes the Steam overlay and brings up the binding screen
// Returns false is overlay is disabled / unavailable, or the user is not in Big Picture mode
DLL_FUNCTION(uint32_t) BS_Controller_ShowBindingPanel(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
#pragma comment(linker, "/EXPORT:BS_Controller_ShowBindingPanel=_BS_Controller_ShowBindingPanel@8")
return lpSteamController->ShowBindingPanel(*pControllerHandle);
}
// ACTION SETS
// Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls.
DLL_FUNCTION(ControllerActionSetHandle_t*) BS_Controller_GetActionSetHandle(ISteamController* lpSteamController, const char* pszActionSetName) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetActionSetHandle=_BS_Controller_GetActionSetHandle@8")
return new ControllerActionSetHandle_t(lpSteamController->GetActionSetHandle(pszActionSetName));
}
// Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive')
// This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in
// your state loops, instead of trying to place it in all of your state transitions.
DLL_FUNCTION(void) BS_Controller_ActivateActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle) {
#pragma comment(linker, "/EXPORT:BS_Controller_ActivateActionSet=_BS_Controller_ActivateActionSet@12")
lpSteamController->ActivateActionSet(*pControllerHandle, *pActionSetHandle);
}
DLL_FUNCTION(ControllerActionSetHandle_t*) BS_Controller_GetCurrentActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetCurrentActionSet=_BS_Controller_GetCurrentActionSet@8")
return new ControllerActionSetHandle_t(lpSteamController->GetCurrentActionSet(*pControllerHandle));
}
// Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls.
DLL_FUNCTION(ControllerDigitalActionHandle_t*) BS_Controller_GetDigitalActionHandle(ISteamController* lpSteamController, const char* pszActionName) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionHandle=_BS_Controller_GetDigitalActionHandle@8")
return new ControllerDigitalActionHandle_t(lpSteamController->GetDigitalActionHandle(pszActionName));
}
// Returns the current state of the supplied digital game action
DLL_FUNCTION(ControllerDigitalActionData_t*) BS_Controller_GetDigitalActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionData=_BS_Controller_GetDigitalActionData@12")
return &lpSteamController->GetDigitalActionData(*pControllerHandle, *pDigitalActionHandle);
}
// Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
DLL_FUNCTION(int32_t) BS_Controller_GetDigitalActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
return lpSteamController->GetDigitalActionOrigins(*pControllerHandle, *pActionSetHandle, *pDigitalActionHandle, pEControllerActionOrigin);
}
// Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls.
DLL_FUNCTION(ControllerAnalogActionHandle_t*) BS_Controller_GetAnalogActionHandle(ISteamController* lpSteamController, const char *pszActionName) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
return new ControllerAnalogActionHandle_t(lpSteamController->GetAnalogActionHandle(pszActionName));
//BlitzSteam: Cleanup using BS_Helper_DeleteLongLong
}
// Returns the current state of these supplied analog game action
DLL_FUNCTION(ControllerAnalogActionData_t*) BS_Controller_GetAnalogActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
return &lpSteamController->GetAnalogActionData(*pControllerHandle, *pAnalogActionHandle);
}
// Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
DLL_FUNCTION(uint32_t) BS_Controller_GetAnalogActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
return lpSteamController->GetAnalogActionOrigins(*pControllerHandle, *pActionSetHandle, *pAnalogActionHandle, pEControllerActionOrigin);
}
DLL_FUNCTION(void) BS_Controller_StopAnalogActionMomentum(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
#pragma comment(linker, "/EXPORT:BS_Controller_StopAnalogActionMomentum=_BS_Controller_StopAnalogActionMomentum@12")
lpSteamController->StopAnalogActionMomentum(*pControllerHandle, *pAnalogActionHandle);
}
// Trigger a haptic pulse on a controller
DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec) {
#pragma comment(linker, "/EXPORT:BS_Controller_TriggerHapticPulse=_BS_Controller_TriggerHapticPulse@16")
DLL_FUNCTION(void) BS_Controller_SetOverrideMode( ISteamController* lpSteamController, const char *pchMode ) {
lpSteamController->SetOverrideMode( pchMode );
}
#pragma comment(linker, "/EXPORT:BS_Controller_SetOverrideMode=_BS_Controller_SetOverrideMode@8")
#endif // 0
lpSteamController->TriggerHapticPulse(*pControllerHandle, eTargetPad, (uint16_t)usDurationMicroSec);
}