Bump OculusVR RIFT SDK to 0.4.4

1 files changed, 0 insertions, 428 deletions

diff --git a/LibOVR/Src/OVR_DeviceImpl.h b/LibOVR/Src/OVR_DeviceImpl.h
deleted file mode 100644
index 8e737a5..0000000
--- a/LibOVR/Src/OVR_DeviceImpl.h
+++ /dev/null
@@ -1,428 +0,0 @@
-/************************************************************************************
-
-Filename    :   OVR_DeviceImpl.h
-Content     :   Partial back-end independent implementation of Device interfaces
-Created     :   October 10, 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_DeviceImpl_h
-#define OVR_DeviceImpl_h
-
-#include "OVR_Device.h"
-#include "Kernel/OVR_Atomic.h"
-#include "Kernel/OVR_Log.h"
-#include "Kernel/OVR_System.h"
-
-#include "Kernel/OVR_Threads.h"
-#include "OVR_ThreadCommandQueue.h"
-#include "OVR_HIDDevice.h"
-
-namespace OVR {
-    
-class DeviceManagerImpl;
-class DeviceFactory;
-
-enum
-{
-    Oculus_VendorId = 0x2833,
-    Device_Tracker_ProductId  = 0x0001,
-    Device_Tracker2_ProductId  = 0x0021,
-    Device_KTracker_ProductId = 0x0010,
-};
-
-
-// Wrapper for MessageHandler that includes synchronization logic.
-class MessageHandlerRef
-{   
-    enum
-    {
-        MaxHandlersCount = 4
-    };
-public:
-    MessageHandlerRef(DeviceBase* device);
-    ~MessageHandlerRef();
-
-    bool            HasHandlers() const { return HandlersCount > 0; };
-    void            AddHandler(MessageHandler* handler);
-    // returns false if the handler is not found
-    bool            RemoveHandler(MessageHandler* handler);
-    // Not-thread-safe version
-    void            AddHandler_NTS(MessageHandler* handler);
-    
-    void            Call(const Message& msg);
-
-    Lock*           GetLock() const { return pLock; }
-    DeviceBase*     GetDevice() const  { return pDevice; }
-
-private:
-    Lock*           pLock;   // Cached global handler lock.
-    DeviceBase*     pDevice;
-
-    int             HandlersCount;
-    MessageHandler* pHandlers[MaxHandlersCount];
-
-    bool            removeHandler(int idx);
-};
-
-
-//-------------------------------------------------------------------------------------
-
-// DeviceManagerLock is a synchronization lock used by DeviceManager for Devices
-// and is allocated separately for potentially longer lifetime.
-// 
-// DeviceManagerLock is used for all of the following:
-//  - Adding/removing devices
-//  - Reporting manager lifetime (pManager != 0) for DeviceHandles
-//  - Protecting device creation/shutdown.
-
-class DeviceManagerLock : public RefCountBase<DeviceManagerLock>
-{
-public:
-    Lock                CreateLock;
-    DeviceManagerImpl*  pManager;
-
-    DeviceManagerLock() : pManager(0) { }
-};
-
-
-// DeviceCreateDesc provides all of the information needed to create any device, a derived
-// instance of this class is created by DeviceFactory during enumeration.
-//   - DeviceCreateDesc may or may not be a part of DeviceManager::Devices list (check pNext != 0).
-//   - Referenced and kept alive by DeviceHandle.
-
-class DeviceCreateDesc : public ListNode<DeviceCreateDesc>, public NewOverrideBase
-{    
-    void operator = (const DeviceCreateDesc&) { } // Assign not supported; suppress MSVC warning.
-public:
-    DeviceCreateDesc(DeviceFactory* factory, DeviceType type)
-        : pFactory(factory), Type(type), pLock(0), HandleCount(0), pDevice(0), Enumerated(true)
-    {
-        pNext = pPrev = 0;
-    }
-
-    virtual ~DeviceCreateDesc()
-    {
-        OVR_ASSERT(!pDevice);
-        if (pNext)        
-            RemoveNode();
-    }
-
-    DeviceManagerImpl* GetManagerImpl() const { return pLock->pManager; }
-    Lock*              GetLock() const        { return &pLock->CreateLock; }
-
-    // DeviceCreateDesc reference counting is tied to Devices list management,
-    // see comments for HandleCount.
-    void AddRef();
-    void Release();
-
-
-    // *** Device creation/matching Interface
-
-
-    // Cloning copies us to an allocated object when new device is enumerated.
-    virtual DeviceCreateDesc* Clone() const = 0;
-    // Creates a new device instance without Initializing it; the
-    // later is done my Initialize()/Shutdown() methods of the device itself.
-    virtual DeviceBase*       NewDeviceInstance() = 0;
-    // Override to return device-specific info.
-    virtual bool              GetDeviceInfo(DeviceInfo* info) const = 0;
-
-
-    enum MatchResult
-    {
-        Match_None,
-        Match_Found,
-        Match_Candidate
-    };
-
-    // Override to return Match_Found if descriptor matches our device.
-    // Match_Candidate can be returned, with pcandicate update, if this may be a match
-    // but more searching is necessary. If this is the case UpdateMatchedCandidate will be called.
-    virtual MatchResult       MatchDevice(const DeviceCreateDesc& other,
-                                          DeviceCreateDesc** pcandidate) const = 0;
-    
-    // Called for matched candidate after all potential matches are iterated.
-    // Used to update HMDevice creation arguments from Sensor.
-    // Optional return param 'newDeviceFlag' will be set to true if the 
-    // 'desc' refers to a new device; false, otherwise.
-    // Return 'false' to create new object, 'true' if done with this argument.
-    virtual bool              UpdateMatchedCandidate(
-        const DeviceCreateDesc& desc, bool* newDeviceFlag = NULL) 
-    { OVR_UNUSED2(desc, newDeviceFlag); return false; }
-
-    // Matches HID device to the descriptor.
-    virtual bool              MatchHIDDevice(const HIDDeviceDesc&) const { return false; }
-
-    // Matches device by path.
-    virtual bool              MatchDevice(const String& /*path*/) { return false; }
-//protected:
-    DeviceFactory* const        pFactory;
-    const DeviceType            Type;
-
-    // List in which this descriptor lives. pList->CreateLock required if added/removed.
-    Ptr<DeviceManagerLock>      pLock;    
-
-    // Strong references to us: Incremented by Device, DeviceHandles & Enumerators.
-    // May be 0 if device not created and there are no handles.
-    // Following transitions require pList->CreateLock:
-    //  {1 -> 0}: May delete & remove handle if no longer available.
-    //  {0 -> 1}: Device creation is only possible if manager is still alive.
-    AtomicInt<UInt32>           HandleCount;
-    // If not null, points to our created device instance. Modified during lock only.
-    DeviceBase*                 pDevice;
-    // True if device is marked as available during enumeration.
-    bool                        Enumerated;
-};
-
-
-
-// Common data present in the implementation of every DeviceBase.
-// Injected by DeviceImpl.
-class DeviceCommon
-{
-public:
-    AtomicInt<UInt32>      RefCount;
-    Ptr<DeviceCreateDesc>  pCreateDesc;
-    Ptr<DeviceBase>        pParent;
-    volatile bool          ConnectedFlag;
-    MessageHandlerRef      HandlerRef;
-
-    DeviceCommon(DeviceCreateDesc* createDesc, DeviceBase* device, DeviceBase* parent)
-        : RefCount(1), pCreateDesc(createDesc), pParent(parent),
-          ConnectedFlag(true), HandlerRef(device)
-    {
-    }
-	virtual ~DeviceCommon() {}
-
-    // Device reference counting delegates to Manager thread to actually kill devices.
-    void DeviceAddRef();
-    void DeviceRelease();
-
-    Lock* GetLock() const { return pCreateDesc->GetLock(); }
-
-    virtual bool Initialize(DeviceBase* parent) = 0;
-    virtual void Shutdown() = 0;
-};
-
-
-//-------------------------------------------------------------------------------------
-// DeviceImpl address DeviceRecord implementation to a device base class B.
-// B must be derived form DeviceBase.
-
-template<class B>
-class DeviceImpl : public B, public DeviceCommon
-{
-public:
-    DeviceImpl(DeviceCreateDesc* createDesc, DeviceBase* parent)
-        : DeviceCommon(createDesc, getThis(), parent)        
-    {
-    }
-
-	// Convenience method to avoid manager access typecasts.
-    DeviceManagerImpl*  GetManagerImpl() const      { return pCreateDesc->pLock->pManager; }
-
-    // Inline to avoid warnings.
-    DeviceImpl*         getThis()                   { return this; }
-
-    // Common implementation delegate to avoid virtual inheritance and dynamic casts.
-    virtual DeviceCommon* getDeviceCommon() const   { return (DeviceCommon*)this; }
-
-    /*
-    virtual void            AddRef()                                   { pCreateDesc->DeviceAddRef(); }
-    virtual void            Release()                                  { pCreateDesc->DeviceRelease(); }
-    virtual DeviceBase*     GetParent() const                          { return pParent.GetPtr(); } 
-    virtual DeviceManager*  GetManager() const                         { return pCreateDesc->pLock->pManager;}
-    virtual void            SetMessageHandler(MessageHandler* handler) { HanderRef.SetHandler(handler); }
-    virtual MessageHandler* GetMessageHandler() const                  { return HanderRef.GetHandler(); }
-    virtual DeviceType      GetType() const                            { return pCreateDesc->Type; }
-    virtual DeviceType      GetType() const                            { return pCreateDesc->Type; }
-    */
-};
-
-
-//-------------------------------------------------------------------------------------
-// ***** DeviceFactory
-
-// DeviceFactory is maintained in DeviceManager for each separately-enumerable
-// device type; factories allow separation of unrelated enumeration code.
-
-class DeviceFactory : public ListNode<DeviceFactory>, public NewOverrideBase
-{    
-public:
-
-    DeviceFactory() : pManager(0)
-    {
-        pNext = pPrev = 0;
-    }
-    virtual ~DeviceFactory() { }
-
-    DeviceManagerImpl* GetManagerImpl() { return pManager; }
-
-    // Notifiers called when we are added to/removed from a device.
-    virtual bool AddedToManager(DeviceManagerImpl* manager)
-    {
-        OVR_ASSERT(pManager == 0);
-        pManager = manager;
-        return true;
-    }
-
-    virtual void RemovedFromManager()
-    {
-        pManager = 0;
-    }
-
-
-    // *** Device Enumeration/Creation Support
-    
-    // Passed to EnumerateDevices to be informed of every device detected.
-    class EnumerateVisitor
-    {
-    public:        
-        virtual void Visit(const DeviceCreateDesc& createDesc) = 0;
-    };
-
-    // Enumerates factory devices by notifying EnumerateVisitor about every
-    // device that is present.
-    virtual void EnumerateDevices(EnumerateVisitor& visitor) = 0;
-
-    // Matches vendorId/productId pair with the factory; returns 'true'
-    // if the factory can handle the device.
-    virtual bool MatchVendorProduct(UInt16 vendorId, UInt16 productId) const
-    {
-        OVR_UNUSED2(vendorId, productId);
-        return false;
-    }
-
-    // Detects the HID device and adds the DeviceCreateDesc into Devices list, if
-    // the device belongs to this factory. Returns 'false', if not.
-    virtual bool DetectHIDDevice(DeviceManager* pdevMgr, const HIDDeviceDesc& desc)
-    {
-        OVR_UNUSED2(pdevMgr, desc);
-        return false;
-    }
-    
-protected:
-    DeviceManagerImpl* pManager;
-};
-
-
-//-------------------------------------------------------------------------------------
-// ***** DeviceManagerImpl
-
-// DeviceManagerImpl is a partial default DeviceManager implementation that
-// maintains a list of devices and supports their enumeration.
-
-class DeviceManagerImpl : public DeviceImpl<OVR::DeviceManager>, public ThreadCommandQueue
-{
-public:
-    DeviceManagerImpl();
-    ~DeviceManagerImpl();
-
-    // Constructor helper function to create Descriptor and manager lock during initialization.
-    static DeviceCreateDesc* CreateManagerDesc();
-
-    // DeviceManagerImpl provides partial implementation of Initialize/Shutdown that must
-    // be called by the platform-specific derived class.
-    virtual bool Initialize(DeviceBase* parent);
-    virtual void Shutdown();
-
-
-    // Every DeviceManager has an associated profile manager, which is used to store
-    // user settings that may affect device behavior. 
-    virtual ProfileManager* GetProfileManager() const { return pProfileManager.GetPtr(); }
-
-    // Override to return ThreadCommandQueue implementation used to post commands
-    // to the background device manager thread (that must be created by Initialize).
-    virtual ThreadCommandQueue* GetThreadQueue() = 0;
-
-    // Returns the thread id of the DeviceManager.
-    virtual ThreadId GetThreadId() const = 0;
-
-    virtual DeviceEnumerator<> EnumerateDevicesEx(const DeviceEnumerationArgs& args);
-
-
-    // 
-    void AddFactory(DeviceFactory* factory)
-    {
-        // This lock is only needed if we call AddFactory after manager thread creation.
-        Lock::Locker scopeLock(GetLock());
-        Factories.PushBack(factory);
-        factory->AddedToManager(this);        
-    }
-
-    void CallOnDeviceAdded(DeviceCreateDesc* desc)
-    {
-        HandlerRef.Call(MessageDeviceStatus(Message_DeviceAdded, this, DeviceHandle(desc)));
-    }
-    void CallOnDeviceRemoved(DeviceCreateDesc* desc)
-    {
-        HandlerRef.Call(MessageDeviceStatus(Message_DeviceRemoved, this, DeviceHandle(desc)));
-    }
-
-    // Helper to access Common data for a device.
-    static DeviceCommon* GetDeviceCommon(DeviceBase* device)
-    {
-        return device->getDeviceCommon();
-    }
-
-
-    // Background-thread callbacks for DeviceCreation/Release. These
-    DeviceBase* CreateDevice_MgrThread(DeviceCreateDesc* createDesc, DeviceBase* parent = 0);
-    Void        ReleaseDevice_MgrThread(DeviceBase* device);
-
-   
-    // Calls EnumerateDevices() on all factories
-    virtual Void EnumerateAllFactoryDevices();
-    // Enumerates devices for a particular factory.
-    virtual Void EnumerateFactoryDevices(DeviceFactory* factory);
-
-    virtual HIDDeviceManager* GetHIDDeviceManager() const
-    {
-        return HidDeviceManager;
-    }
-
-    // Adds device (DeviceCreateDesc*) into Devices. Returns NULL, 
-    // if unsuccessful or device is already in the list.
-    virtual Ptr<DeviceCreateDesc> AddDevice_NeedsLock(const DeviceCreateDesc& createDesc);
-    
-    // Finds a device descriptor by path and optional type.
-    Ptr<DeviceCreateDesc> FindDevice(const String& path, DeviceType = Device_None);
-
-    // Finds HID device by HIDDeviceDesc.
-    Ptr<DeviceCreateDesc> FindHIDDevice(const HIDDeviceDesc&, bool created);
-    void DetectHIDDevice(const HIDDeviceDesc&);
-
-    // Manager Lock-protected list of devices.
-    List<DeviceCreateDesc>  Devices;    
-
-    // Factories used to detect and manage devices.
-    List<DeviceFactory>     Factories;
-
-protected:
-    Ptr<HIDDeviceManager>   HidDeviceManager;
-    Ptr<ProfileManager>     pProfileManager;
-};
-
-
-} // namespace OVR
-
-#endif