Forte Data Gloves

C++ SDK

On this page

    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