oculus1

view libovr/Src/OVR_HIDDeviceImpl.h @ 21:ef4c9d8eeca7

find changesets by author, revision, files, or words in the commit message
added shaderless distortion method
author John Tsiombikas <nuclear@member.fsf.org>
date Wed, 02 Oct 2013 04:09:37 +0300
parents
children
line source
1 /************************************************************************************
2
3 Filename : OVR_HIDDeviceImpl.h
4 Content : Implementation of HIDDevice.
5 Created : March 7, 2013
6 Authors : Lee Cooper
7
8 Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
9
10 Use of this software is subject to the terms of the Oculus license
11 agreement provided at the time of installation or download, or which
12 otherwise accompanies this software in either electronic or hard copy form.
13
14 *************************************************************************************/
15
16 #ifndef OVR_HIDDeviceImpl_h
17 #define OVR_HIDDeviceImpl_h
18
19 //#include "OVR_Device.h"
20 #include "OVR_DeviceImpl.h"
21
22 namespace OVR {
23
24 //-------------------------------------------------------------------------------------
25 class HIDDeviceCreateDesc : public DeviceCreateDesc
26 {
27 public:
28 HIDDeviceCreateDesc(DeviceFactory* factory, DeviceType type, const HIDDeviceDesc& hidDesc)
29 : DeviceCreateDesc(factory, type), HIDDesc(hidDesc) { }
30 HIDDeviceCreateDesc(const HIDDeviceCreateDesc& other)
31 : DeviceCreateDesc(other.pFactory, other.Type), HIDDesc(other.HIDDesc) { }
32
33 virtual bool MatchDevice(const String& path)
34 {
35 // should it be case insensitive?
36 return HIDDesc.Path.CompareNoCase(path) == 0;
37 }
38
39 HIDDeviceDesc HIDDesc;
40 };
41
42 //-------------------------------------------------------------------------------------
43 template<class B>
44 class HIDDeviceImpl : public DeviceImpl<B>, public HIDDevice::HIDHandler
45 {
46 public:
47 HIDDeviceImpl(HIDDeviceCreateDesc* createDesc, DeviceBase* parent)
48 : DeviceImpl<B>(createDesc, parent)
49 {
50 }
51
52 // HIDDevice::Handler interface.
53 virtual void OnDeviceMessage(HIDDeviceMessageType messageType)
54 {
55 MessageType handlerMessageType;
56 switch (messageType) {
57 case HIDDeviceMessage_DeviceAdded:
58 handlerMessageType = Message_DeviceAdded;
59 break;
60
61 case HIDDeviceMessage_DeviceRemoved:
62 handlerMessageType = Message_DeviceRemoved;
63 break;
64
65 default: OVR_ASSERT(0); return;
66 }
67
68 // Do device notification.
69 {
70 Lock::Locker scopeLock(this->HandlerRef.GetLock());
71
72 if (this->HandlerRef.GetHandler())
73 {
74 MessageDeviceStatus status(handlerMessageType, this, OVR::DeviceHandle(this->pCreateDesc));
75 this->HandlerRef.GetHandler()->OnMessage(status);
76 }
77 }
78
79 // Do device manager notification.
80 DeviceManagerImpl* manager = this->GetManagerImpl();
81 switch (handlerMessageType) {
82 case Message_DeviceAdded:
83 manager->CallOnDeviceAdded(this->pCreateDesc);
84 break;
85
86 case Message_DeviceRemoved:
87 manager->CallOnDeviceRemoved(this->pCreateDesc);
88 break;
89
90 default:;
91 }
92 }
93
94 virtual bool Initialize(DeviceBase* parent)
95 {
96 // Open HID device.
97 HIDDeviceDesc& hidDesc = *getHIDDesc();
98 HIDDeviceManager* pManager = GetHIDDeviceManager();
99
100
101 HIDDevice* device = pManager->Open(hidDesc.Path);
102 if (!device)
103 {
104 return false;
105 }
106
107 InternalDevice = *device;
108 InternalDevice->SetHandler(this);
109
110 // AddRef() to parent, forcing chain to stay alive.
111 DeviceImpl<B>::pParent = parent;
112
113 return true;
114 }
115
116 virtual void Shutdown()
117 {
118 InternalDevice->SetHandler(NULL);
119
120 // Remove the handler, if any.
121 this->HandlerRef.SetHandler(0);
122
123 DeviceImpl<B>::pParent.Clear();
124 }
125
126 DeviceManager* GetDeviceManager()
127 {
128 return DeviceImpl<B>::pCreateDesc->GetManagerImpl();
129 }
130
131 HIDDeviceManager* GetHIDDeviceManager()
132 {
133 return DeviceImpl<B>::pCreateDesc->GetManagerImpl()->GetHIDDeviceManager();
134 }
135
136
137 struct WriteData
138 {
139 enum { BufferSize = 64 };
140 UByte Buffer[64];
141 UPInt Size;
142
143 WriteData(UByte* data, UPInt size) : Size(size)
144 {
145 OVR_ASSERT(size <= BufferSize);
146 memcpy(Buffer, data, size);
147 }
148 };
149
150 bool SetFeatureReport(UByte* data, UInt32 length)
151 {
152 WriteData writeData(data, length);
153
154 // Push call with wait.
155 bool result = false;
156
157 ThreadCommandQueue* pQueue = this->GetManagerImpl()->GetThreadQueue();
158 if (!pQueue->PushCallAndWaitResult(this, &HIDDeviceImpl::setFeatureReport, &result, writeData))
159 return false;
160
161 return result;
162 }
163
164 bool setFeatureReport(const WriteData& data)
165 {
166 return InternalDevice->SetFeatureReport((UByte*) data.Buffer, (UInt32) data.Size);
167 }
168
169 bool GetFeatureReport(UByte* data, UInt32 length)
170 {
171 bool result = false;
172
173 ThreadCommandQueue* pQueue = this->GetManagerImpl()->GetThreadQueue();
174 if (!pQueue->PushCallAndWaitResult(this, &HIDDeviceImpl::getFeatureReport, &result, data, length))
175 return false;
176
177 return result;
178 }
179
180 bool getFeatureReport(UByte* data, UInt32 length)
181 {
182 return InternalDevice->GetFeatureReport(data, length);
183 }
184
185 protected:
186 HIDDevice* GetInternalDevice() const
187 {
188 return InternalDevice;
189 }
190
191 HIDDeviceDesc* getHIDDesc() const
192 { return &getCreateDesc()->HIDDesc; }
193
194 HIDDeviceCreateDesc* getCreateDesc() const
195 { return (HIDDeviceCreateDesc*) &(*DeviceImpl<B>::pCreateDesc); }
196
197 private:
198 Ptr<HIDDevice> InternalDevice;
199 };
200
201 } // namespace OVR
202
203 #endif