OSVR-Vive

DriverWrapper类（DriverWrapper.h），主要有：

1.openvr_driver.h中接口：

vr::ITrackedDeviceServerDriver:

@brief:表示一个追踪设备。在驱动动态库中实现，如vive的driver_lighthouse.dll，运行时被vrserver加载，可用ITrackedDeviceServerProvider对象的Cleanup方法卸载。

vr::IVRServerDriverHost:

@brief:向server发送各类事件通知（Pose或Button按键信息等），提供以下函数功能：

1>.TrackedDeviceAdded：通知server一个追踪设备已经被添加。若返回true,则server将调用该设备的Active函数，若返回false，则该设备不会被active

2>.TrackedDevicePoseUpdated:往server发送pose信息

3>.TrackedDeviceAxisUpdated：往server发送x,y坐标轴信息(Joystick触摸板)

4>.GetRawTrackedDevicePoses：v1.0.7版本添加的函数，为驱动提供设备裸Pose信息


vr::IServerTrackedDeviceProvider:

@brief：用于查询发送追踪设备信息并往server发送，可理解为一个client与server的中间桥梁作用，在驱动dll动态库中实现，运行时被vrserver加载调用。提供以下函数：

1>.HmdError Init( IDriverLog *pDriverLog, vr::IServerDriverHost *pDriverHost, const char *pchUserDriverConfigDir, const char *pchDriverInstallDir )：

@brief:初始化驱动，该函数最先被调用（在任何函数之前）。当且仅当返回HmdError_None时，dll驱动才会被调用。

@pchUserDriverConfigDir：驱动用户配置文件的绝对路径，如：Steam\config

@pchDriverInstallDir:驱动根目录绝对路径，如：Steam\steamapps\common\SteamVR\drivers\lighthouse\bin\win64

@note:在V1.0.6之后，若provider含有HMD，则需在Init返回前，调用TrackedDeviceAdded添加HMD的详细信息。其他设备则可在任何时候调用TrackedDeviceAdded添加。

后续版本被virtual EVRInitError Init( IVRDriverContext *pDriverContext ) = 0所取代。

其中IVRDriverContext在后面分析。

2>.virtual void Cleanup():

@brief: 卸载vr::ITrackedDeviceServerDriver声明的驱动。

3>.virtual const char * const *GetInterfaceVersions() = 0:

@brief:返回驱动使用的vr::ITrackedDeviceServerDriver接口的版本号

4>.virtual void RunFrame() = 0：

@brief:在server的main循环中被调用，通过vr::ITrackedDeviceServerDriver提供的数据接口循环往server发送pose或button或axis等信息

5>.uint32_t GetTrackedDeviceCount()：

@brief:返回驱动连接追踪设备的数量。在启动时，可用来初始化驱动的追踪设备链表。


vr::IVRDriverContext:

@brief:获取驱动所需使用到的接口以及获取驱动handle

1>.virtual void *GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError = nullptr ) = 0：

@berief:通过版本号获取接口，以供后续使用。如：

m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface( IVRServerDriverHost_Version, &eError );  
static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_004"; 

@note:在新版本vr::IServerTrackedDeviceProvider的Init使用到。

比如：

EVRInitError CServerDriver_Sample::Init( vr::IVRDriverContext *pDriverContext )  
{  
    VR_INIT_SERVER_DRIVER_CONTEXT( pDriverContext );  
    InitDriverLog( vr::VRDriverLog() );  
  
    m_pNullHmdLatest = new CSampleDeviceDriver();  
    vr::VRServerDriverHost()->TrackedDeviceAdded( m_pNullHmdLatest->GetSerialNumber().c_str(), vr::TrackedDeviceClass_HMD, m_pNullHmdLatest );  
    return VRInitError_None;  
}  

在VR_INIT_SERVER_DRIVER_CONTEXT( pDriverContext )初始化m_pVRServerDriverHost，m_pVRSettings，

m_propertyHelpers，m_pVRDriverLog，m_pVRDriverManager，m_pVRResources接口，以供后续调用它们的方法。

2>.virtual DriverHandle_t GetDriverHandle() = 0：
@brief:返回该驱动属性容器的句柄

vr::IVRSettings:

@brief:提供接口用来获取类似Steam\steamapps\common\SteamVR\resources\settings\default.vrsettings文件下的属性字段

vr::IVRDriverLog:

@virtual void Log( const char *pchLogMessage ) = 0:

将log输出到log文件，并在log文件名前加驱动名前缀。

vr::IVRProperties:

@brief:对设备的属性进行读写，设备属性有追踪设备系统名，产品型号，产品序列号等。

enum ETrackedDeviceProperty  
{  
    Prop_Invalid                                = 0,  
  
