Release v0.4.2

v0.4.2

.clang-format

@@ -1,2 +1,7 @@
 BasedOnStyle: Google
-ColumnLimit: 170
+ColumnLimit: 150
+BinPackParameters: false
+BinPackArguments: false
+AlignAfterOpenBracket: AlwaysBreak
+AllowShortFunctionsOnASingleLine: Empty
+NamespaceIndentation: All

README.md

@@ -25,7 +25,7 @@ If you are planning on modifying source files, refer to [BUILDING.md](https://gi
 
 ## Compatibility
 ### Compatible Hardware
-* [LucidVR Gloves](https://github.com/LucidVR/lucidgloves-hardware) - Lucas VRTech
+* [LucidGloves](https://github.com/LucidVR/lucidgloves) - Lucas VRTech
 * [Fngrs](https://github.com/danwillm/Fngrs/) - danwillm
 * Have your own hardware you want to feature here? Let us know!
 

include/Bones.h

@@ -6,78 +6,79 @@
 #include "openvr_driver.h"
 
 enum class HandSkeletonBone : vr::BoneIndex_t {
-  eBone_Root = 0,
-  eBone_Wrist,
-  eBone_Thumb0,
-  eBone_Thumb1,
-  eBone_Thumb2,
-  eBone_Thumb3,
-  eBone_IndexFinger0,
-  eBone_IndexFinger1,
-  eBone_IndexFinger2,
-  eBone_IndexFinger3,
-  eBone_IndexFinger4,
-  eBone_MiddleFinger0,
-  eBone_MiddleFinger1,
-  eBone_MiddleFinger2,
-  eBone_MiddleFinger3,
-  eBone_MiddleFinger4,
-  eBone_RingFinger0,
-  eBone_RingFinger1,
-  eBone_RingFinger2,
-  eBone_RingFinger3,
-  eBone_RingFinger4,
-  eBone_PinkyFinger0,
-  eBone_PinkyFinger1,
-  eBone_PinkyFinger2,
-  eBone_PinkyFinger3,
-  eBone_PinkyFinger4,
-  eBone_Aux_Thumb,
-  eBone_Aux_IndexFinger,
-  eBone_Aux_MiddleFinger,
-  eBone_Aux_RingFinger,
-  eBone_Aux_PinkyFinger,
-  eBone_Count
+  Root = 0,
+  Wrist,
+  Thumb0,
+  Thumb1,
+  Thumb2,
+  Thumb3,
+  IndexFinger0,
+  IndexFinger1,
+  IndexFinger2,
+  IndexFinger3,
+  IndexFinger4,
+  MiddleFinger0,
+  MiddleFinger1,
+  MiddleFinger2,
+  MiddleFinger3,
+  MiddleFinger4,
+  RingFinger0,
+  RingFinger1,
+  RingFinger2,
+  RingFinger3,
+  RingFinger4,
+  PinkyFinger0,
+  PinkyFinger1,
+  PinkyFinger2,
+  PinkyFinger3,
+  PinkyFinger4,
+  AuxThumb,
+  AuxIndexFinger,
+  AuxMiddleFinger,
+  AuxRingFinger,
+  AuxPinkyFinger,
+  _Count
 };
 
-const short NUM_BONES = (short)HandSkeletonBone::eBone_Count;
+const short NUM_BONES = static_cast<short>(HandSkeletonBone::_Count);
 
 extern vr::VRBoneTransform_t rightOpenPose[NUM_BONES];
 extern vr::VRBoneTransform_t leftOpenPose[NUM_BONES];
 
-struct Transform_t {
-  Transform_t();
+struct Transform {
+  Transform();
   std::array<float, 4> rotation;
   std::array<float, 3> translation;
 };
 
-struct AnimationData_t {
-  AnimationData_t();
-  Transform_t startTransform;
+struct AnimationData {
+  AnimationData();
+  Transform startTransform;
   float startTime;
-  Transform_t endTransform;
+  Transform endTransform;
   float endTime;
+  float fScaled;
 };
 
 class IModelManager {
  public:
   virtual bool Load() = 0;
 
-  virtual AnimationData_t GetAnimationDataByBoneIndex(const HandSkeletonBone& boneIndex, float f) const = 0;
-  virtual Transform_t GetTransformByBoneIndex(const HandSkeletonBone& boneIndex) const = 0;
+  virtual AnimationData GetAnimationDataByBoneIndex(const HandSkeletonBone& boneIndex, float f) const = 0;
+  virtual Transform GetTransformByBoneIndex(const HandSkeletonBone& boneIndex) const = 0;
 };
 
 class BoneAnimator {
  public:
-  BoneAnimator(const std::string& fileName);
+  explicit BoneAnimator(const std::string& fileName);
   void ComputeSkeletonTransforms(vr::VRBoneTransform_t* skeleton, const std::array<float, 5>& flexion, const bool rightHand);
-  void TransformLeftBone(vr::VRBoneTransform_t& bone, const HandSkeletonBone& boneIndex);
+  static void TransformLeftBone(vr::VRBoneTransform_t& bone, const HandSkeletonBone& boneIndex);
 
  private:
-  vr::VRBoneTransform_t GetTransformForBone(const HandSkeletonBone& boneIndex, const float f, const bool rightHand);
+  void SetTransformForBone(vr::VRBoneTransform_t& bone, const HandSkeletonBone& boneIndex, const float f, const bool rightHand) const;
 
-  std::string m_fileName;
-  std::unique_ptr<IModelManager> m_modelManager;
-  bool m_loaded;
-  std::vector<float> m_keyframes;
+  std::string fileName_;
+  std::unique_ptr<IModelManager> modelManager_;
+  bool loaded_;
+  std::vector<float> keyframes_;
 };

include/Calibration.h

@@ -1,23 +1,31 @@
 #pragma once
-#include <openvr_driver.h>
-#include <memory>
+
 #include "DeviceConfiguration.h"
+#include "openvr_driver.h"
+
+enum class CalibrationMethod {
+  Hardware,
+  Ui,
+  None,
+};
 
 class Calibration {
-public:
-    Calibration();
+ public:
+  Calibration();
+
+  void StartCalibration(vr::DriverPose_t maintainPose, CalibrationMethod method);
 
-    void StartCalibration(vr::DriverPose_t maintainPose);
+  VRPoseConfiguration CompleteCalibration(
+      vr::TrackedDevicePose_t controllerPose, VRPoseConfiguration poseConfiguration, bool isRightHand, CalibrationMethod method);
 
-    VRPoseConfiguration_t CompleteCalibration(vr::TrackedDevicePose_t controllerPose, VRPoseConfiguration_t poseConfiguration, bool isRightHand);
+  void CancelCalibration(CalibrationMethod method);
 
-    void CancelCalibration();
+  bool IsCalibrating() const;
 
-    bool isCalibrating();
-
-    vr::DriverPose_t GetMaintainPose();
+  vr::DriverPose_t GetMaintainPose() const;
 
-private:
-    vr::DriverPose_t m_maintainPose;
-    bool m_isCalibrating;
+ private:
+  vr::DriverPose_t maintainPose_;
+  bool isCalibrating_;
+  CalibrationMethod calibratingMethod_;
 };

include/Communication/BTSerialCommunicationManager.h

@@ -1,61 +1,39 @@
 #pragma once
-#include <Winsock2.h>
-#include <Ws2bth.h>
+
+#include <WinSock2.h>
 #include <bluetoothapis.h>
-#include <windows.h>
 
 #include <atomic>
-#include <chrono>
 #include <memory>
-#include <mutex>
-#include <sstream>
-#include <thread>
-#include <vector>
+#include <string>
 
-#include "CommunicationManager.h"
+#include "Communication/CommunicationManager.h"
 #include "DeviceConfiguration.h"
-#include "DriverLog.h"
+#include "Encode/EncodingManager.h"
 
-class BTSerialCommunicationManager : public ICommunicationManager {
+class BTSerialCommunicationManager : public CommunicationManager {
  public:
-  BTSerialCommunicationManager(const VRBTSerialConfiguration_t& configuration, std::unique_ptr<IEncodingManager> encodingManager);
+  BTSerialCommunicationManager(
+      std::unique_ptr<EncodingManager> encodingManager, VRBTSerialConfiguration configuration, const VRDeviceConfiguration& deviceConfiguration);
 
-  // start a thread that listens for updates from the device and calls the callback with data
-  void BeginListener(const std::function<void(VRCommData_t)>& callback);
-  // returns if connected or not
-  bool IsConnected();
-  // close the serial port
-  void Disconnect();
+  bool IsConnected() override;
 
-  void QueueSend(const VRFFBData_t& data);
+ protected:
+  bool Connect() override;
+  bool DisconnectFromDevice() override;
+  void LogError(const char* message) override;
+  void LogMessage(const char* message) override;
+  bool ReceiveNextPacket(std::string& buff) override;
+  bool SendMessageToDevice() override;
 
  private:
-  bool Connect();
-  void ListenerThread(const std::function<void(VRCommData_t)>& callback);
-  bool ReceiveNextPacket(std::string& buff);
-  bool GetPairedDeviceBtAddress();
+  bool ConnectToDevice(const BTH_ADDR& deviceBtAddress);
+  bool GetPairedDeviceBtAddress(BTH_ADDR* deviceBtAddress);
   bool StartupWindowsSocket();
-  bool ConnectToDevice();
-  bool SendMessageToDevice();
-  void WaitAttemptConnection();
-  bool DisconnectFromDevice();
-  void LogError(const char* message);
-  void LogMessage(const char* message);
-
-  std::atomic<bool> m_isConnected;
-  std::atomic<bool> m_threadActive;
-  std::thread m_serialThread;
-
-  std::unique_ptr<IEncodingManager> m_encodingManager;
-
-  VRBTSerialConfiguration_t m_btSerialConfiguration;
 
-  BTH_ADDR m_deviceBtAddress;
-  SOCKADDR_BTH m_btSocketAddress;
-  SOCKET m_btClientSocket;
-  WCHAR* m_wcDeviceName;
+  VRBTSerialConfiguration btSerialConfiguration_;
 
-  std::mutex m_writeMutex;
+  std::atomic<bool> isConnected_;
 
-  std::string m_writeString = "\n";
+  std::atomic<SOCKET> btClientSocket_;
 };

include/Communication/CommunicationManager.h

@@ -1,17 +1,43 @@
 #pragma once
+
+#include <atomic>
 #include <functional>
 #include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
 
+#include "DeviceConfiguration.h"
 #include "Encode/EncodingManager.h"
 
-class ICommunicationManager {
+class CommunicationManager {
  public:
-  virtual void BeginListener(const std::function<void(VRCommData_t)>& callback) = 0;
+  explicit CommunicationManager(const VRDeviceConfiguration& deviceConfiguration);
+  CommunicationManager(std::unique_ptr<EncodingManager> encodingManager, const VRDeviceConfiguration& deviceConfiguration);
+
+  virtual void BeginListener(const std::function<void(VRInputData)>& callback);
+  virtual void Disconnect();
+  virtual void QueueSend(const VRFFBData& data);
+
   virtual bool IsConnected() = 0;
-  virtual void Disconnect() = 0;
 
-  virtual void QueueSend(const VRFFBData_t& data) = 0;
+ protected:
+  virtual void ListenerThread(const std::function<void(VRInputData)>& callback);
+  virtual void WaitAttemptConnection();
+
+  virtual bool Connect() = 0;
+  virtual bool DisconnectFromDevice() = 0;
+  virtual void LogError(const char* message) = 0;
+  virtual void LogMessage(const char* message) = 0;
+  virtual bool ReceiveNextPacket(std::string& buff) = 0;
+  virtual bool SendMessageToDevice() = 0;
+
+  std::unique_ptr<EncodingManager> encodingManager_;
+  VRDeviceConfiguration deviceConfiguration_;
+
+  std::atomic<bool> threadActive_;
+  std::thread thread_;
 
- private:
-  std::unique_ptr<IEncodingManager> m_encodingManager;
+  std::mutex writeMutex_;
+  std::string writeString_;
 };

include/Communication/NamedPipeCommunicationManager.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+
+#include "Communication/CommunicationManager.h"
+#include "DeviceConfiguration.h"
+#include "Util/NamedPipeListener.h"
+
+class NamedPipeCommunicationManager : public CommunicationManager {
+ public:
+  NamedPipeCommunicationManager(VRNamedPipeInputConfiguration configuration, const VRDeviceConfiguration& deviceConfiguration);
+  bool IsConnected() override;
+  void QueueSend(const VRFFBData& data) override{};
+
+ protected:
+  bool Connect() override;
+  bool DisconnectFromDevice() override;
+  void LogError(const char* message) override;
+  void LogMessage(const char* message) override;
+
+  // Functions currently unimplemented
+  bool SendMessageToDevice() override {
+    return true;
+  };
+  bool ReceiveNextPacket(std::string& buff) override {
+    return true;
+  };
+
+  void BeginListener(const std::function<void(VRInputData)>& callback) override;
+
+ private:
+  std::unique_ptr<NamedPipeListener<VRInputData>> namedPipeListener_;
+  std::atomic<bool> isConnected_;
+
+  std::function<void(VRInputData)> callback_;
+
+  VRNamedPipeInputConfiguration configuration_;
+};