0.4 Win-Beta0.4.0

1 files changed, 0 insertions, 1135 deletions

diff --git a/LibOVR/Src/OVR_Device.h b/LibOVR/Src/OVR_Device.h
deleted file mode 100644
index 52a41f9..0000000
--- a/LibOVR/Src/OVR_Device.h
+++ /dev/null
@@ -1,1135 +0,0 @@
-/************************************************************************************
-
-PublicHeader:   OVR.h
-Filename    :   OVR_Device.h
-Content     :   Definition of HMD-related Device interfaces
-Created     :   September 21, 2012
-Authors     :   Michael Antonov
-
-Copyright   :   Copyright 2014 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); 
-you may not use the Oculus VR Rift SDK except in compliance with the License, 
-which is provided at the time of installation or download, or which 
-otherwise accompanies this software in either electronic or hard copy form.
-
-You may obtain a copy of the License at
-
-http://www.oculusvr.com/licenses/LICENSE-3.1 
-
-Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-*************************************************************************************/
-
-#ifndef OVR_Device_h
-#define OVR_Device_h
-
-#include "OVR_DeviceConstants.h"
-#include "OVR_DeviceHandle.h"
-#include "OVR_DeviceMessages.h"
-#include "OVR_HIDDeviceBase.h"
-
-#include "Kernel/OVR_Atomic.h"
-#include "Kernel/OVR_RefCount.h"
-#include "Kernel/OVR_String.h"
-
-
-namespace OVR {
-
-// Declared externally
-class Profile;
-class ProfileManager; // << Should be renamed for consistency
-
-// Forward declarations
-class SensorDevice;
-class DeviceCommon;
-class DeviceManager;
-
-// MessageHandler is a base class from which users derive to receive messages,
-// its OnMessage handler will be called for messages once it is installed on
-// a device. Same message handler can be installed on multiple devices.
-class MessageHandler
-{
-    friend class MessageHandlerImpl;
-public:
-    MessageHandler();
-    virtual ~MessageHandler();
-
-    // Returns 'true' if handler is currently installed on any devices.
-    bool        IsHandlerInstalled() const;
-
-    // Should be called from derived class destructor to avoid handler
-    // being called after it exits.
-    void        RemoveHandlerFromDevices();
-
-    // Returns a pointer to the internal lock object that is locked by a
-    // background thread while OnMessage() is called.
-    // This lock guaranteed to survive until ~MessageHandler.
-    Lock*       GetHandlerLock() const;
-
-
-    virtual void OnMessage(const Message&) { }
-
-    // Determines if handler supports a specific message type. Can
-    // be used to filter out entire message groups. The result
-    // returned by this function shouldn't change after handler creation.
-    virtual bool SupportsMessageType(MessageType) const { return true; }    
-
-private:    
-    UPInt Internal[8];
-};
-
-
-//-------------------------------------------------------------------------------------
-// ***** DeviceBase
-
-// DeviceBase is the base class for all OVR Devices. It provides the following basic
-// functionality:
-//   - Reports device type, manager, and associated parent (if any).
-//   - Supports installable message handlers, which are notified of device events.
-//   - Device objects are created through DeviceHandle::CreateDevice or more commonly
-//     through DeviceEnumerator<>::CreateDevice.
-//   - Created devices are reference counted, starting with RefCount of 1.
-//   - Device is resources are cleaned up when it is Released, although its handles
-//     may survive longer if referenced.
-
-class DeviceBase : public NewOverrideBase
-{    
-    friend class DeviceHandle;  
-    friend class DeviceManagerImpl;
-public:
-
-    // Enumerating DeviceBase enumerates all devices.
-    enum { EnumDeviceType = Device_All };
-
-    virtual ~DeviceBase() { }
-    virtual void            AddRef();
-    virtual void            Release();
-    
-    virtual DeviceBase*     GetParent() const;
-    virtual DeviceManager*  GetManager() const;  
-
-    virtual void            AddMessageHandler(MessageHandler* handler);
-
-    virtual DeviceType      GetType() const;
-    virtual bool            GetDeviceInfo(DeviceInfo* info) const;
-
-    // Returns true if device is connected and usable
-    virtual bool            IsConnected();
-
-    // returns the MessageHandler's lock
-    Lock*                   GetHandlerLock() const;
-protected:
-    // Internal
-    virtual DeviceCommon*   getDeviceCommon() const = 0;
-};
-
-
-//-------------------------------------------------------------------------------------
-// ***** DeviceInfo
-
-// DeviceInfo describes a device and its capabilities, obtained by calling
-// GetDeviceInfo. This base class only contains device-independent functionality;
-// users will normally use a derived HMDInfo or SensorInfo classes for more
-// extensive device info.
-
-class DeviceInfo
-{
-public:
-    DeviceInfo() : InfoClassType(Device_None), Type(Device_None), Version(0)
-    {}
-    
-    // Type of device for which DeviceInfo is intended.
-    // This will be set to Device_HMD for HMDInfo structure, note that this may be
-    // different form the actual device type since (Device_None) is valid.
-    const DeviceType    InfoClassType;
-    // Type of device this describes. This must be the same as InfoClassType when
-    // InfoClassType != Device_None.
-    DeviceType          Type;
-    // Name string describing the product: "Oculus Rift DK1", etc.
-    String              ProductName;    
-    String              Manufacturer;
-    unsigned            Version;
-    
-protected:
-    DeviceInfo(DeviceType type) : InfoClassType(type), Type(type), Version(0)
-    {}
-    void operator = (const DeviceInfo&) { OVR_ASSERT(0); } // Assignment not allowed.
-};
-
-
-//-------------------------------------------------------------------------------------
-// DeviceEnumerationArgs provides device enumeration argumenrs for DeviceManager::EnumerateDevicesEx.
-class DeviceEnumerationArgs
-{
-public:
-    DeviceEnumerationArgs(DeviceType enumType, bool availableOnly)
-        : EnumType(enumType), AvailableOnly(availableOnly)
-    { }
-
-    // Helper; returns true if args match our enumeration criteria.
-    bool         MatchRule(DeviceType type, bool available) const
-    {
-        return ((EnumType == type) || (EnumType == Device_All)) &&
-                (available || !AvailableOnly);
-    }
-
-protected:    
-    DeviceType   EnumType;
-    bool         AvailableOnly;
-};
-
-
-// DeviceEnumerator<> is used to enumerate and create devices of specified class,
-// it is returned by calling MeviceManager::EnumerateDevices. Initially, the enumerator will
-// refer to the first device of specified type. Additional devices can be accessed by
-// calling Next().
-
-template<class T = DeviceBase>
-class DeviceEnumerator : public DeviceHandle
-{
-    friend class DeviceManager;
-    friend class DeviceManagerImpl;
-public:
-    DeviceEnumerator()
-        : DeviceHandle(), EnumArgs(Device_None, true) { }
-
-    // Next advances enumeration to the next device that first criteria.
-    // Returns false if no more devices exist that match enumeration criteria.
-    bool    Next()          { return enumerateNext(EnumArgs); }
-
-    // Creates an instance of the device referenced by enumerator; returns null
-    // if enumerator does not refer to a valid device or device is unavailable.
-    // If device was already created, the same object with incremented ref-count is returned.
-    T*      CreateDevice()  { return static_cast<T*>(DeviceHandle::CreateDevice()); }
-
-protected:
-    DeviceEnumerator(const DeviceHandle &dev, const DeviceEnumerationArgs& args)
-        : DeviceHandle(dev), EnumArgs(args)
-    { }
-
-    DeviceEnumerationArgs EnumArgs;
-};
-
-//-------------------------------------------------------------------------------------
-// ***** DeviceManager
-
-// DeviceManager maintains and provides access to devices supported by OVR, such as
-// HMDs and sensors. A single instance of DeviceManager is normally created at
-// program startup, allowing devices to be enumerated and created. DeviceManager is
-// reference counted and is AddRefed by its created child devices, causing it to
-// always be the last object that is released.
-//
-// Install MessageHandler on DeviceManager to detect when devices are inserted or removed.
-//
-// The following code will create the manager and its first available HMDDevice,
-// and then release it when not needed:
-//
-//  DeviceManager* manager = DeviceManager::Create();
-//  HMDDevice*     hmd = manager->EnumerateDevices<HMDDevice>().CreateDevice();
-//
-//  if (hmd) hmd->Release();
-//  if (manager) manager->Release();
-
-
-class DeviceManager : public DeviceBase
-{
-public:
-  
-    DeviceManager()
-    { }
-
-    // DeviceBase implementation.
-    virtual DeviceType      GetType() const     { return Device_Manager; }
-    virtual DeviceManager*  GetManager() const  { return const_cast<DeviceManager*>(this); }
-
-    // Every DeviceManager has an associated profile manager, which us used to store
-    // user settings that may affect device behavior. 
-    virtual ProfileManager* GetProfileManager() const = 0;
-
-
-    // EnumerateDevices enumerates all of the available devices of the specified class,
-    // returning an enumerator that references the first device. An empty enumerator is
-    // returned if no devices are available. The following APIs are exposed through
-    // DeviceEnumerator:
-    //   DeviceEnumerator::GetType()        - Check device type. Returns Device_None 
-    //                                        if no device was found/pointed to.
-    //   DeviceEnumerator::GetDeviceInfo()  - Get more information on device.
-    //   DeviceEnumerator::CreateDevice()   - Create an instance of device.
-    //   DeviceEnumerator::Next()           - Move onto next device.
-    template<class D>
-    DeviceEnumerator<D>     EnumerateDevices(bool availableOnly = true)
-    {
-        // TBD: A cleaner (but less efficient) alternative is though enumeratorFromHandle.
-        DeviceEnumerator<> e = EnumerateDevicesEx(DeviceEnumerationArgs((DeviceType)D::EnumDeviceType, availableOnly));
-        return *reinterpret_cast<DeviceEnumerator<D>*>(&e);
-    }
-  
-    // EnumerateDevicesEx provides internal implementation for device enumeration, enumerating
-    // devices based on dynamically specified DeviceType in DeviceEnumerationArgs.
-    // End users should call DeumerateDevices<>() instead.
-    virtual DeviceEnumerator<> EnumerateDevicesEx(const DeviceEnumerationArgs& args) = 0;
-
-    // Creates a new DeviceManager. Only one instance of DeviceManager should be created at a time.
-    static   DeviceManager* Create();
-
-    // Static constant for this device type, used in template cast type checks.
-    enum { EnumDeviceType = Device_Manager };
-
-
-
-    // Adds a device (DeviceCreateDesc*) into Devices. Returns NULL, 
-    // if unsuccessful or device is already in the list.
-    virtual Ptr<DeviceCreateDesc> AddDevice_NeedsLock(const DeviceCreateDesc& createDesc) = 0;
-
-protected:
-    DeviceEnumerator<> enumeratorFromHandle(const DeviceHandle& h, const DeviceEnumerationArgs& args)
-    { return DeviceEnumerator<>(h, args); }
-
-    DeviceManager* getThis() { return this; }
-};
-
-
-
-//-------------------------------------------------------------------------------------
-// ***** HMDInfo 
-
-// This structure describes various aspects of the HMD allowing us to configure rendering.
-//
-//  Currently included data:
-//   - Physical screen dimensions, resolution, and eye distances.
-//     (some of these will be configurable with a tool in the future).
-//     These arguments allow us to properly setup projection across HMDs.
-//   - DisplayDeviceName for identifying HMD screen; system-specific interpretation.
-//
-// TBD:
-//  - Power on/ off?
-//  - Sensor rates and capabilities
-//  - Distortion radius/variables    
-//  - Screen update frequency
-//  - Distortion needed flag
-//  - Update modes:
-//      Set update mode: Stereo (both sides together), mono (same in both eyes),
-//                       Alternating, Alternating scan-lines.
-
-class HMDInfo : public DeviceInfo
-{
-public:
-    // Characteristics of the HMD screen and enclosure
-    HmdTypeEnum HmdType;
-    Size<int>   ResolutionInPixels;
-    Size<float> ScreenSizeInMeters;
-    float       ScreenGapSizeInMeters;
-    float       CenterFromTopInMeters;
-    float       LensSeparationInMeters;
-
-    // Timing & shutter data. All values in seconds.
-    struct ShutterInfo
-    {
-        HmdShutterTypeEnum  Type;
-        float               VsyncToNextVsync;                // 1/framerate
-        float               VsyncToFirstScanline;            // for global shutter, vsync->shutter open.
-        float               FirstScanlineToLastScanline;     // for global shutter, will be zero.
-        float               PixelSettleTime;                 // estimated.
-        float               PixelPersistence;                // Full persistence = 1/framerate.
-    }                   Shutter;
-
-    // Desktop coordinate position of the screen (can be negative; may not be present on all platforms)
-    int                 DesktopX;
-    int                 DesktopY;
-    
-    // Windows:
-    // "\\\\.\\DISPLAY3", etc. Can be used in EnumDisplaySettings/CreateDC.
-    char      DisplayDeviceName[32];
-    
-    // MacOS:
-    int      DisplayId;
-
-
-    // Constructor initializes all values to 0s.
-    // To create a "virtualized" HMDInfo, use CreateDebugHMDInfo instead.
-    HMDInfo()
-        : DeviceInfo(Device_HMD),
-          HmdType(HmdType_None),
-          ResolutionInPixels(0),
-          ScreenSizeInMeters(0.0f),
-          ScreenGapSizeInMeters(0.0f),
-          CenterFromTopInMeters(0),
-          LensSeparationInMeters(0),
-          DisplayId(0)
-    {
-        DesktopX = 0;
-        DesktopY = 0;
-        DisplayDeviceName[0] = 0;
-        Shutter.Type = HmdShutter_LAST;
-        Shutter.VsyncToNextVsync = 0.0f;
-        Shutter.VsyncToFirstScanline = 0.0f;
-        Shutter.FirstScanlineToLastScanline = 0.0f;
-        Shutter.PixelSettleTime = 0.0f;
-        Shutter.PixelPersistence = 0.0f;
-    }
-
-    // Operator = copies local fields only (base class must be correct already)
-    void operator = (const HMDInfo& src)
-    {        
-        HmdType                          = src.HmdType;
-        ResolutionInPixels               = src.ResolutionInPixels;      
-        ScreenSizeInMeters               = src.ScreenSizeInMeters;
-        ScreenGapSizeInMeters            = src.ScreenGapSizeInMeters;
-        CenterFromTopInMeters            = src.CenterFromTopInMeters;
-        LensSeparationInMeters           = src.LensSeparationInMeters;
-        DesktopX                         = src.DesktopX;
-        DesktopY                         = src.DesktopY;
-        Shutter                          = src.Shutter;
-        memcpy(DisplayDeviceName, src.DisplayDeviceName, sizeof(DisplayDeviceName));
-
-        DisplayId                        = src.DisplayId;
-    }
-
-    bool IsSameDisplay(const HMDInfo& o) const
-    {
-        return DisplayId == o.DisplayId &&
-               String::CompareNoCase(DisplayDeviceName, 
-                                     o.DisplayDeviceName) == 0;
-    }
-
-};
-
-
-// HMDDevice represents an Oculus HMD device unit. An instance of this class
-// is typically created from the DeviceManager.
-//  After HMD device is created, we its sensor data can be obtained by 
-//  first creating a Sensor object and then.
-
-//  TBD:
-//  - Configure Sensor
-//  - APIs to set On-Screen message, other states?
-
-class HMDDevice : public DeviceBase
-{
-public:
-    HMDDevice()
-    { }
-
-    // Static constant for this device type, used in template cast type checks.
-    enum { EnumDeviceType = Device_HMD };
-
-    virtual DeviceType      GetType() const   { return Device_HMD; }  
-
-    // Creates a sensor associated with this HMD.
-    virtual SensorDevice*   GetSensor() = 0;
-
-
-    // Requests the currently used profile. This profile affects the
-    // settings reported by HMDInfo. 
-    virtual Profile*    GetProfile() = 0;
-    // Obtains the currently used profile name. This is initialized to the default
-    // profile name, if any; it can then be changed per-device by SetProfileName.    
-    virtual const char* GetProfileName() = 0;
-    // Sets the profile user name, changing the data returned by GetProfileInfo.
-    virtual bool        SetProfileName(const char* name) = 0;
-
-
-    // Disconnects from real HMD device. This HMDDevice remains as 'fake' HMD.
-    // SensorDevice ptr is used to restore the 'fake' HMD (can be NULL).
-    HMDDevice*  Disconnect(SensorDevice*);
-    
-    // Returns 'true' if HMD device is a 'fake' HMD (was created this way or 
-    // 'Disconnect' method was called).
-    bool        IsDisconnected() const;
-};
-
-
-//-------------------------------------------------------------------------------------
-// ***** SensorRange & SensorInfo
-
-// SensorRange specifies maximum value ranges that SensorDevice hardware is configured
-// to detect. Although this range doesn't affect the scale of MessageBodyFrame values,
-// physical motions whose positive or negative magnitude is outside the specified range
-// may get clamped or misreported. Setting lower values may result in higher precision
-// tracking.
-struct SensorRange
-{
-    SensorRange(float maxAcceleration = 0.0f, float maxRotationRate = 0.0f,
-                float maxMagneticField = 0.0f)
-        : MaxAcceleration(maxAcceleration), MaxRotationRate(maxRotationRate),
-          MaxMagneticField(maxMagneticField)
-    { }
-
-    // Maximum detected acceleration in m/s^2. Up to 8*G equivalent support guaranteed,
-    // where G is ~9.81 m/s^2.
-    // Oculus DK1 HW has thresholds near: 2, 4 (default), 8, 16 G.
-    float   MaxAcceleration;  
-    // Maximum detected angular velocity in rad/s. Up to 8*Pi support guaranteed.
-    // Oculus DK1 HW thresholds near: 1, 2, 4, 8 Pi (default).
-    float   MaxRotationRate;
-    // Maximum detectable Magnetic field strength in Gauss. Up to 2.5 Gauss support guaranteed.
-    // Oculus DK1 HW thresholds near: 0.88, 1.3, 1.9, 2.5 gauss.
-    float   MaxMagneticField;
-};
-
-// SensorInfo describes capabilities of the sensor device.
-class SensorInfo : public DeviceInfo
-{
-public:
-    SensorInfo() : DeviceInfo(Device_Sensor), VendorId(0), ProductId(0)
-    {
-    }
-
-    // HID Vendor and ProductId of the device.
-    UInt16      VendorId;
-    UInt16      ProductId;
-    // MaxRanges report maximum sensor range values supported by HW.
-    SensorRange MaxRanges;
-    // Sensor (and display) serial number.
-    String      SerialNumber;
-
-private:
-    void operator = (const SensorInfo&) { OVR_ASSERT(0); } // Assignment not allowed.
-};
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Serial Number feature report. (DK1)
-struct SerialReport
-{
-    static const int SERIAL_NUMBER_SIZE = 12;  // Serial Number size = 12 bytes. (Refer 'Tracker Firmware Specification Section 4.9, Pg 18)
-
-	SerialReport()
-        : CommandId(0)
-	{
-        memset(SerialNumberValue, 0, sizeof(SerialNumberValue));
-    }
-                
-    SerialReport(UInt16 commandId,
-                UByte SNo[SERIAL_NUMBER_SIZE])
-        :	    CommandId(commandId)
-    { 
-        for (int i=0; i < SERIAL_NUMBER_SIZE; i++)
-        {
-            SerialNumberValue[i] = SNo[i];
-        }
-    }
-
-    UInt16      CommandId;
-	UByte	    SerialNumberValue[SERIAL_NUMBER_SIZE];          // See 'Tracker Firmware Specification' document for
-													  // a description of Serial Report.
-};
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//Added Serial Report Implementation.
-
-struct SerialImpl
-{
-    enum  { PacketSize = 15 };
-    UByte   Buffer[PacketSize];
-
-    SerialReport Settings;
-
-	SerialImpl()
-	{
-	memset(Buffer, 0, sizeof(Buffer));
-	Buffer[0] = 10;
-	}
-
-	SerialImpl(const SerialReport& settings)
-			:Settings(settings)
-	{
-		Pack();
-	}
-
-	void  Pack()
-	{
-    Buffer[0] = 10;
-    Alg::EncodeUInt16(Buffer+1, Settings.CommandId);
-	for (int i = 0; i < Settings.SERIAL_NUMBER_SIZE; ++i)
-		Buffer[3 + i] = Settings.SerialNumberValue[i];
-	}
-
-	void Unpack()
-	{
-		Settings.CommandId = Alg::DecodeUInt16(Buffer+1);
-		for (int i = 0; i < Settings.SERIAL_NUMBER_SIZE; ++i)
-			Settings.SerialNumberValue[i] = Buffer[3 + i];
-	}
-
-};
-
-
-// Tracking settings (DK2).
-struct TrackingReport
-{
-	TrackingReport()
-      : CommandId(0), Pattern(0), 
-        Enable(0), Autoincrement(0), UseCarrier(0), 
-        SyncInput(0), VsyncLock(0), CustomPattern(0),
-        ExposureLength(0), FrameInterval(0), 
-        VsyncOffset(0), DutyCycle(0)
-	{}
-
-    TrackingReport( UInt16 commandId, 
-                    UByte pattern,
-                    bool enable, 
-					bool autoincrement, 
-					bool useCarrier, 
-                    bool syncInput, 
-					bool vsyncLock, 
-					bool customPattern, 
-                    UInt16 exposureLength, 
-                    UInt16 frameInterval, 
-                    UInt16 vsyncOffset, 
-                    UByte dutyCycle)
-        :	    CommandId(commandId), Pattern(pattern), 
-                Enable(enable), Autoincrement(autoincrement), UseCarrier(useCarrier), 
-                SyncInput(syncInput), VsyncLock(vsyncLock), CustomPattern(customPattern),
-			    ExposureLength(exposureLength), FrameInterval(frameInterval), 
-			    VsyncOffset(vsyncOffset), DutyCycle(dutyCycle)
-    { }
-
-    UInt16  CommandId;
-	UByte	Pattern;            // Tracking LED pattern index.
-    bool    Enable;             // Enables the tracking LED exposure and updating.
-    bool    Autoincrement;      // Autoincrement pattern after each exposure.
-    bool    UseCarrier;         // Modulate tracking LEDs at 85kHz.
-    bool    SyncInput;          // Trigger LED exposure from wired sync signal.
-    bool    VsyncLock;          // Trigger LED exposure from panel Vsync.
-    bool    CustomPattern;      // Use custom LED sequence.
-    UInt16	ExposureLength;     // Tracking LED illumination (and exposure) length in microseconds.
-	UInt16	FrameInterval;      // LED exposure interval in microseconds when in 
-                                // 'internal timer' mode (when SyncInput = VsyncLock = false).
-    UInt16	VsyncOffset;        // Exposure offset in microseconds from vsync when in 
-                                // 'vsync lock' mode (when VsyncLock = true).
-	UByte	DutyCycle;          // Duty cycle of 85kHz modulation when in 'use carrier' mode 
-                                // (when UseCarrier = true). 128 = 50% duty cycle.
-};
-
-// Display settings (DK2).
-struct DisplayReport
-{
-    enum ShutterTypeEnum
-    {
-        // These are not yet defined.
-        ShutterType_Default     = 0,
-    };
-
-    enum CurrentLimitEnum
-    {
-        // These are not yet defined.
-        CurrentLimit_Default     = 0,
-    };
-
-	DisplayReport()
-      :	CommandId(0), Brightness(0), 
-        ShutterType(ShutterType_Default), CurrentLimit(CurrentLimit_Default), UseRolling(0), 
-        ReverseRolling(0), HighBrightness(0), SelfRefresh(0),
-        ReadPixel(0), DirectPentile(0), 
-        Persistence(0), LightingOffset(0),
-        PixelSettle(0), TotalRows(0)
-	{}
-
-    DisplayReport(  UInt16 commandId,
-                    UByte brightness,
-                    ShutterTypeEnum shutterType,
-                    CurrentLimitEnum currentLimit,
-                    bool useRolling,
-                    bool reverseRolling, 
-                    bool highBrightness, 
-                    bool selfRefresh,
-                    bool readPixel, 
-                    bool directPentile,
-                    UInt16 persistence,
-                    UInt16 lightingOffset,
-                    UInt16 pixelSettle,
-                    UInt16 totalRows)
-        :	    CommandId(commandId), Brightness(brightness), 
-                ShutterType(shutterType), CurrentLimit(currentLimit), UseRolling(useRolling), 
-                ReverseRolling(reverseRolling), HighBrightness(highBrightness), SelfRefresh(selfRefresh),
-			    ReadPixel(readPixel), DirectPentile(directPentile), 
-			    Persistence(persistence), LightingOffset(lightingOffset),
-			    PixelSettle(pixelSettle), TotalRows(totalRows)
-    { }
-
-    UInt16              CommandId;
-	UByte	            Brightness;         // See 'DK2 Firmware Specification' document for a description of
-    ShutterTypeEnum     ShutterType;        // display settings.
-    CurrentLimitEnum    CurrentLimit;
-    bool                UseRolling;
-    bool                ReverseRolling;
-    bool                HighBrightness;
-    bool                SelfRefresh;
-    bool                ReadPixel;
-    bool                DirectPentile;
-    UInt16	            Persistence;
-	UInt16	            LightingOffset;
-    UInt16	            PixelSettle;
-	UInt16	            TotalRows;
-};
-
-// MagCalibration matrix (DK2).
-struct MagCalibrationReport
-{
-	MagCalibrationReport()
-        :	    CommandId(0), Version(0), Calibration()
-	{}
-
-    MagCalibrationReport(   UInt16 commandId,
-                            UByte version,
-                            const Matrix4f& calibration)
-        :	    CommandId(commandId), Version(version), Calibration(calibration)
-    { }
-
-    UInt16      CommandId;
-	UByte	    Version;            // Version of the calibration procedure used to generate the calibration matrix.
-    Matrix4f    Calibration;        // Calibration matrix. Note only the first three rows are used by the feature report.
-};
-
-// PositionCalibration values (DK2).
-// - Sensor interface versions before 5 do not support Normal and Rotation.
-struct PositionCalibrationReport
-{
-    enum PositionTypeEnum
-    {
-        PositionType_LED     = 0,
-        PositionType_IMU     = 1
-    };
-
-    PositionCalibrationReport()
-      :	CommandId(0), Version(0), 
-        Position(0), Normal(0), Angle(0),
-        PositionIndex(0), NumPositions(0), PositionType(PositionType_LED)
-	{}
-
-    PositionCalibrationReport(UInt16 commandId,
-                        UByte version,
-                        const Vector3d& position,
-						const Vector3d& normal,
-						double rotation,
-                        UInt16 positionIndex,
-                        UInt16 numPositions,
-                        PositionTypeEnum positionType)
-        :	    CommandId(commandId), Version(version), 
-				Position(position),	Normal(normal), Angle(rotation),
-                PositionIndex(positionIndex), NumPositions(numPositions), PositionType(positionType)
-    {
-	}
-
-    UInt16			CommandId;
-	UByte			Version;            // The version of the calibration procedure used to generate the stored positions.
-    Vector3d        Position;           // Position of the LED or inertial tracker in meters. This is relative to the 
-										// center of the emitter plane of the display at nominal focus.
-	Vector3d        Normal;				// Normal of the LED or inertial tracker. This is a signed integer in 
-										// meters. The normal is relative to the position. 
-	double          Angle;			    // The rotation about the normal. This is in radians.
-    UInt16			PositionIndex;      // The current position being read or written to. Autoincrements on reads, gets set
-										// to the written value on writes.
-    UInt16			NumPositions;       // The read-only number of items with positions stored. The last position is that of
-										// the inertial tracker, all others are LED positions.
-    PositionTypeEnum PositionType;      // The type of the item which has its position reported in the current report
-};
-
-// CustomPattern values (DK2).
-struct CustomPatternReport
-{
-	CustomPatternReport()
-      :	CommandId(0), SequenceLength(0), Sequence(0),
-        LEDIndex(0), NumLEDs(0)
-	{}
-
-    CustomPatternReport(UInt16 commandId,
-                        UByte sequenceLength,
-                        UInt32 sequence,
-                        UInt16 ledIndex,
-                        UInt16 numLEDs)
-        :	    CommandId(commandId), SequenceLength(sequenceLength), Sequence(sequence),
-                LEDIndex(ledIndex), NumLEDs(numLEDs)
-    { }
-
-    UInt16      CommandId;
-	UByte	    SequenceLength;     // See 'DK2 Firmware Specification' document for a description of
-    UInt32      Sequence;           // LED custom patterns.
-    UInt16      LEDIndex;
-    UInt16      NumLEDs;
-};
-
-// KeepAliveMux settings (DK2).
-struct KeepAliveMuxReport
-{
-	KeepAliveMuxReport()
-        : CommandId(0), INReport(0), Interval(0)
-	{}
-
-    KeepAliveMuxReport( UInt16 commandId,
-                        UByte inReport,
-                        UInt16 interval)
-        :	    CommandId(commandId), INReport(inReport), Interval(interval)
-    { }
-
-    UInt16      CommandId;
-	UByte	    INReport;           // Requested IN report type (1 = DK1, 11 = DK2).
-    UInt16      Interval;           // Keep alive period in milliseconds.
-};
-
-// Manufacturing test result (DK2).
-struct ManufacturingReport
-{
-	ManufacturingReport()
-      : CommandId(0), NumStages(0), Stage(0),
-        StageVersion(0), StageLocation(0), StageTime(0), Result(0)
-	{}
-
-    ManufacturingReport(    UInt16 commandId,
-                            UByte numStages,
-                            UByte stage,
-							UByte  version,
-                            UInt16 stageLocation,
-                            UInt32 stageTime,
-                            UInt32 result)
-        :	    CommandId(commandId), NumStages(numStages), Stage(stage),
-                StageVersion(version), StageLocation(stageLocation), StageTime(stageTime), Result(result)
-    { }
-
-    UInt16      CommandId;
-	UByte	    NumStages;          // See 'DK2 Firmware Specification' document for a description of
-	UByte	    Stage;              // manufacturing test results.
-	UByte		StageVersion;
-	UInt16	    StageLocation;
-	UInt32	    StageTime;
-    UInt32      Result;
-};
-
-// UUID (DK2).
-struct UUIDReport
-{
-    static const int UUID_SIZE = 20;
-
-	UUIDReport()
-        : CommandId(0)
-	{
-        memset(UUIDValue, 0, sizeof(UUIDValue));
-    }
-                
-    UUIDReport( UInt16 commandId,
-                UByte uuid[UUID_SIZE])
-        :	    CommandId(commandId)
-    { 
-        for (int i=0; i<UUID_SIZE; i++)
-        {
-            UUIDValue[i] = uuid[i];
-        }
-    }
-
-    UInt16      CommandId;
-	UByte	    UUIDValue[UUID_SIZE];          // See 'DK2 Firmware Specification' document for
-                                        // a description of UUID.
-};
-
-// Lens Distortion (DK2).
-struct LensDistortionReport
-{
-	LensDistortionReport()
-      :	CommandId(0),
-        NumDistortions(0),
-        DistortionIndex(0),
-        Bitmask(0),
-        LensType(0),
-        Version(0),
-        EyeRelief(0),
-        MaxR(0),
-        MetersPerTanAngleAtCenter(0)
-	{}
-                
-    LensDistortionReport( UInt16 commandId,
-						  UByte numDistortions,
-						  UByte distortionIndex,
-                          UByte bitmask,
-                          UInt16 lensType,
-                          UInt16 version,
-                          UInt16 eyeRelief,
-                          UInt16 kCoefficients[11],
-                          UInt16 maxR,
-                          UInt16 metersPerTanAngleAtCenter,
-                          UInt16 chromaticAberration[4])
-        :	    CommandId(commandId),
-				NumDistortions(numDistortions),
-				DistortionIndex(distortionIndex),
-				Bitmask(bitmask),
-				LensType(lensType),
-				Version(version),
-				EyeRelief(eyeRelief),
-				MaxR(maxR),
-				MetersPerTanAngleAtCenter(metersPerTanAngleAtCenter)
-    {
-		memcpy(KCoefficients, kCoefficients, sizeof(KCoefficients));
-		memcpy(ChromaticAberration, chromaticAberration, sizeof(ChromaticAberration));
-    }
-
-    UInt16      CommandId;
-	UByte		NumDistortions;
-	UByte		DistortionIndex;
-	UByte		Bitmask;
-	UInt16		LensType;
-	UInt16		Version;
-	UInt16		EyeRelief;
-	UInt16		KCoefficients[11];
-	UInt16		MaxR;
-	UInt16		MetersPerTanAngleAtCenter;
-	UInt16		ChromaticAberration[4];
-};
-
-// Temperature calibration result (DK2).
-struct TemperatureReport
-{
-    TemperatureReport()
-      :	CommandId(0), Version(0), 
-        NumBins(0), Bin(0), NumSamples(0), Sample(0), 
-        TargetTemperature(0), ActualTemperature(0),
-        Time(0), Offset(0)
-    {}
-
-    TemperatureReport(  UInt16 commandId,
-                        UByte  version,
-                        UByte  numBins,
-                        UByte  bin,
-                        UByte  numSamples,
-                        UByte  sample,
-                        double targetTemperature,
-                        double actualTemperature,
-                        UInt32 time,
-                        Vector3d offset)
-        :	    CommandId(commandId), Version(version), 
-                NumBins(numBins), Bin(bin), NumSamples(numSamples), Sample(sample), 
-                TargetTemperature(targetTemperature), ActualTemperature(actualTemperature),
-                Time(time), Offset(offset)
-    { }
-
-    UInt16      CommandId;
-    UByte	    Version;          // See 'DK2 Firmware Specification' document for a description of
-    UByte	    NumBins;          // temperature calibration data.
-    UByte	    Bin;
-    UByte	    NumSamples;
-    UByte	    Sample;
-    double	    TargetTemperature;
-    double	    ActualTemperature;
-    UInt32      Time;             // Better hope nobody tries to use this in 2038
-    Vector3d    Offset;
-};
-
-// Gyro autocalibration result (DK2).
-struct GyroOffsetReport
-{
-    enum VersionEnum
-    {
-        // These are not yet defined.
-        Version_NoOffset     = 0,
-        Version_ShortAvg     = 1,
-        Version_LongAvg      = 2
-    };
-
-    GyroOffsetReport()
-      :	CommandId(0), Version(Version_NoOffset), 
-        Offset(0), Temperature(0)
-    {}
-
-    GyroOffsetReport(	UInt16		commandId,
-						VersionEnum version,
-						Vector3d	offset,
-						double		temperature)
-		:		CommandId(commandId), Version(version), 
-				Offset(offset), Temperature(temperature)
-    {}
-
-    UInt16      CommandId;
-    VersionEnum Version;
-    Vector3d    Offset;
-    double      Temperature;
-};
-
-
-
-//-------------------------------------------------------------------------------------
-// ***** SensorDevice
-
-// SensorDevice is an interface to sensor data.
-// Install a MessageHandler of SensorDevice instance to receive MessageBodyFrame
-// notifications.
-//
-// TBD: Add Polling API? More HID interfaces?
-
-class SensorDevice : public HIDDeviceBase, public DeviceBase
-{
-public:
-    SensorDevice() 
-    { }
-
-    // Static constant for this device type, used in template cast type checks.
-    enum { EnumDeviceType = Device_Sensor };
-
-    virtual DeviceType GetType() const   { return Device_Sensor; }
-
-	virtual UByte GetDeviceInterfaceVersion() = 0;
-
-
-    // CoordinateFrame defines whether messages come in the coordinate frame
-    // of the sensor device or HMD, which has a different internal sensor.
-    // Sensors obtained form the HMD will automatically use HMD coordinates.
-    enum CoordinateFrame
-    {
-        Coord_Sensor = 0,
-        Coord_HMD    = 1
-    };
-
-    virtual void            SetCoordinateFrame(CoordinateFrame coordframe) = 0;
-    virtual CoordinateFrame GetCoordinateFrame() const = 0;
-
-    // Sets report rate (in Hz) of MessageBodyFrame messages (delivered through MessageHandler::OnMessage call). 
-    // Currently supported maximum rate is 1000Hz. If the rate is set to 500 or 333 Hz then OnMessage will be 
-    // called twice or thrice at the same 'tick'. 
-    // If the rate is  < 333 then the OnMessage / MessageBodyFrame will be called three
-    // times for each 'tick': the first call will contain averaged values, the second
-    // and third calls will provide with most recent two recorded samples.
-    virtual void        SetReportRate(unsigned rateHz) = 0;
-    // Returns currently set report rate, in Hz. If 0 - error occurred.
-    // Note, this value may be different from the one provided for SetReportRate. The return
-    // value will contain the actual rate.
-    virtual unsigned	GetReportRate() const = 0;
-
-    // Sets maximum range settings for the sensor described by SensorRange.    
-    // The function will fail if you try to pass values outside Maximum supported
-    // by the HW, as described by SensorInfo.
-    // Pass waitFlag == true to wait for command completion. For waitFlag == true,
-    // returns true if the range was applied successfully (no HW error).
-    // For waitFlag = false, return 'true' means that command was enqueued successfully.
-    virtual bool		SetRange(const SensorRange& range, bool waitFlag = false) = 0;
-
-    // Return the current sensor range settings for the device. These may not exactly
-    // match the values applied through SetRange.
-    virtual void		GetRange(SensorRange* range) const = 0;
-
-    // Return the factory calibration parameters for the IMU
-    virtual void        GetFactoryCalibration(Vector3f* AccelOffset, Vector3f* GyroOffset,
-                                              Matrix4f* AccelMatrix, Matrix4f* GyroMatrix, 
-                                              float* Temperature) = 0;
-    // Enable/disable onboard IMU calibration
-    // If set to false, the device will return raw values
-    virtual void        SetOnboardCalibrationEnabled(bool enabled) = 0;
-    // Return true if the mag is calibrated
-    virtual bool        IsMagCalibrated() { return false; }
-
-	// Get/set feature reports from DK1 added to DK2. See 'Tracker Firmware Specification' document for details.
-	virtual bool		SetSerialReport(const SerialReport&) { return false; }
-	virtual bool		GetSerialReport(SerialReport*) { return false; }
-
-    // Get/set feature reports added to DK2. See 'DK2 Firmware Specification' document for details.
-    virtual bool		SetTrackingReport(const TrackingReport&) { return false; }
-	virtual bool		GetTrackingReport(TrackingReport*) { return false; }
-
-    virtual bool		SetDisplayReport(const DisplayReport&) { return false; }
-	virtual bool		GetDisplayReport(DisplayReport*) { return false; }
-
-    virtual bool		SetMagCalibrationReport(const MagCalibrationReport&) { return false; }
-	virtual bool		GetMagCalibrationReport(MagCalibrationReport*) { return false; }
-
-    virtual bool		SetPositionCalibrationReport(const PositionCalibrationReport&) { return false; }
-	virtual bool		GetAllPositionCalibrationReports(Array<PositionCalibrationReport>*) { return false; }
-
-    virtual bool		SetCustomPatternReport(const CustomPatternReport&) { return false; }
-	virtual bool		GetCustomPatternReport(CustomPatternReport*) { return false; }
-
-    virtual bool		SetKeepAliveMuxReport(const KeepAliveMuxReport&) { return false; }
-	virtual bool		GetKeepAliveMuxReport(KeepAliveMuxReport*) { return false; }
-
-    virtual bool		SetManufacturingReport(const ManufacturingReport&) { return false; }
-	virtual bool		GetManufacturingReport(ManufacturingReport*) { return false; }
-
-    virtual bool		SetUUIDReport(const UUIDReport&) { return false; }
-	virtual bool		GetUUIDReport(UUIDReport*) { return false; }
-
-    virtual bool		SetTemperatureReport(const TemperatureReport&) { return false; }
-    virtual bool        GetAllTemperatureReports(Array<Array<TemperatureReport> >*) { return false; }
-
-    virtual bool        GetGyroOffsetReport(GyroOffsetReport*) { return false; }
-
-    virtual bool		SetLensDistortionReport(const LensDistortionReport&) { return false; }
-    virtual bool		GetLensDistortionReport(LensDistortionReport*) { return false; }
-};
-
-//-------------------------------------------------------------------------------------
-// ***** LatencyTestConfiguration
-// LatencyTestConfiguration specifies configuration information for the Oculus Latency Tester device.
-struct LatencyTestConfiguration
-{
-    LatencyTestConfiguration(const Color& threshold, bool sendSamples = false)
-        : Threshold(threshold), SendSamples(sendSamples) 
-    {
-    }
-
-    // The color threshold for triggering a detected display change.
-    Color    Threshold;
-    // Flag specifying whether we wish to receive a stream of color values from the sensor.
-    bool        SendSamples;
-};
-
-//-------------------------------------------------------------------------------------
-// ***** LatencyTestDisplay
-// LatencyTestDisplay sets the mode and contents of the Latency Tester LED display.
-// See the 'Latency Tester Specification' document for more details.
-struct LatencyTestDisplay
-{
-    LatencyTestDisplay(UByte mode, UInt32 value)
-        : Mode(mode), Value(value)
-    {
-    }
-
-    UByte       Mode;       // The display mode that we wish to select.
-    UInt32      Value;      // The value to display.
-};
-
-//-------------------------------------------------------------------------------------
-// ***** LatencyTestDevice
-
-// LatencyTestDevice provides an interface to the Oculus Latency Tester which is used to test 'motion to photon' latency.
-class LatencyTestDevice : public HIDDeviceBase, public DeviceBase
-{
-public:
-    LatencyTestDevice()
-    { }
-
-    // Static constant for this device type, used in template cast type checks.
-    enum { EnumDeviceType = Device_LatencyTester };
-
-    virtual DeviceType GetType() const { return Device_LatencyTester; }
-
-    // Specifies configuration information including the threshold for triggering a detected color change,
-    // and a flag to enable a stream of sensor values (typically used for debugging).
-    virtual bool SetConfiguration(const LatencyTestConfiguration& configuration, bool waitFlag = false) = 0;
-
-    // Get configuration information from device.
-    virtual bool GetConfiguration(LatencyTestConfiguration* configuration) = 0;
-
-    // Used to calibrate the latency tester at the start of a test. Display the specified color on the screen
-    // beneath the latency tester and then call this method. Calibration information is lost
-    // when power is removed from the device.
-    virtual bool SetCalibrate(const Color& calibrationColor, bool waitFlag = false) = 0;
-
-    // Triggers the start of a measurement. This starts the millisecond timer on the device and 
-    // causes it to respond with the 'MessageLatencyTestStarted' message.
-    virtual bool SetStartTest(const Color& targetColor, bool waitFlag = false) = 0;
-
-    // Used to set the value displayed on the LED display panel.
-    virtual bool SetDisplay(const LatencyTestDisplay& display, bool waitFlag = false) = 0;
-
-    virtual DeviceBase* GetDevice() { return this; }
-};
-
-} // namespace OVR
-
-
-
-
-#endif