C++ SDK

1. Prerequisites

Note: The C++ API is a collection of DLL and headers for 64-bit and 32-bit Windows 10. If you require a more in-depth Visual Studio project example this is something that we can make available. The instructions below give directions on how a developer can integrate our files with 2 different methods of DLL integration and use the Data Glove API functions.

2. Dynamically Loading the Data Glove API DLL

Since many environments have their own unique functions for loading a DLL built on Windows, the implementation of dynamically loading a DLL can change slightly from environment to environment, but the same basic steps are required in each case.

Step 1: Load the Data Glove API DLL with a given filepath

Here are a few examples of loading a dll in different environment APIs:

  • Unreal Engine: FPlatformProcess::GetDllHandle(filepath);
  • Qt: QLibrary lib = new QLibrary(filepath)
  • Windows: win32 API: LoadLibraryA(filepath)

Step 2: Create some function definitions and declare them

Based on the DataGloveAPI.h header file, a function definition can be created by copying the parameters and return type. Here are some functions to give you an idea of what to do:

Typedefs for API:

  • typedef void         (*DataGloveIO)         (void*);
  • typedef DataGloveIO* (*CreateDataGloveIO)          (byte handType, const char* name);
  • typedef byte         (*DestroyDataGloveIO)         (DataGloveIO* dgIO);
  • typedef float*       (*GetSensors)         (DataGloveIO* dgIO);
  • typedef short*      (*GetIMU)           (DataGloveIO* dgIO);
  • typedef float         (*GetBatteryLevel)         (DataGloveIO* dgIO);
  • typedef byte          (*GetConnectionState)         (DataGloveIO* dgIO);
  • typedef byte          (*GetHandType)         (DataGloveIO* dgIO);
  • typedef byte*        (*GetDeviceInfo)         (DataGloveIO* dgIO, byte infoKey);
  • typedef void          (*Calibrate)         (DataGloveIO* dgIO, byte calibrationKey, byte slot);
  • typedef void          (*Haptics)         (DataGloveIO* dgIO, byte functionKey, float* params);
  • typedef byte          (*UploadFile)         (DataGloveIO* dgIO, const char* filename, byte uploadSlot);
  • typedef void          (*EnterBootloader)         (DataGloveIO* dgIO);
  • typedef void          (*SetGloveID)         (DataGloveIO* dgIO, byte a1, byte a2, byte a3, byte a4);
  • typedef byte*         (*GetFullReport)         (DataGloveIO* dgIO);
  •  typedef byte*        (*HomeIMU)         (DataGloveIO* dgIO);

Declarations:

  • CreateDataGloveIO createDataGloveIO;
  • DestroyDataGloveIO destroyDataGloveIO;
  • GetSensors getSensors_DLL;
  • GetIMU getIMU_DLL;
  • GetBatteryLevel getBatteryLevel;
  • GetConnectionState getConnectionState;
  • GetConnectionState getHandType;
  • GetDeviceInfo getDeviceInfo;
  • Calibrate calibrate;
  • Haptics haptics;
  • UploadFile uploadFile_DLL;
  • EnterBootloader enterBootloader;
  • SetGloveID setGloveID;
  • GetFullReport getFullReport;
  • HomeIMU homeIMU;

Step 3: Link the functions from the DLL with the declared variables

Again, each environment has its own unique way of finding a function, so here’s an example from Qt and Unreal.

Qt:

createDataGloveIO = CreateDataGloveIO(lib->resolve(“Forte_CreateDataGloveIO”));

getSensors_DLL = GetSensors(lib->resolve(“Forte_GetSensors”));

Unreal:

createDataGloveIO = CreateDataGloveIO(FPlatformProcess::GetDllExport(dllHandle, *FString(“Forte_CreateDataGloveIO”)));

getSensors_DLL = GetSensors(FPlatformProcess::GetDllExport(dllHandle, 

Step 4: Call the functions

DataGloveIO* dataGloveIO = createDataGloveIO(2, name);

float* sensorsDLL = getSensors_DLL(dataGloveIO);

 

3. Statically Linking the Data Glove API DLL

TBA