    // general properties that apply to all device classes  
    Prop_TrackingSystemName_String              = 1000,  
    Prop_ModelNumber_String                     = 1001,  
    Prop_SerialNumber_String                    = 1002,  
    Prop_RenderModelName_String                 = 1003,  
    Prop_WillDriftInYaw_Bool                    = 1004,  
    Prop_ManufacturerName_String                = 1005,  
    Prop_TrackingFirmwareVersion_String         = 1006,  
    Prop_HardwareRevision_String                = 1007,  
    Prop_AllWirelessDongleDescriptions_String   = 1008,  
    Prop_ConnectedWirelessDongle_String         = 1009,  
    Prop_DeviceIsWireless_Bool                  = 1010,  
    Prop_DeviceIsCharging_Bool                  = 1011,  
    Prop_DeviceBatteryPercentage_Float          = 1012, // 0 is empty, 1 is full  
    Prop_StatusDisplayTransform_Matrix34        = 1013,  
    Prop_Firmware_UpdateAvailable_Bool          = 1014,  
    Prop_Firmware_ManualUpdate_Bool             = 1015,  
    Prop_Firmware_ManualUpdateURL_String        = 1016,  
    Prop_HardwareRevision_Uint64                = 1017,  
    Prop_FirmwareVersion_Uint64                 = 1018,  
    Prop_FPGAVersion_Uint64                     = 1019,  
    Prop_VRCVersion_Uint64                      = 1020,  
    Prop_RadioVersion_Uint64                    = 1021,  
    Prop_DongleVersion_Uint64                   = 1022,  
    Prop_BlockServerShutdown_Bool               = 1023,  
    Prop_CanUnifyCoordinateSystemWithHmd_Bool   = 1024,  
    Prop_ContainsProximitySensor_Bool           = 1025,  
    Prop_DeviceProvidesBatteryStatus_Bool       = 1026,  
    Prop_DeviceCanPowerOff_Bool                 = 1027,  
    Prop_Firmware_ProgrammingTarget_String      = 1028,  
    Prop_DeviceClass_Int32                      = 1029,  
    Prop_HasCamera_Bool                         = 1030,  
    Prop_DriverVersion_String                   = 1031,  
    Prop_Firmware_ForceUpdateRequired_Bool      = 1032,  
    Prop_ViveSystemButtonFixRequired_Bool       = 1033,  
    Prop_ParentDriver_Uint64                    = 1034,  
    Prop_ResourceRoot_String                    = 1035,  
  
    // Properties that are unique to TrackedDeviceClass_HMD  
    Prop_ReportsTimeSinceVSync_Bool             = 2000,  
    Prop_SecondsFromVsyncToPhotons_Float        = 2001,  
    Prop_DisplayFrequency_Float                 = 2002,  
    Prop_UserIpdMeters_Float                    = 2003,  
    Prop_CurrentUniverseId_Uint64               = 2004,   
    Prop_PreviousUniverseId_Uint64              = 2005,   
    Prop_DisplayFirmwareVersion_Uint64          = 2006,  
    Prop_IsOnDesktop_Bool                       = 2007,  
    Prop_DisplayMCType_Int32                    = 2008,  
    Prop_DisplayMCOffset_Float                  = 2009,  
    Prop_DisplayMCScale_Float                   = 2010,  
    Prop_EdidVendorID_Int32                     = 2011,  
    Prop_DisplayMCImageLeft_String              = 2012,  
    Prop_DisplayMCImageRight_String             = 2013,  
    Prop_DisplayGCBlackClamp_Float              = 2014,  
    Prop_EdidProductID_Int32                    = 2015,  
    Prop_CameraToHeadTransform_Matrix34         = 2016,  
    Prop_DisplayGCType_Int32                    = 2017,  
    Prop_DisplayGCOffset_Float                  = 2018,  
    Prop_DisplayGCScale_Float                   = 2019,  
    Prop_DisplayGCPrescale_Float                = 2020,  
    Prop_DisplayGCImage_String                  = 2021,  
    Prop_LensCenterLeftU_Float                  = 2022,  
    Prop_LensCenterLeftV_Float                  = 2023,  
    Prop_LensCenterRightU_Float                 = 2024,  
    Prop_LensCenterRightV_Float                 = 2025,  
    Prop_UserHeadToEyeDepthMeters_Float         = 2026,  
    Prop_CameraFirmwareVersion_Uint64           = 2027,  
    Prop_CameraFirmwareDescription_String       = 2028,  
    Prop_DisplayFPGAVersion_Uint64              = 2029,  
    Prop_DisplayBootloaderVersion_Uint64        = 2030,  
    Prop_DisplayHardwareVersion_Uint64          = 2031,  
    Prop_AudioFirmwareVersion_Uint64            = 2032,  
    Prop_CameraCompatibilityMode_Int32          = 2033,  
    Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,  
    Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,  
    Prop_DisplaySuppressed_Bool                 = 2036,  
    Prop_DisplayAllowNightMode_Bool             = 2037,  
    Prop_DisplayMCImageWidth_Int32              = 2038,  
    Prop_DisplayMCImageHeight_Int32             = 2039,  
    Prop_DisplayMCImageNumChannels_Int32        = 2040,  
    Prop_DisplayMCImageData_Binary              = 2041,  
    Prop_SecondsFromPhotonsToVblank_Float       = 2042,  
  
    // Properties that are unique to TrackedDeviceClass_Controller  
    Prop_AttachedDeviceId_String                = 3000,  
    Prop_SupportedButtons_Uint64                = 3001,  
    Prop_Axis0Type_Int32                        = 3002, // Return value is of type EVRControllerAxisType  
    Prop_Axis1Type_Int32                        = 3003, // Return value is of type EVRControllerAxisType  
    Prop_Axis2Type_Int32                        = 3004, // Return value is of type EVRControllerAxisType  
    Prop_Axis3Type_Int32                        = 3005, // Return value is of type EVRControllerAxisType  
    Prop_Axis4Type_Int32                        = 3006, // Return value is of type EVRControllerAxisType  
    Prop_ControllerRoleHint_Int32               = 3007, // Return value is of type ETrackedControllerRole  
  
    // Properties that are unique to TrackedDeviceClass_TrackingReference  
    Prop_FieldOfViewLeftDegrees_Float           = 4000,  
    Prop_FieldOfViewRightDegrees_Float          = 4001,  
    Prop_FieldOfViewTopDegrees_Float            = 4002,  
    Prop_FieldOfViewBottomDegrees_Float         = 4003,  
    Prop_TrackingRangeMinimumMeters_Float       = 4004,  
    Prop_TrackingRangeMaximumMeters_Float       = 4005,  
    Prop_ModeLabel_String                       = 4006,  
  
