Access research mode from a c# script about hololens2forcv HOT 8 OPEN

IntPtr hrResearchMode = NativeAPI.LoadLibraryA("ResearchModeAPI");
if (hrResearchMode == IntPtr.Zero) throw new InvalidOperationException("The ResearchModeAPI library could not be loaded.");
IntPtr procAddress = NativeAPI.GetProcAddress(hrResearchMode, "CreateResearchModeSensorDevice");
if (procAddress == IntPtr.Zero) throw new InvalidOperationException("Procedure CreateResearchModeSensorDevice not found.");
CreateResearchModeSensorDevice pfnCreate = (CreateResearchModeSensorDevice) Marshal.GetDelegateForFunctionPointer(procAddress, typeof(CreateResearchModeSensorDevice));
Marshal.ThrowExceptionForHR(pfnCreate(out IntPtr device));

Guid guid = typeof(IResearchModeSensorDevicePerception).GUID;
int queryInterface = Marshal.QueryInterface(device, ref guid, out IntPtr devicePerception);
Marshal.ThrowExceptionForHR(queryInterface);

[UnmanagedFunctionPointer(CallingConvention.StdCall)]
delegate int CreateResearchModeSensorDevice([Out] out IntPtr sensorDevice);

static class NativeAPI
{
     [DllImport("kernel32.dll")]
     public static extern IntPtr LoadLibrary(string dllToLoad);

     [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true)]
     public static extern IntPtr LoadLibraryA(string lpLibFileName);

     [DllImport("kernel32.dll")]
     public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);

     [DllImport("kernel32.dll")]
     public static extern bool FreeLibrary(IntPtr hModule);
}

[ComImport]
[Guid("C1678F4B-ECB4-47A8-B6FA-97DBF4417DB2")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
interface IResearchModeSensorDevicePerception
{
     [PreserveSig]
     int GetRigNodeId([Out] out Guid rigNodeId);
}

...
 unsafe {
   // get data from dll
   SensorDataStruct* dataPointer = getAccDataBatched();

   // save it in struct
   for (int i = 0; i < ACCBATCHSIZE; i++) {
     accData.timestamp = dataPointer[i].VinylHupTicks;
     accData.sensorData = new Vector3(dataPointer[i].SensorValueX, dataPointer[i].SensorValueY, dataPointer[i].SensorValueZ);

     ...
     // fire event with new sensor data
     ...
   }
 }
...

extern "C" {
  //##### Structs #####
  struct SensorDataStruct {
    uint64_t VinylHupTicks;
    float SensorValueX;
    float SensorValueY;
    float SensorValueZ;
  };

  //##### Class #####
  class DllExports {
public:
    DllExport static SensorDataStruct* GetAccDataBatched();

    ...
  };
}

		static SensorDataStruct *GetAccDataBatched();

		static void CloseAccSensorStream();

		static void ReleaseSensors();

		static void ImuAccessOnComplete(ResearchModeSensorConsent consent);

};
	//##### Global Vars #####
	// static vars for research mode init
       static IResearchModeSensorDeviceConsent* m_pSensorDeviceConsent;
	static IResearchModeSensorFrame *pSensorFrame;

	static IResearchModeSensorDevice *m_pSensorDevice;
	static std::vector<ResearchModeSensorDescriptor> m_sensorDescriptors;		
	static IResearchModeAccelFrame *m_pSensorAccelFrame;

	// static vars for sensor access
	static IResearchModeSensor *m_pAcclSensor;
	
	HRESULT hr = S_OK;

HMODULE hrResearchMode = LoadLibraryA("ResearchModeAPI");
if (hrResearchMode)
{
	
	typedef HRESULT(__cdecl* PFN_CREATEPROVIDER) (IResearchModeSensorDevice** ppSensorDevice);
	PFN_CREATEPROVIDER pfnCreate = reinterpret_cast<PFN_CREATEPROVIDER>(GetProcAddress(hrResearchMode, "CreateResearchModeSensorDevice"));
	if (pfnCreate)
	{
		hr = pfnCreate(&m_pSensorDevice);
	}
	else
	{
		hr = E_INVALIDARG;
	}

}
m_pSensorDevice->QueryInterface(IID_PPV_ARGS(&m_pSensorDeviceConsent));
m_pSensorDeviceConsent->RequestIMUAccessAsync(ImuAccessOnComplete);

m_pSensorDevice->DisableEyeSelection();

m_pSensorDevice->GetSensorCount(&sensorCount);
m_sensorDescriptors.resize(sensorCount);

m_pSensorDevice->GetSensorDescriptors(m_sensorDescriptors.data(), m_sensorDescriptors.size(), &sensorCount);

for (auto& sensorDescriptor : m_sensorDescriptors)
{
	if (sensorDescriptor.sensorType == IMU_ACCEL)
	{
		
		m_pSensorDevice->GetSensor(sensorDescriptor.sensorType, &m_pAcclSensor);
	}
}

m_pAcclSensor->GetNextBuffer(&pSensorFrame);
hr = pSensorFrame->QueryInterface(IID_PPV_ARGS(&m_pSensorAccelFrame));

// get the sensor Frame and next buffer
	const AccelDataStruct* accelBuffer;
    size_t BufferOutLength;
	// read sensor values ...
	hr = m_pSensorAccelFrame->GetCalibratedAccelarationSamples(&accelBuffer, &BufferOutLength);

	SensorDataStruct* data = new SensorDataStruct[BufferOutLength];  // ?
	// … and copy them to return array
	for (UINT i = 0; i < BufferOutLength; i++)
	{
		data[i].VinylHupTicks = accelBuffer[i].VinylHupTicks;
		data[i].SocTicks = accelBuffer[i].SocTicks;
		data[i].SensorValueX = accelBuffer[i].AccelValues[0];
		data[i].SensorValueY = accelBuffer[i].AccelValues[1];
		data[i].SensorValueZ = accelBuffer[i].AccelValues[2];
		data[i].temperature = accelBuffer[i].temperature;
	}
	return data;

m_pSensorAccelFrame->Release();

class DllExports {
  public:
    DllExport static void InitSensors();
    DllExport static void OpenAccSensorStream();
    DllExport static void GetAccDataStamped(float& accX, float& accY, float& accZ, UINT64& timestamp);
    DllExport static void CloseAccSensorStream();
    ....
    DllExport static void ReleaseSensors();
};

class DllExport DllExports {
  public:
    static void InitSensors();
    static void OpenAccSensorStream();
    static SensorDataStruct *GetAccDataBatched();
    static void CloseAccSensorStream();
    static void ReleaseSensors();
    static void ImuAccessOnComplete(ResearchModeSensorConsent consent);
};