Merge OculusSDK 0.3.2 Windows Source Code

1 files changed, 434 insertions, 0 deletions

diff --git a/LibOVR/Src/OVR_Win32_DeviceManager.cpp b/LibOVR/Src/OVR_Win32_DeviceManager.cpp
new file mode 100644
index 0000000..1c14bbf
--- /dev/null
+++ b/LibOVR/Src/OVR_Win32_DeviceManager.cpp
@@ -0,0 +1,434 @@
+/************************************************************************************

+

+Filename    :   OVR_Win32_DeviceManager.cpp

+Content     :   Win32 implementation of DeviceManager.

+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.

+

+*************************************************************************************/

+

+#include "OVR_Win32_DeviceManager.h"

+

+// Sensor & HMD Factories

+#include "OVR_SensorImpl.h"

+#include "OVR_LatencyTestImpl.h"

+#include "OVR_Win32_HMDDevice.h"

+#include "OVR_Win32_DeviceStatus.h"

+#include "OVR_Win32_HIDDevice.h"

+

+#include "Kernel/OVR_Timer.h"

+#include "Kernel/OVR_Std.h"

+#include "Kernel/OVR_Log.h"

+

+DWORD Debug_WaitedObjectCount = 0;

+

+namespace OVR { namespace Win32 {

+

+

+//-------------------------------------------------------------------------------------

+// **** Win32::DeviceManager

+

+DeviceManager::DeviceManager()

+{

+    HidDeviceManager = *HIDDeviceManager::CreateInternal(this);

+}

+

+DeviceManager::~DeviceManager()

+{

+    // make sure Shutdown was called.

+    OVR_ASSERT(!pThread);

+}

+

+bool DeviceManager::Initialize(DeviceBase*)

+{

+    if (!DeviceManagerImpl::Initialize(0))

+        return false;

+

+    pThread = *new DeviceManagerThread(this);

+    if (!pThread || !pThread->Start())

+        return false;

+         

+    pCreateDesc->pDevice = this;

+    LogText("OVR::DeviceManager - initialized.\n");

+    return true;

+}

+

+void DeviceManager::Shutdown()

+{   

+    LogText("OVR::DeviceManager - shutting down.\n");

+

+    // Set Manager shutdown marker variable; this prevents

+    // any existing DeviceHandle objects from accessing device.

+    pCreateDesc->pLock->pManager = 0;

+

+    // Push for thread shutdown *WITH NO WAIT*.

+    // This will have the following effect:

+    //  - Exit command will get enqueued, which will be executed later on the thread itself.

+    //  - Beyond this point, this DeviceManager object may be deleted by our caller.

+    //  - Other commands, such as CreateDevice, may execute before ExitCommand, but they will

+    //    fail gracefully due to pLock->pManager == 0. Future commands can't be enqued

+    //    after pManager is null.

+    //  - Once ExitCommand executes, ThreadCommand::Run loop will exit and release the last

+    //    reference to the thread object.

+    pThread->PushExitCommand(false);

+    pThread->DetachDeviceManager();

+    pThread.Clear();

+

+    DeviceManagerImpl::Shutdown();

+}

+

+ThreadCommandQueue* DeviceManager::GetThreadQueue()

+{

+    return pThread;

+}

+

+bool DeviceManager::GetDeviceInfo(DeviceInfo* info) const

+{

+    if ((info->InfoClassType != Device_Manager) &&

+        (info->InfoClassType != Device_None))

+        return false;

+    

+    info->Type    = Device_Manager;

+    info->Version = 0;

+    info->ProductName = "DeviceManager";

+    info->Manufacturer = "Oculus VR, Inc.";        

+    return true;

+}

+

+DeviceEnumerator<> DeviceManager::EnumerateDevicesEx(const DeviceEnumerationArgs& args)

+{

+    // TBD: Can this be avoided in the future, once proper device notification is in place?

+    if (GetThreadId() != OVR::GetCurrentThreadId())

+    {

+        pThread->PushCall((DeviceManagerImpl*)this,

+            &DeviceManager::EnumerateAllFactoryDevices, true);

+    }

+    else

+        DeviceManager::EnumerateAllFactoryDevices();

+

+    return DeviceManagerImpl::EnumerateDevicesEx(args);

+}

+

+ThreadId DeviceManager::GetThreadId() const

+{

+    return pThread->GetThreadId();

+}

+    

+bool DeviceManager::GetHIDDeviceDesc(const String& path, HIDDeviceDesc* pdevDesc) const

+{

+    if (GetHIDDeviceManager())

+        return static_cast<HIDDeviceManager*>(GetHIDDeviceManager())->GetHIDDeviceDesc(path, pdevDesc);

+    return false;

+}

+

+

+//-------------------------------------------------------------------------------------

+// ***** DeviceManager Thread 

+

+DeviceManagerThread::DeviceManagerThread(DeviceManager* pdevMgr)

+    : Thread(ThreadStackSize), hCommandEvent(0), pDeviceMgr(pdevMgr)

+{    

+    // Create a non-signaled manual-reset event.

+    hCommandEvent = ::CreateEvent(0, TRUE, FALSE, 0);

+    if (!hCommandEvent)

+        return;

+

+    // Must add event before starting.

+    AddOverlappedEvent(0, hCommandEvent);

+

+	// Create device messages object.

+	pStatusObject = *new DeviceStatus(this);

+}

+

+DeviceManagerThread::~DeviceManagerThread()

+{

+    // Remove overlapped event [0], after thread service exit.

+    if (hCommandEvent)

+    {

+        RemoveOverlappedEvent(0, hCommandEvent);    

+        ::CloseHandle(hCommandEvent);

+        hCommandEvent = 0;

+    }

+}

+

+int DeviceManagerThread::Run()

+{

+    ThreadCommand::PopBuffer command;

+

+    SetThreadName("OVR::DeviceManagerThread");

+    LogText("OVR::DeviceManagerThread - running (ThreadId=0x%X).\n", GetThreadId());

+  

+	if (!pStatusObject->Initialize())

+	{

+		LogText("OVR::DeviceManagerThread - failed to initialize MessageObject.\n");

+	}

+

+    while(!IsExiting())

+    {

+        // PopCommand will reset event on empty queue.

+        if (PopCommand(&command))

+        {

+            command.Execute();

+        }

+        else

+        {

+            DWORD eventIndex = 0;

+            do {

+                UPInt numberOfWaitHandles = WaitHandles.GetSize();

+				Debug_WaitedObjectCount = (DWORD)numberOfWaitHandles;

+

+                DWORD waitMs = INFINITE;

+

+                // If devices have time-dependent logic registered, get the longest wait

+                // allowed based on current ticks.

+                if (!TicksNotifiers.IsEmpty())

+                {

+                    double  timeSeconds = Timer::GetSeconds();

+                    DWORD   waitAllowed;

+

+                    for (UPInt j = 0; j < TicksNotifiers.GetSize(); j++)

+                    {

+                        waitAllowed = (DWORD)(TicksNotifiers[j]->OnTicks(timeSeconds) * Timer::MsPerSecond);

+                        if (waitAllowed < waitMs)

+                            waitMs = waitAllowed;

+                    }

+                }

+          

+				// Wait for event signals or window messages.

+                eventIndex = MsgWaitForMultipleObjects((DWORD)numberOfWaitHandles, &WaitHandles[0], FALSE, waitMs, QS_ALLINPUT);

+				

+                if (eventIndex != WAIT_FAILED)

+                {

+                    if (eventIndex == WAIT_TIMEOUT)

+                        continue;

+

+                    // TBD: Does this ever apply?

+                    OVR_ASSERT(eventIndex < WAIT_ABANDONED_0);

+

+                    if (eventIndex == WAIT_OBJECT_0)

+                    {

+                        // Handle [0] services commands.

+                        break;

+                    }

+					else if (eventIndex == WAIT_OBJECT_0 + numberOfWaitHandles)

+					{

+						// Handle Windows messages.

+						pStatusObject->ProcessMessages();

+					}

+                    else 

+                    {

+                        // Notify waiting device that its event is signaled.

+                        unsigned i = eventIndex - WAIT_OBJECT_0; 

+                        OVR_ASSERT(i < numberOfWaitHandles);

+                        if (WaitNotifiers[i])                        

+                            WaitNotifiers[i]->OnOverlappedEvent(WaitHandles[i]);

+                    }

+                }

+

+            } while(eventIndex != WAIT_FAILED);

+                    

+        }

+    }

+

+	pStatusObject->ShutDown();

+

+    LogText("OVR::DeviceManagerThread - exiting (ThreadId=0x%X).\n", GetThreadId());

+    return 0;

+}

+

+bool DeviceManagerThread::AddOverlappedEvent(Notifier* notify, HANDLE hevent)

+{

+    WaitNotifiers.PushBack(notify);

+    WaitHandles.PushBack(hevent);

+

+    OVR_ASSERT(WaitNotifiers.GetSize() <= MAXIMUM_WAIT_OBJECTS);

+    return true;

+}

+

+bool DeviceManagerThread::RemoveOverlappedEvent(Notifier* notify, HANDLE hevent)

+{

+    // [0] is reserved for thread commands with notify of null, but we still

+    // can use this function to remove it.

+    for (UPInt i = 0; i < WaitNotifiers.GetSize(); i++)

+    {

+        if ((WaitNotifiers[i] == notify) && (WaitHandles[i] == hevent))

+        {

+            WaitNotifiers.RemoveAt(i);

+            WaitHandles.RemoveAt(i);

+            return true;

+        }

+    }

+    return false;

+}

+

+bool DeviceManagerThread::AddTicksNotifier(Notifier* notify)

+{

+     TicksNotifiers.PushBack(notify);

+     return true;

+}

+

+bool DeviceManagerThread::RemoveTicksNotifier(Notifier* notify)

+{

+    for (UPInt i = 0; i < TicksNotifiers.GetSize(); i++)

+    {

+        if (TicksNotifiers[i] == notify)

+        {

+            TicksNotifiers.RemoveAt(i);

+            return true;

+        }

+    }

+    return false;

+}

+

+bool DeviceManagerThread::AddMessageNotifier(Notifier* notify)

+{

+	MessageNotifiers.PushBack(notify);

+	return true;

+}

+

+bool DeviceManagerThread::RemoveMessageNotifier(Notifier* notify)

+{

+	for (UPInt i = 0; i < MessageNotifiers.GetSize(); i++)

+	{

+		if (MessageNotifiers[i] == notify)

+		{

+			MessageNotifiers.RemoveAt(i);

+			return true;

+		}

+	}

+	return false;

+}

+

+bool DeviceManagerThread::OnMessage(MessageType type, const String& devicePath)

+{

+	Notifier::DeviceMessageType notifierMessageType = Notifier::DeviceMessage_DeviceAdded;

+	if (type == DeviceAdded)

+	{

+	}

+	else if (type == DeviceRemoved)

+	{

+		notifierMessageType = Notifier::DeviceMessage_DeviceRemoved;

+	}

+	else

+	{

+		OVR_ASSERT(false);

+	}

+

+	bool error = false;

+    bool deviceFound = false;

+	for (UPInt i = 0; i < MessageNotifiers.GetSize(); i++)

+    {

+		if (MessageNotifiers[i] && 

+			MessageNotifiers[i]->OnDeviceMessage(notifierMessageType, devicePath, &error))

+		{

+			// The notifier belonged to a device with the specified device name so we're done.

+            deviceFound = true;

+			break;

+		}

+    }

+    if (type == DeviceAdded && !deviceFound)

+    {

+        Lock::Locker devMgrLock(&DevMgrLock);

+        // a new device was connected. Go through all device factories and

+        // try to detect the device using HIDDeviceDesc.

+        HIDDeviceDesc devDesc;

+        if (pDeviceMgr->GetHIDDeviceDesc(devicePath, &devDesc))

+        {

+            Lock::Locker deviceLock(pDeviceMgr->GetLock());

+            DeviceFactory* factory = pDeviceMgr->Factories.GetFirst();

+            while(!pDeviceMgr->Factories.IsNull(factory))

+            {

+                if (factory->DetectHIDDevice(pDeviceMgr, devDesc))

+                {

+                    deviceFound = true;

+                    break;

+                }

+                factory = factory->pNext;

+            }

+        }

+    }

+

+    if (!deviceFound && strstr(devicePath.ToCStr(), "#OVR00"))

+    {

+        Ptr<DeviceManager> pmgr;

+        {

+            Lock::Locker devMgrLock(&DevMgrLock);

+            pmgr = pDeviceMgr;

+        }

+        // HMD plugged/unplugged

+        // This is not a final solution to enumerate HMD devices and get

+        // a first available handle. This won't work with multiple rifts.

+        // @TODO (!AB)

+        pmgr->EnumerateDevices<HMDDevice>();

+    }

+

+	return !error;

+}

+

+void DeviceManagerThread::DetachDeviceManager()

+{

+    Lock::Locker devMgrLock(&DevMgrLock);

+    pDeviceMgr = NULL;

+}

+

+} // namespace Win32

+

+

+//-------------------------------------------------------------------------------------

+// ***** Creation

+

+

+// Creates a new DeviceManager and initializes OVR.

+DeviceManager* DeviceManager::Create()

+{

+

+    if (!System::IsInitialized())

+    {

+        // Use custom message, since Log is not yet installed.

+        OVR_DEBUG_STATEMENT(Log::GetDefaultLog()->

+            LogMessage(Log_Debug, "DeviceManager::Create failed - OVR::System not initialized"); );

+        return 0;

+    }

+

+    Ptr<Win32::DeviceManager> manager = *new Win32::DeviceManager;

+

+    if (manager)

+    {

+        if (manager->Initialize(0))

+        {            

+            manager->AddFactory(&SensorDeviceFactory::GetInstance());

+			manager->AddFactory(&LatencyTestDeviceFactory::GetInstance());

+			manager->AddFactory(&Win32::HMDDeviceFactory::GetInstance());

+			

+            manager->AddRef();

+        }

+        else

+        {

+            manager.Clear();

+        }

+

+    }    

+

+    return manager.GetPtr();

+}

+

+

+} // namespace OVR

+