    // Properties that are used for user interface like icons names  
    Prop_IconPathName_String                        = 5000, // usually a directory named "icons"  
    Prop_NamedIconPathDeviceOff_String              = 5001, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceSearching_String        = 5002, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceSearchingAlert_String   = 5003, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceReady_String            = 5004, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceReadyAlert_String       = 5005, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceNotReady_String         = 5006, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceStandby_String          = 5007, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
    Prop_NamedIconPathDeviceAlertLow_String         = 5008, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others  
  
    // Properties that are used by helpers, but are opaque to applications  
    Prop_DisplayHiddenArea_Binary_Start             = 5100,  
    Prop_DisplayHiddenArea_Binary_End               = 5150,  
  
    // Properties that are unique to drivers  
    Prop_UserConfigPath_String                  = 6000,  
    Prop_InstallPath_String                     = 6001,  
    Prop_HasDisplayComponent_Bool               = 6002,  
    Prop_HasControllerComponent_Bool            = 6003,  
    Prop_HasCameraComponent_Bool                = 6004,  
    Prop_HasDriverDirectModeComponent_Bool      = 6005,  
    Prop_HasVirtualDisplayComponent_Bool        = 6006,  
  
    // Vendors are free to expose private debug data in this reserved region  
    Prop_VendorSpecific_Reserved_Start          = 10000,  
    Prop_VendorSpecific_Reserved_End            = 10999,  
}  

在vr::ITrackedDeviceServerDriver设备驱动中使用如下：

virtual EVRInitError Activate( vr::TrackedDeviceIndex_t unObjectId )  
{  
        m_unObjectId = unObjectId;  
        m_ulPropertyContainer = vr::VRProperties()->TrackedDeviceToPropertyContainer( m_unObjectId );  
  
  
        vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, Prop_ModelNumber_String, m_sModelNumber.c_str() );  
        vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, Prop_RenderModelName_String, m_sModelNumber.c_str() );  
        vr::VRProperties()->SetFloatProperty( m_ulPropertyContainer, Prop_UserIpdMeters_Float, m_flIPD );  
        vr::VRProperties()->SetFloatProperty( m_ulPropertyContainer, Prop_UserHeadToEyeDepthMeters_Float, 0.f );  
        vr::VRProperties()->SetFloatProperty( m_ulPropertyContainer, Prop_DisplayFrequency_Float, m_flDisplayFrequency );  
        vr::VRProperties()->SetFloatProperty( m_ulPropertyContainer, Prop_SecondsFromVsyncToPhotons_Float, m_flSecondsFromVsyncToPhotons );  
  
        // return a constant that's not 0 (invalid) or 1 (reserved for Oculus)  
        vr::VRProperties()->SetUint64Property( m_ulPropertyContainer, Prop_CurrentUniverseId_Uint64, 2 );  
  
        // avoid "not fullscreen" warnings from vrmonitor  
        vr::VRProperties()->SetBoolProperty( m_ulPropertyContainer, Prop_IsOnDesktop_Bool, false );  
  
        // Icons can be configured in code or automatically configured by an external file "drivername\resources\driver.vrresources".  
        // Icon properties NOT configured in code (post Activate) are then auto-configured by the optional presence of a driver's "drivername\resources\driver.vrresources".  
        // In this manner a driver can configure their icons in a flexible data driven fashion by using an external file.  
        //  
        // The structure of the driver.vrresources file allows a driver to specialize their icons based on their HW.  
        // Keys matching the value in "Prop_ModelNumber_String" are considered first, since the driver may have model specific icons.  
        // An absence of a matching "Prop_ModelNumber_String" then considers the ETrackedDeviceClass ("HMD", "Controller", "GenericTracker", "TrackingReference")  
        // since the driver may have specialized icons based on those device class names.  
        //  
        // An absence of either then falls back to the "system.vrresources" where generic device class icons are then supplied.  
        //  
        // Please refer to "bin\drivers\sample\resources\driver.vrresources" which contains this sample configuration.  
        //  
        // "Alias" is a reserved key and specifies chaining to another json block.  
        //  
        // In this sample configuration file (overly complex FOR EXAMPLE PURPOSES ONLY)....  
        //  
        // "Model-v2.0" chains through the alias to "Model-v1.0" which chains through the alias to "Model-v Defaults".  
        //  
        // Keys NOT found in "Model-v2.0" would then chase through the "Alias" to be resolved in "Model-v1.0" and either resolve their or continue through the alias.  
        // Thus "Prop_NamedIconPathDeviceAlertLow_String" in each model's block represent a specialization specific for that "model".  
        // Keys in "Model-v Defaults" are an example of mapping to the same states, and here all map to "Prop_NamedIconPathDeviceOff_String".  
        //  
        bool bSetupIconUsingExternalResourceFile = true;  
        if ( !bSetupIconUsingExternalResourceFile )  
        {  
            // Setup properties directly in code.  
            // Path values are of the form {drivername}\icons\some_icon_filename.png  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceOff_String, "{sample}/icons/headset_sample_status_off.png" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceSearching_String, "{sample}/icons/headset_sample_status_searching.gif" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceSearchingAlert_String, "{sample}/icons/headset_sample_status_searching_alert.gif" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceReady_String, "{sample}/icons/headset_sample_status_ready.png" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceReadyAlert_String, "{sample}/icons/headset_sample_status_ready_alert.png" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceNotReady_String, "{sample}/icons/headset_sample_status_error.png" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceStandby_String, "{sample}/icons/headset_sample_status_standby.png" );  
            vr::VRProperties()->SetStringProperty( m_ulPropertyContainer, vr::Prop_NamedIconPathDeviceAlertLow_String, "{sample}/icons/headset_sample_status_ready_low.png" );  
        }  
  
        return VRInitError_None;  
}  

