sOpenvr.h

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2012 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

-----------------------------------------------------------------------------
*/

#ifndef S_OPENVR_H
#define S_OPENVR_H

#include <scolPlugin.h>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include "vrmaths.h"
#include "openvr/openvr.h" // Include the OpenVR SDK

#define USE_VR_INPUT 0

#ifdef USE_VIVE_GESTURE
# include "interface_gesture.hpp"
#define MAX_VR_CONTROLLERS 10
#else
#define MAX_VR_CONTROLLERS 8
#endif



enum VrControllerSide
{
  Left,
  Right,
  Undefined
};

class sOpenvrController
{
public:
  enum ControllerType
  {
    CLASSIC_CONTROLLER = 0,
    TRACKER_CONTROLLER = 1,
    HANDS_CONTROLLER = 2
  };
protected:
private:
  vr::IVRSystem* mHmdSystem;
  unsigned int mDeviceId;
  bool mVisible;
  VrControllerSide mSide;
  Matrix4 mMatrix;
  vr::VRControllerState_t mControllerState;
  std::vector<vr::EVRButtonId> mButtonsToHandle;
  std::vector<bool> mButtonsStates;
  Vector3 mAxisValues;
  Vector3 mVelocity;
  Vector3 mAngularVelocity;
  int64 mLastRumble;
  ControllerType mType;

#if USE_VR_INPUT
  vr::VRInputValueHandle_t mSource;
  vr::VRActionHandle_t mActionPose;
  vr::VRActionHandle_t mActionHaptic;
  vr::VRActionHandle_t mPadAxis;
  vr::VRActionHandle_t mTriggerAxis;

  std::vector<vr::VRActionHandle_t> mActionsToHandle;
#endif

#ifdef USE_VIVE_GESTURE
  GestureType mLastGesture;
#endif

public:
  sOpenvrController(vr::IVRSystem* hmdSystem, unsigned int id);

  ~sOpenvrController();

  void Update(vr::TrackedDevicePose_t* trackedPoses, unsigned int deviceId);

#ifdef USE_VIVE_GESTURE
  void UpdateGesture(GestureResult result, unsigned int deviceId);
  GestureType GetLastGesture();
#endif
  
  bool IsVisible();
  void SetState(bool state);
  void SetSide(VrControllerSide side);
  VrControllerSide GetSide();
  void SetType(ControllerType type);
  ControllerType GetType();
  Vector3 GetPosition();
  Vector3 GetVelocity();
  Vector3 GetAngularVelocity();
  Quaternion GetOrientation();
  void Rumble(float value);
  std::vector<bool> GetButtonsState();
  Vector3 GetAxisValues();
};

class sOpenvr
{
public:
protected:
  bool mConnected;
  
private:
  vr::IVRSystem* mHMDSystem;
  vr::HmdError mHMDError;
  vr::TrackedDevicePose_t mTrackedPoses[vr::k_unMaxTrackedDeviceCount];
  std::array<vr::VRTextureBounds_t, 2> mTexturesBounds;
  std::array<vr::Texture_t, 2> mTextures;
  Quaternion mPreviousHmdQuat;
  Vector3 mPreviousHmdPos;
  std::array<sOpenvrController*, MAX_VR_CONTROLLERS> mControllers;
  vr::IVRTrackedCamera* mCamera;
  vr::TrackedCameraHandle_t     mTrackedCameraHandle;
  uint32_t mCameraWidth;
  uint32_t mCameraHeight;
  uint32_t mCameraFrameBufferSize;
  uint8_t* mCameraFrameBuffer;
  uint32_t mCameraLastFrameId;
  bool mCameraEnable;
  bool mVisible;

#if USE_VR_INPUT
  vr::VRActionSetHandle_t mActionSet;
  std::string mInputPath;
#endif

#ifdef USE_VIVE_GESTURE
  bool mGestureInterface;
  GestureOption mGestureOption;
  int mLastGestureFrameIndex;
#endif
public:
        sOpenvr(const char* inpuPath);
        
        ~sOpenvr();

  static Matrix4 getMatrix4FromSteamVRMatrix34(const vr::HmdMatrix34_t& mat);
  bool Connect();
  void Disconnect();
  void ResetHmd();
  bool IsConnected();
  bool IsVisible();

  bool GetHmdOrientation(Quaternion &quat);
  bool GetHmdPosition(Vector3 &vec);

  std::string GetHmdName();
  bool GetProjectionMatrix(vr::EVREye eye, float nearclip, float farclip, Matrix4 &mat);
  bool GetStereoTextureSize(unsigned int &w, unsigned int &h);
  float GetStereoConfigAspect();
  float GetStereoConfigFovY();
  float GetStereoIPD();
  bool Update();
  void UpdateTextures(void* leftTexture, void* rightTexture, vr::ETextureType type);
  sOpenvrController* GetController(unsigned int id);

  bool HaveCamera();
  bool IsCameraEnable();
  void GetCameraSize(uint32_t &w, uint32_t &h);
  bool StartCamera();
  void StopCamera();
  bool GetCameraFrame(PtrObjBitmap scolBitmap);

protected:
private:
  void ProcessEvents();
  void ProcessTrackedDevices();
};

class ConversionTools
{
public:
  class SConvertBuffer
  {
  public:
    SConvertBuffer(uchar* _srcBuff, uchar* _srcBuffa, void* _dstBuff, const int &_width, const int &_height, const int &_sbpl, const int &_abpl, const int &_dbpl, const int &_bpp) :
      srcBuff(_srcBuff),
      srcBuffa(_srcBuffa),
      dstBuff(_dstBuff),
      width(_width),
      height(_height),
      sbpl(_sbpl),
      abpl(_abpl),
      dbpl(_dbpl),
      bpp(_bpp)
    {}

    ~SConvertBuffer(){}

    uchar* srcBuff;
    uchar* srcBuffa;
    void* dstBuff;
    const int width;
    const int height;
    const int sbpl;
    const int abpl;
    const int dbpl;
    const int bpp;
  };
protected:
private:

public:
  static void BuffToBitmap(const int start, const int end, const SConvertBuffer &conv);

protected:
private:
  ConversionTools();
};

#endif