2.自定义类：

DeviceHolder类:

1>.addAndActivateDevice():代码如下：

IdReturnValue  
       addAndActivateDevice(vr::ITrackedDeviceServerDriver *dev) {  
           /// check to make sure it's not null and not already in there  
           if (!dev) {  
               return IdReturnValue::makeError();  
           }  
           auto existing = findDevice(dev);//查找  
           if (existing) {  
               /// @todo do we return an error or the existing location? This  
               /// returns the existing location after re-activating.  
               dev->Activate(existing.value);  
               return existing;  
           }  
           auto newId = static_cast<std::uint32_t>(devices_.size());  
           devices_.push_back(dev);  
           dev->Activate(newId);  
           return IdReturnValue::makeValue(newId);  
       }  

@brief:查找容器devices_中是否存在dev设备驱动，若存在，则active它并返回它的id号；反之，则添加进devices_并返回id号。

2>.addAndActivateDeviceAt()：代码如下：

/// Add and activate a device at a reserved id.  
        IdReturnValue  
        addAndActivateDeviceAt(vr::ITrackedDeviceServerDriver *dev,  
                               std::uint32_t idx) {  
            /// check to make sure it's not null and not already in there  
            if (!dev) {  
                return IdReturnValue::makeError();  
            }  
            auto existing = findDevice(dev);  
            if (existing && existing.value != idx) {  
                // if we already found it in there and it's not at the desired  
                // index...  
                return IdReturnValue(existing.value, false);  
            }  
  
            if (existing) {  
                // well, in this case, we might need to just activate it again.  
                dev->Activate(idx);  
                return IdReturnValue::makeValue(idx);  
            }  
  
            if (!(idx < devices_.size())) {  
                // OK, we need to reserve more room.  
                reserveIds(idx + 1);  
            }  
  
            if (devices_[idx]) {  
                // there's already somebody else there...  
                return IdReturnValue::makeError();  
            }  
  
            /// Finally, if we made it through that, it's our turn.  
            devices_[idx] = dev;  
            dev->Activate(idx);  
  
            return IdReturnValue::makeValue(idx);  
        }  

@brief:激活指定idx的设备。

InterfaceVersionSupport类：

@brief:辅助类，用于管理接口版本号

1>.InterfaceVersionSupport() : supportedInterfaces_(populate()) {}

@brief:接收populate的返回值

2>.populate：

/// Function to create and populate the supported interface  
      /// container, so the object's data member may be const.  
      static Container populate() {  
          Container ret;  
          // Populate a vector with all the supported interfaces.  
          for_each_const_string_array(  
              vr::k_InterfaceVersions,  
              [&](const char *str) { ret.emplace_back(str); });  
  
          // so we can use binary_search  
          std::sort(ret.begin(), ret.end());  
          return ret;  
      }  

@brief:将openvr_driver.h中声明的vr::k_InterfaceVersions传入lambda函数，加入vector。之后按序列从小到大排列，
并返回赋给supportedInterfaces_

namespace vr  
{  
    static const char * const k_InterfaceVersions[] =  
    {  
        IVRSettings_Version,  
        ITrackedDeviceServerDriver_Version,  
        IVRDisplayComponent_Version,  
        IVRDriverDirectModeComponent_Version,  
        IVRControllerComponent_Version,  
        IVRCameraComponent_Version,  
        IServerTrackedDeviceProvider_Version,  
        IVRWatchdogProvider_Version,  
        IVRVirtualDisplay_Version,  
        IVRDriverManager_Version,  
        IVRResources_Version,  
        nullptr  
    };  
...  
  
}  

2>.inline bool isInterfaceNameWeCareAbout(std::string const &interfaceName)

@brief:用于检查传入的接口类是否为该驱动所care的接口类

/// A list of just the interface names we actually use.  
        static const auto interfaceNamesWeCareAbout = {  
            "ITrackedDeviceServerDriver", "IVRDisplayComponent",  
            "IVRControllerComponent", //< @todo do we actually use/cast to  
                                      // this interface?  
            "IServerTrackedDeviceProvider", "IVRWatchdogProvider"};  
  
    } // namespace detail  
  
    inline bool isInterfaceNameWeCareAbout(std::string const &interfaceName) {  
        return std::find(detail::interfaceNamesWeCareAbout.begin(),  
                         detail::interfaceNamesWeCareAbout.end(),  
                         interfaceName) !=  
               detail::interfaceNamesWeCareAbout.end();  
    } 

DriverLoader：
@brief:用来加载一个steamVR driver dll驱动，获取主入口点及其函数调用，这个类是驱动运行的必要条件。
1>. /// Factory function to make a driver loader.
        static std::unique_ptr<DriverLoader>
        make(std::string const &driverRoot, std::string const &driverFile);
@brief:工厂方法生成一个驱动加载对象。

loader_ = DriverLoader::make(locations_.driverRoot,  
                                         locations_.driverFile);  

驱动根目录（driverRoot）如:Steam\steamapps\common\SteamVR\drivers\lighthouse\bin\win64
驱动文件（driverFile）如:Steam\steamapps\common\SteamVR\drivers\lighthouse\bin\win64\driver_lighthouse.dll

2>.template <typename InterfaceType>
        ReturnValue<InterfaceType *, int> getInterface()
@brief:获取模板参数InterfaceType指定的接口类。最初由getProvider<vr::IServerTrackedDeviceProvider>调用。

3>.std::string const &getDriverRoot()

@brief:获取根目录，如：

Steam\steamapps\common\SteamVR\drivers\lighthouse\bin\win64

ChaperoneData：
@brief:一些已知的追踪器空间范围的数据。比如空间界限，游戏空间等。来自于chaperone_info，位于<Steam\config\chaperone_info.vrchap>

1>.struct UniverseData {
            CalibrationType type = CalibrationType::Standing;
            std::array<double, 3> translation;
            double yaw = 0.;
        };

@brief：空间数据。类型：站立。数据：位置信息以及偏航角。

2>.ChaperoneData::ChaperoneData(std::string const &steamConfigDir)
        : impl_(new Impl), configDir_(steamConfigDir)

@brief:从chaperone_info.vrchap文件中获取字段填充成员变量impl_，结构代码如下：

struct ChaperoneData::Impl {  
        Json::Value chaperoneInfo;  
        UniverseDataMap universes;  
        UniverseBaseSerials baseSerials;  
    };  

3>.UniverseData getDataForUniverse(UniverseId universe) const
@brief:获取外设数据。

ChaperoneData::UniverseData  
    ChaperoneData::getDataForUniverse(UniverseId universe) const {  
        auto it = impl_->universes.find(universe);  
        if (it == end(impl_->universes)) {  
            return UniverseData();  
        }  
        return it->second; // ChaperoneData::UniverseData类型  
    }  

@brief:通过universe号获取对应的键值
 
using UniverseDataMap =

        std::map<std::uint64_t, ChaperoneData::UniverseData>;


4>. UniverseId        guessUniverseIdFromBaseStations(BaseStationSerials const &bases);

using BaseStationSerials = std::vector<std::string>;  
  
ChaperoneData::UniverseId ChaperoneData::guessUniverseIdFromBaseStations(  
        BaseStationSerials const &bases) {  
        auto providedSize = bases.size();  
        UniverseId ret = 0;  
        using UniverseRank = std::pair<float, UniverseId>;  
        /// Compare function for heap.  
        auto compare = [](UniverseRank const &a, UniverseRank const &b) {  
            return a.first < b.first;  
        };  
  
        /// Will contain heap of potential universes and their value (a fraction  
        /// of their base stations and provided base stations that were included  
        /// in the base station list provided to the function)  
        std::vector<UniverseRank> potentialUniverses;  
        auto push = [&](float value, UniverseId id) {  
            potentialUniverses.emplace_back(value, id);  
            std::push_heap(begin(potentialUniverses), end(potentialUniverses),  
                           compare);  
        };  
  
        for (auto &univBaseSerial : impl_->baseSerials) {  
            auto const &baseSerials = univBaseSerial.second;  
            std::size_t hits = 0;  
            auto b = begin(baseSerials);  
            auto e = end(baseSerials);  
            /// Count the number of entries that we were given that are also in  
            /// this universe's list.  
            auto found = std::count_if(begin(bases), end(bases),  
                                       [&](std::string const &needle) {  
                                           return std::find(b, e, needle) != e;  
                                       });  
            if (found > 0) {  
                /// This is meant to combine the influence of "found" in both  
                /// providedSize and universe size, and the +1 in the  
                /// denominator is to avoid division by zero.  
                auto weight = 2.f * static_cast<float>(found) /  
                              (baseSerials.size() + providedSize + 1);  
#if 0  
                std::cout << "Guessing produced weight of " << weight << " for "  
                          << univBaseSerial.first << std::endl;  
#endif  
                push(weight, univBaseSerial.first);  
            }  
        }  
        if (!potentialUniverses.empty()) {  
            /// it's a heap, so the best one is always on top.  
            return potentialUniverses.front().second;  
        }  
        return ret;  
    }  

@brief:由基站预测id。

com_osvr_Vive.cpp为OSVR插件一般结构：

OSVR_ReturnCode update(){  
        if (m_startedInSuccess) {  
            return OSVR_RETURN_SUCCESS;  
        }  
  
        if (!m_shouldAttemptDetection) {  
            /// We said we shouldn't and wouldn't try again.  
            return OSVR_RETURN_FAILURE;  
        }  
  
        /// Hand the Vive object off to the OSVR driver.  
        auto startResult = finishViveStartup();// 进入  
        if (startResult) {  
            /// and it started up the rest of the way just fine!  
            /// We'll keep the driver around!  
            m_logger->info("Vive driver finished startup successfully!");  
            m_startedInSuccess = true;  
            return OSVR_RETURN_SUCCESS;  
        }  
  
        m_logger->error("Vive driver startup failed.");  
  
        if (m_shouldAttemptDetection) {  
            m_logger->info(" Unloading to perhaps try again later.");  
        }  
  
        return OSVR_RETURN_FAILURE;  
    }  

finishViveStartup()中调用ViveDriverHost中的start方法。

ViveDriverHost类 ：继承自vr::IVRServerDriverHost：

ViveDriverHost::StartResult  
    ViveDriverHost::start(OSVR_PluginRegContext ctx,  
                          osvr::vive::DriverWrapper &&inVive)  
{  
        if (!inVive) {  
            m_logger->error(  
                "Called ViveDriverHost::start() with an invalid vive object!");  
            return StartResult::TemporaryFailure;  
        }  
        /// Take ownership of the Vive.  
        m_vive.reset(new osvr::vive::DriverWrapper(std::move(inVive)));  
  
        /// define the lambda to handle the ServerDriverHost::TrackedDeviceAdded  
        auto handleNewDevice = [&](const char *serialNum,  
                                   ETrackedDeviceClass eDeviceClass,  
                                   ITrackedDeviceServerDriver *pDriver) {  
            auto dev = pDriver;  
            if (!dev) {  
                m_logger->info("null input device");  
                return false;  
            }  
            auto ret = activateDevice(dev, eDeviceClass);  
            if (!ret) {  
                m_logger->error("Device with serial number ")  
                    << serialNum << " couldn't be added to the devices vector.";  
                return false;  
            }  
            NewDeviceReport out{std::string{serialNum}, ret.value};  
            {  
                std::lock_guard<std::mutex> lock(m_mutex);  
                m_newDevices.submitNew(std::move(out), lock);  
            }  
            return true;  
        };  
  
        m_vive->driverHost().onTrackedDeviceAdded = handleNewDevice;  
  
        /// Finish setting up the Vive.  
        try {  
            if (!m_vive->startServerDeviceProvider()) {  
                m_logger->error("Could not start the server device provider in "  
                                "the Vive driver. Exiting.");  
                return StartResult::TemporaryFailure;  
            }  
        } catch (CouldNotGetInterface &e) {  
            m_logger->error("Caught exception trying to start Vive server "  
                            "device provider: ")  
                << e.what();  
            m_logger->error("SteamVR interface version may have changed, may "  
                            "need to be rebuilt against an updated header or "  
                            "use an older SteamVR version. Exiting.");  
            return StartResult::PermanentFailure;  
        }  
  
        /// Check for interface compatibility  
        if (DriverWrapper::InterfaceVersionStatus::InterfaceMismatch ==  
            m_vive->checkServerDeviceProviderInterfaces()) {  
            m_logger->error(  
                "SteamVR lighthouse driver requires unavailable/unsupported "  
                "SteamVR lighthouse driver requires unavailable/unsupported "  
                "interface versions - either too old or too new for this "  
                "build. Specifically, the following critical mismaches: ");  
            for (auto iface : m_vive->getUnsupportedRequestedInterfaces()) {  
                if (isInterfaceNameWeCareAbout(  
                        detail::getInterfaceName(iface))) {  
                    auto supported =  
                        m_vive->getSupportedInterfaceVersions()  
                            .findSupportedVersionOfInterface(iface);  
                    m_logger->error(" - SteamVR lighthouse: ")  
                        << iface << "\t\t OSVR-Vive: " << supported;  
                }  
            }  
            m_logger->error("Cannot continue.\n");  
            return StartResult::PermanentFailure;  
        }  
  
        /// Power the system up.  
        m_vive->serverDevProvider().LeaveStandby();  
  
        /// Reserve ID 0 for the HMD  
        m_vive->devices().reserveIds(1);  
  
        /// Finish setting this up as an OSVR device.  
        /// Create the initialization options  
        OSVR_DeviceInitOptions opts = osvrDeviceCreateInitOptions(ctx);  
  
        osvrDeviceTrackerConfigure(opts, &m_tracker);  
        osvrDeviceAnalogConfigure(opts, &m_analog, NUM_ANALOGS);  
        osvrDeviceButtonConfigure(opts, &m_button, NUM_BUTTONS);  
  
        /// Because the callbacks may not come from the same thread that  
        /// calls RunFrame, we need to be careful to not send directly from  
        /// those callbacks. We can't use an Async device token because the  
        /// waits are too long and they goof up the SteamVR Lighthouse driver.  
        m_dev.initSync(ctx, "Vive", opts);  
  
        /// Send JSON descriptor  
        m_dev.sendJsonDescriptor(com_osvr_Vive_json);  
  
        /// Register update callback  
        m_dev.registerUpdateCallback(this);  
  
        return StartResult::Success;  
    }  

1>.将参数DriverWrapper类对象inVive赋给成员变量m_vive
2>.将lambda函数指针handleNewDevice赋给onTrackedDeviceAdded（由m_vive控制的driverHost类）：
lambda函数截获串号（类似hydra_controller1或hydra_controller2之类的字符串形式），设备类别（类似HMD PUCK等）以及
设备驱动。通过参数传入将指定idx的外设添加到容器std::vector<vr::ITrackedDeviceServerDriver *> devices_中
，并激活它,激活后返回它的idx值赋值给ret.value。之后，将serialNum与ret.value构造一个NewDeviceReport类，将该类存入
队列deque_。
3>.将lambda函数赋给 m_vive->driverHost().onTrackedDeviceAdded。将在ServerDeviceProvider启动后，在Init中被调用。
4>.startServerDeviceProvider：
初始化vr::IVRSettings,vr::IVRDriverLog,vr::IVRProperties类对象，并使用它们构建一个vr::DriverContext类对象，再通过
VR_INIT_SERVER_DRIVER_CONTEXT(context_)本质上是给COpenVRDriverContext类的m_pVRSettings，m_pVRDriverLog，m_pVRProperties
赋值。以供后续如TrackedDeviceAdded使用。

#define VR_INIT_SERVER_DRIVER_CONTEXT( pContext ) \  
          { \  
          vr::EVRInitError eError = vr::InitServerDriverContext( pContext ); \  
          if( eError != vr::VRInitError_None ) \  
              return eError; \  
          }  

在将环境准备好之后，serverDeviceProvider_ =
                getProvider<vr::IServerTrackedDeviceProvider>(
                    std::move(loader_), context_);
 
传入模板参数vr::IServerTrackedDeviceProvider, 随后:

template <typename InterfaceType>  
    inline ProviderPtr<InterfaceType>  
    getProvider(std::unique_ptr<DriverLoader> &&loader,  
                vr::IVRDriverContext *context) {  
        static_assert(  
            InterfaceExpectedFromEntryPointTrait<InterfaceType>::value,  
            "Function only valid for those 'provider' interface types "  
            "expected to be provided by the driver entry point.");  
        return detail::getProviderImpl<InterfaceType>(  
            std::move(loader), context, [](SharedDriverLoader const &) {});  
    }  

传入一个lambda函数指针（不捕获时才可转换为函数指针）。

template <typename InterfaceType, typename F>  
        inline ProviderPtr<InterfaceType>  
        getProviderImpl(std::unique_ptr<DriverLoader> &&loader,  
                        vr::IVRDriverContext *context,  
                        F &&driverLoaderFunctor) {  
            using return_type = ProviderPtr<InterfaceType>;  
  
            if (!loader) {  
                return return_type{};  
            }  
            /// Move into local pointer, so if something goes wrong, the driver  
            /// gets unloaded.  
            std::unique_ptr<DriverLoader> myLoader(std::move(loader));  
            auto rawPtr = myLoader->getInterfaceThrowing<InterfaceType>();  
            auto initResults = rawPtr->Init(context);  
            if (vr::VRInitError_None != initResults) {  
                /// Failed, reset the loader pointer to unload the driver.  
                std::cout << "Got error code " << initResults << std::endl;  
                myLoader.reset();  
                return return_type{};  
            }  
  
            /// OK, so this is the interface. Move the loader into a shared  
            /// pointer, make the loader responsible for cleanup of the  
            /// interface, and get the shared pointer of the interface pointer  
            /// returned.  
            SharedDriverLoader sharedLoader(std::move(myLoader));  
            sharedLoader->cleanupInterfaceOnDestruction(rawPtr);  
  
            /// Call the hook  
            (std::forward<F>(driverLoaderFunctor))(sharedLoader);  
  
            /// Create the return value: another shared pointer.  
            /// This is the so-called "aliasing" constructor - this pointer will  
            /// actually keep the DriverLoader alive and do nothing with the  
            /// lifetime of rawPtr (which is why the loader is responsible for  
            /// calling Cleanup, see above)  
            return_type ret(sharedLoader, rawPtr);  
  
            return ret;  
        }  

(std::forward<F>(driverLoaderFunctor))(sharedLoader)：钩子获取dll中的接口，与driver_lighthouse.dll衔接。

其中sharedLoader最初由loader_ = DriverLoader::make(locations_.driverRoot, locations_.driverFile);构建而成。

std::unique_ptr<DriverLoader>  
    DriverLoader::make(std::string const &driverRoot,  
                       std::string const &driverFile) {  
        std::unique_ptr<DriverLoader> ret(  
            new DriverLoader(driverRoot, driverFile));  
        return ret;  
    }  

返回一个DriverLoader对象。

DriverLoader::DriverLoader(std::string const &driverRoot,  
                             std::string const &driverFile)  
      : impl_(new Impl),  
        logger_(osvr::util::log::make_logger("DriverLoader")) {  
      /// Set the PATH to include the driver directory so it can  
      /// find its deps.  
      SearchPathExtender extender(driverRoot);  
f defined(OSVR_WINDOWS)  
      impl_->driver_ = LoadLibraryA(driverFile.c_str());<strong><span style="font-size:14px;">// 加载steam目录下的driver_lighthouse.dll文件</span></strong>  
      if (!impl_->driver_) {  
          reset();  
          throw CouldNotLoadDriverModule();  
      }  
  
      auto proc = GetProcAddress(impl_->driver_, ENTRY_POINT_FUNCTION_NAME);<strong><span style="font-size:14px;">// 获取dll文件中的HmdDriverFactory接口地址</span></strong>  
      if (!proc) {  
          reset();  
          throw CouldNotLoadEntryPoint();  
      }  
      factory_ = reinterpret_cast<DriverFactory>(proc);<strong><span style="font-size:14px;">// 强制转换为void *(*)(const char *, int *)类型</span></strong>  
lif defined(OSVR_LINUX) || defined(OSVR_MACOSX)  
      impl_->driver_ = dlopen(driverFile.c_str(), RTLD_NOW | RTLD_GLOBAL);  
      if (!impl_->driver_) {  
          reset();  
          throw CouldNotLoadDriverModule(dlerror());  
      }  
  
      auto proc = dlsym(impl_->driver_, ENTRY_POINT_FUNCTION_NAME);  
      if (!proc) {  
          reset();  
          throw CouldNotLoadEntryPoint(dlerror());  
      }  
      factory_ = reinterpret_cast<DriverFactory>(proc);  
ndif  
  } 

static const auto ENTRY_POINT_FUNCTION_NAME = "HmdDriverFactory";

using DriverFactory = void *(*)(const char *, int *);
目的是存储一个地址到变量：factory_
在driver_lighthouse.dll中的vr::IServerTrackedDeviceProvider已提供接口如下：
CServerDriver g_ServerTrackedDeviceProvider;

HMD_DLL_EXPORT  
void *HmdDriverFactory(const char *pInterfaceName, int *pReturnCode)  
{  
    if (0 == strcmp(IServerTrackedDeviceProvider_Version, pInterfaceName)) {  
        return &g_ServerTrackedDeviceProvider;  
    }  
  
    if (pReturnCode) {  
        *pReturnCode = VRInitError_Init_InterfaceNotFound;  
    }  
  
    return NULL;  
}  

回到ViveDriverHost::start中，checkServerDeviceProviderInterfaces检测驱动需要的接口openvr_driver.h是否支持。

enum class InterfaceVersionStatus {  
           /// All mentioned interface version strings are handled/described by  
           /// the header we've built against.  
           AllInterfacesOK,// 驱动请求使用的所有接口类 openvr_driver.h中都支持  
           /// Not all mentioned interface version strings are  
           /// handled/described by the header we've built against, but the  
           /// interfaces that we use match.  
           AllUsedInterfacesOK, // 不是所有请求的接口类openvr_driver.h中都支持，但是所使用到的类都支持。  
           /// At least one of the interfaces that we use doesn't match the  
           /// version we built against.  
           InterfaceMismatch //至少一个所使用到的接口类在openvr_driver.h中不支持  
       };  
  
       static const char * const k_InterfaceVersions[] =  
   {  
       IVRSettings_Version,  
       ITrackedDeviceServerDriver_Version,  
       IVRDisplayComponent_Version,  
       IVRDriverDirectModeComponent_Version,  
       IVRControllerComponent_Version,  
       IVRCameraComponent_Version,  
       IServerTrackedDeviceProvider_Version,  
       IVRWatchdogProvider_Version,  
       IVRVirtualDisplay_Version,  
       nullptr  
   };  

serverDevProvider().GetInterfaceVersions()返回的是以上openvr_driver.h中的接口类名，并比较是否所有接口类版本都支持。
若一个版本不支持，则将其入队，并将其与本驱动care的版本进行对比，若是必须要使用的但是又不被openvr_driver.h所支持。
则allUsedSupported=false.

/// A list of just the interface names we actually use.  
        static const auto interfaceNamesWeCareAbout = {  
            "ITrackedDeviceServerDriver", "IVRDisplayComponent",  
            "IVRControllerComponent", //< @todo do we actually use/cast to  
                                      // this interface?  
            "IServerTrackedDeviceProvider", "IVRWatchdogProvider"};  

关于数据传输部分：
在driver_lighthouse.dll中通过RunFrame（）中的vr::VRServerDriverHost()->TrackedDevicePoseUpdated(m_unObjectId, GetPose(), sizeof(DriverPose_t));
往vive中的以下接口发：

void ViveDriverHost::TrackedDevicePoseUpdated(uint32_t unWhichDevice,  
                                                  const DriverPose_t &newPose,  
                                                  uint32_t unPoseStructSize) {  
        submitTrackingReport(unWhichDevice, osvr::util::time::getNow(),  
                             newPose);  
    }  
  
void ViveDriverHost::submitTrackingReport(uint32_t unWhichDevice,  
                                              OSVR_TimeValue const &tv,  
                                              const DriverPose_t &newPose) {  
        TrackingReport out;  
        out.timestamp = tv;  
        out.sensor = unWhichDevice;  
        out.report = newPose;  
        {  
            std::lock_guard<std::mutex> lock(m_mutex);  
            m_trackingReports.submitNew(std::move(out), lock);  
        }  
    }  

因此，整个数据过程为：
通过DriverLoader.cpp加载dll后，再通过m_vive->startServerDeviceProvider()获取dll实现的
vr::IServerTrackedDeviceProvider接口， update中通过调用m_vive->serverDevProvider().RunFrame()结构，通过submitNew往deque_中push，vive osvr端通过grabItems到vector_。最后在update中再通过accessWorkItems获取

vector_。最终通过convertAndSendTracker中的osvrDeviceTrackerSendPoseTimestamped往应用程序传数据。其中chaperone
配置文件中的数据在handleUniverseChange中被处理。

2017-6-27------------------------------------------------------------------------

无论是在直连或者扩展模式上，HTC Vive和它的控制器被OSVR所支持且可以在任何OSVR应用程序上使用，还支持畸变校正，全方位追踪以及输入支持。

通过OSVR，OSVR-Vive插件及其工具访问Vive硬件。

兼容性：

然后改驱动应该兼容所有的Vive家族设备，到目前为止，它只在HTC Vive和Vive PRE（非早期开发版本）上测试过。

OSVR-Vive驱动与为Vive服务的SteamVR驱动交互（driver_lighthouse），因此与SteamVR版本也有关联。

安装流程：

首先确保Vive在SteamVR上工作正常且已经安排了一个房间，最好是进行一个站立状态或房间级别的校准作为游戏空间。然后，下载

与OSVR服务相对应位数的插件二进制包。

在下载的解压包内有以下文件：

1>.一个插件文件。在Windows上，这是一个在bin/osvr-plugins-0目录下的.dll文件。将它放在OSVR server相同目录下。

2>.在bin目录内，一个ViveDisplayExtractor工具---拷贝到OSVR server的bin目录下。

3>.一个起始样例配置文件osvr_server_config（还有一些可以快速替换的预设显示描述符以及网格文件）

首先应该在不需要改变任何SteamVR设置的基础上，能够以直连模式在Vive头显上运行一个OSVR的应用程序。如果Vive在SteamVR上以

直联模式工作正常，但是在OSVR上不能以直连模式打开，则原因可能是在OSVR应用程序启动之前SteamVR没有退出（需要确保在

OSVR应用程序启动之前SteamVR已经退出）。在一些系统上，退出SteamVR之前，在SteamVR菜单内可能需要禁止直连模式。

一次安装：Vive需要一个客户显示描述以及网格畸变数据文件，使用ViveDisplayExtractor工具提取这些文件数据。确保ViveDisplayExtractor与

osvr_server一起运行，也就是Vive与PC连接，SteamVR已经退出，运行ViveDisplayExtractor。

如果成功，将会看到类似以下：

[DisplayExtractor] Writing distortion mesh data file:
C:/Users/Ryan/Desktop/OSVR/bin/displays/HTC_Vive_PRE_meshdata.json

[DisplayExtractor] Writing display descriptor file:
C:/Users/Ryan/Desktop/OSVR/bin/displays/HTC_Vive_PRE.json

[DisplayExtractor] Press enter to quit...

Note：结果配置包含一个到网格数据的绝对路径，因此如果改变了osvr server所在目录，只需要再次运行ViveDisplayExtractor。

以上就是所有的了！现在可以使用样例osvr_server_config.vive.sample.json  文件作为服务配置文件了（将它改为默认名： osvr_server_config.json

），可以在Vive上运行OSVR启动的应用程序了。

如果想要运行SteamVR APP，没问题：只要关闭OSVR Server并且任何在直连模式运行的OSVR Apps即可。