razerHydraDevice.cpp

Public Functions

DefineEngineFunction(getRazerHydraControllerPos , Point3F , (S32 controller) , "@brief Get the given Razer Hydra controller's last <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">position\n\n</a>" "@param controller Controller number <a href="/coding/file/cmdgram_8cpp/#cmdgram_8cpp_1a5bafda9519252aa2d0fd038153f77dca">to</a> <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">check.\n</a>" "@return A <a href="/coding/class/classpoint3f/">Point3F</a> containing the last known <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">position.\n</a>" "@ingroup Game" )

DefineEngineFunction(getRazerHydraControllerRot , AngAxisF , (S32 controller) , "@brief Get the given Razer Hydra controller's last <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">rotation\n\n</a>" "@param controller Controller number <a href="/coding/file/cmdgram_8cpp/#cmdgram_8cpp_1a5bafda9519252aa2d0fd038153f77dca">to</a> <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">check.\n</a>" "@return A <a href="/coding/class/classangaxisf/">AngAxisF</a> containing the last known <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">rotation.\n</a>" "@ingroup Game" )

DefineEngineFunction(getRazerHydraControllerTransform , TransformF , (S32 controller) , "@brief Get the given Razer Hydra controller's last <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">transform\n\n</a>" "@param controller Controller number <a href="/coding/file/cmdgram_8cpp/#cmdgram_8cpp_1a5bafda9519252aa2d0fd038153f77dca">to</a> <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">check.\n</a>" "@return A <a href="/coding/class/classtransformf/">TransformF</a> containing the last known <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">transform.\n</a>" "@ingroup Game" )

DefineEngineFunction(isRazerHydraActive , bool , () , "@brief Used <a href="/coding/file/cmdgram_8cpp/#cmdgram_8cpp_1a5bafda9519252aa2d0fd038153f77dca">to</a> determine <a href="/coding/file/tsmeshintrinsics_8cpp/#tsmeshintrinsics_8cpp_1a4e4fa7e3399708e0777b5308db01278c">if</a> the Razer Hydra input device <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">active\n\n</a>" "The Razer Hydra input device is considered active when the support library has been " "loaded and the controller has been <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">found.\n\n</a>" "@return True <a href="/coding/file/tsmeshintrinsics_8cpp/#tsmeshintrinsics_8cpp_1a4e4fa7e3399708e0777b5308db01278c">if</a> the Razer Hydra input device is <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">active.\n</a>" "@ingroup Game" )

DefineEngineFunction(isRazerHydraControllerDocked , bool , (S32 controller) , "@brief Used <a href="/coding/file/cmdgram_8cpp/#cmdgram_8cpp_1a5bafda9519252aa2d0fd038153f77dca">to</a> determine <a href="/coding/file/tsmeshintrinsics_8cpp/#tsmeshintrinsics_8cpp_1a4e4fa7e3399708e0777b5308db01278c">if</a> the given Razer Hydra controller is <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">docked\n\n</a>" "@param controller Controller number <a href="/coding/file/cmdgram_8cpp/#cmdgram_8cpp_1a5bafda9519252aa2d0fd038153f77dca">to</a> <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">check.\n</a>" "@return True <a href="/coding/file/tsmeshintrinsics_8cpp/#tsmeshintrinsics_8cpp_1a4e4fa7e3399708e0777b5308db01278c">if</a> the given Razer Hydra controller is docked. Also returns true <a href="/coding/file/tsmeshintrinsics_8cpp/#tsmeshintrinsics_8cpp_1a4e4fa7e3399708e0777b5308db01278c">if</a> " "the input device is not found or <a href="/coding/file/cmdscan_8cpp/#cmdscan_8cpp_1aeab71244afb687f16d8c4f5ee9d6ef0e">active.\n</a>" "@ingroup Game" )

if(RazerHydraDevice::smEnableDevice )

registerDevice(RAZERHYDRADEV )

  1
  2//-----------------------------------------------------------------------------
  3// Copyright (c) 2012 GarageGames, LLC
  4//
  5// Permission is hereby granted, free of charge, to any person obtaining a copy
  6// of this software and associated documentation files (the "Software"), to
  7// deal in the Software without restriction, including without limitation the
  8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  9// sell copies of the Software, and to permit persons to whom the Software is
 10// furnished to do so, subject to the following conditions:
 11//
 12// The above copyright notice and this permission notice shall be included in
 13// all copies or substantial portions of the Software.
 14//
 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 21// IN THE SOFTWARE.
 22//-----------------------------------------------------------------------------
 23
 24#include "platform/input/razerHydra/razerHydraDevice.h"
 25#include "platform/input/razerHydra/razerHydraData.h"
 26#include "platform/input/razerHydra/razerHydraConstants.h"
 27#include "platform/input/razerHydra/razerHydraFrameStore.h"
 28#include "platform/platformInput.h"
 29#include "core/module.h"
 30#include "console/engineAPI.h"
 31#include "math/mAngAxis.h"
 32#include "math/mTransform.h"
 33
 34MODULE_BEGIN( RazerHydraDevice )
 35
 36   MODULE_INIT_AFTER( InputEventManager )
 37   MODULE_SHUTDOWN_BEFORE( InputEventManager )
 38
 39   MODULE_INIT
 40   {
 41      RazerHydraDevice::staticInit();
 42      ManagedSingleton< RazerHydraDevice >::createSingleton();
 43      if(RazerHydraDevice::smEnableDevice)
 44      {
 45         RAZERHYDRADEV->enable();
 46      }
 47
 48      // Register the device with the Input Event Manager
 49      INPUTMGR->registerDevice(RAZERHYDRADEV);
 50   }
 51   
 52   MODULE_SHUTDOWN
 53   {
 54      INPUTMGR->unregisterDevice(RAZERHYDRADEV);
 55      ManagedSingleton< RazerHydraDevice >::deleteSingleton();
 56   }
 57
 58MODULE_END;
 59
 60bool RazerHydraDevice::smEnableDevice = true;
 61
 62bool RazerHydraDevice::smProcessWhenDocked = false;
 63
 64bool RazerHydraDevice::smSeparatePositionEvents = true;
 65bool RazerHydraDevice::smCombinedPositionEvents = false;
 66bool RazerHydraDevice::smRotationAsAxisEvents = false;
 67
 68F32 RazerHydraDevice::smMaximumAxisAngle = 25.0;
 69
 70bool RazerHydraDevice::smGenerateWholeFrameEvents = false;
 71
 72U32 RazerHydraDevice::RH_DOCKED[RazerHydraConstants::MaxControllers] = {0};
 73U32 RazerHydraDevice::RH_POSX[RazerHydraConstants::MaxControllers] = {0};
 74U32 RazerHydraDevice::RH_POSY[RazerHydraConstants::MaxControllers] = {0};
 75U32 RazerHydraDevice::RH_POSZ[RazerHydraConstants::MaxControllers] = {0};
 76U32 RazerHydraDevice::RH_POS[RazerHydraConstants::MaxControllers] = {0};
 77U32 RazerHydraDevice::RH_ROT[RazerHydraConstants::MaxControllers] = {0};
 78U32 RazerHydraDevice::RH_ROTAXISX[RazerHydraConstants::MaxControllers] = {0};
 79U32 RazerHydraDevice::RH_ROTAXISY[RazerHydraConstants::MaxControllers] = {0};
 80U32 RazerHydraDevice::RH_THUMBX[RazerHydraConstants::MaxControllers] = {0};
 81U32 RazerHydraDevice::RH_THUMBY[RazerHydraConstants::MaxControllers] = {0};
 82U32 RazerHydraDevice::RH_TRIGGER[RazerHydraConstants::MaxControllers] = {0};
 83U32 RazerHydraDevice::RH_SHOULDER[RazerHydraConstants::MaxControllers] = {0};
 84U32 RazerHydraDevice::RH_THUMB[RazerHydraConstants::MaxControllers] = {0};
 85U32 RazerHydraDevice::RH_START[RazerHydraConstants::MaxControllers] = {0};
 86U32 RazerHydraDevice::RH_1[RazerHydraConstants::MaxControllers] = {0};
 87U32 RazerHydraDevice::RH_2[RazerHydraConstants::MaxControllers] = {0};
 88U32 RazerHydraDevice::RH_3[RazerHydraConstants::MaxControllers] = {0};
 89U32 RazerHydraDevice::RH_4[RazerHydraConstants::MaxControllers] = {0};
 90U32 RazerHydraDevice::RH_FRAME = 0;
 91
 92RazerHydraDevice::RazerHydraDevice()
 93{
 94   // From IInputDevice
 95   dStrcpy(mName, "razerhydra", 30);
 96   mDeviceType = INPUTMGR->getNextDeviceType();
 97
 98   //
 99   mRazerHydraLib = NULL;
100   mEnabled = false;
101   mActive = false;
102   mNumberActiveControllers = 0;
103   mLastActiveCheck = 0;
104
105   for(U32 i=0; i<RazerHydraConstants::MaxControllers; ++i)
106   {
107      for(U32 j=0; j<2; ++j)
108      {
109         mDataBuffer[i][j] = new RazerHyrdaControllerData();
110      }
111
112      mPrevData[i] = mDataBuffer[i][0];
113   }
114
115   buildCodeTable();
116}
117
118RazerHydraDevice::~RazerHydraDevice()
119{
120   mRazerHydraLib = NULL;
121
122   // Delete the controller data buffers
123   for(U32 i=0; i<RazerHydraConstants::MaxControllers; ++i)
124   {
125      for(U32 j=0; j<2; ++j)
126      {
127         delete mDataBuffer[i][j];
128         mDataBuffer[i][j] = NULL;
129         mPrevData[i] = NULL;
130      }
131   }
132}
133
134void RazerHydraDevice::staticInit()
135{
136   Con::addVariable("pref::RazerHydra::EnableDevice", TypeBool, &smEnableDevice, 
137      "@brief If true, the Razer Hydra device will be enabled, if present.\n\n"
138      "@ingroup Game");
139
140   Con::addVariable("RazerHydra::ProcessWhenDocked", TypeBool, &smProcessWhenDocked, 
141      "@brief If true, events will still be sent when a controller is docked.\n\n"
142      "@ingroup Game");
143
144   Con::addVariable("RazerHydra::SeparatePositionEvents", TypeBool, &smSeparatePositionEvents, 
145      "@brief If true, separate position events will be sent for each component.\n\n"
146      "@ingroup Game");
147   Con::addVariable("RazerHydra::CombinedPositionEvents", TypeBool, &smCombinedPositionEvents, 
148      "@brief If true, one position event will be sent that includes one component per argument.\n\n"
149      "@ingroup Game");
150
151   Con::addVariable("RazerHydra::RotationAsAxisEvents", TypeBool, &smRotationAsAxisEvents, 
152      "@brief If true, broadcast controller rotation as axis events.\n\n"
153      "@ingroup Game");
154   Con::addVariable("RazerHydra::MaximumAxisAngle", TypeF32, &smMaximumAxisAngle, 
155      "@brief The maximum controller angle when used as an axis event as measured from a vector pointing straight up (in degrees).\n\n"
156      "Shoud range from 0 to 90 degrees.\n\n"
157      "@ingroup Game");
158
159   Con::addVariable("RazerHydra::GenerateWholeFrameEvents", TypeBool, &smGenerateWholeFrameEvents, 
160      "@brief Indicates that a whole frame event should be generated and frames should be buffered.\n\n"
161      "@ingroup Game");
162}
163
164void RazerHydraDevice::buildCodeTable()
165{
166   // Obtain all of the device codes
167   for(U32 i=0; i<RazerHydraConstants::MaxControllers; ++i)
168   {
169      RH_DOCKED[i] = INPUTMGR->getNextDeviceCode();
170
171      RH_POSX[i] = INPUTMGR->getNextDeviceCode();
172      RH_POSY[i] = INPUTMGR->getNextDeviceCode();
173      RH_POSZ[i] = INPUTMGR->getNextDeviceCode();
174
175      RH_POS[i] = INPUTMGR->getNextDeviceCode();
176
177      RH_ROT[i] = INPUTMGR->getNextDeviceCode();
178
179      RH_ROTAXISX[i] = INPUTMGR->getNextDeviceCode();
180      RH_ROTAXISY[i] = INPUTMGR->getNextDeviceCode();
181
182      RH_THUMBX[i] = INPUTMGR->getNextDeviceCode();
183      RH_THUMBY[i] = INPUTMGR->getNextDeviceCode();
184
185      RH_TRIGGER[i] = INPUTMGR->getNextDeviceCode();
186
187      RH_SHOULDER[i] = INPUTMGR->getNextDeviceCode();
188      RH_THUMB[i] = INPUTMGR->getNextDeviceCode();
189      RH_START[i] = INPUTMGR->getNextDeviceCode();
190      RH_1[i] = INPUTMGR->getNextDeviceCode();
191      RH_2[i] = INPUTMGR->getNextDeviceCode();
192      RH_3[i] = INPUTMGR->getNextDeviceCode();
193      RH_4[i] = INPUTMGR->getNextDeviceCode();
194   }
195
196   RH_FRAME = INPUTMGR->getNextDeviceCode();
197
198   // Build out the virtual map
199   char buffer[64];
200   for(U32 i=0; i<RazerHydraConstants::MaxControllers; ++i)
201   {
202      dSprintf(buffer, 64, "rh_docked%d", i);
203      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_DOCKED[i] );
204
205      dSprintf(buffer, 64, "rh_posx%d", i);
206      INPUTMGR->addVirtualMap( buffer, SI_FLOAT, RH_POSX[i] );
207      dSprintf(buffer, 64, "rh_posy%d", i);
208      INPUTMGR->addVirtualMap( buffer, SI_FLOAT, RH_POSY[i] );
209      dSprintf(buffer, 64, "rh_posz%d", i);
210      INPUTMGR->addVirtualMap( buffer, SI_FLOAT, RH_POSZ[i] );
211
212      dSprintf(buffer, 64, "rh_pos%d", i);
213      INPUTMGR->addVirtualMap( buffer, SI_POS, RH_POS[i] );
214
215      dSprintf(buffer, 64, "rh_rot%d", i);
216      INPUTMGR->addVirtualMap( buffer, SI_ROT, RH_ROT[i] );
217
218      dSprintf(buffer, 64, "rh_rotaxisx%d", i);
219      INPUTMGR->addVirtualMap( buffer, SI_AXIS, RH_ROTAXISX[i] );
220      dSprintf(buffer, 64, "rh_rotaxisy%d", i);
221      INPUTMGR->addVirtualMap( buffer, SI_AXIS, RH_ROTAXISY[i] );
222
223      dSprintf(buffer, 64, "rh_thumbx%d", i);
224      INPUTMGR->addVirtualMap( buffer, SI_AXIS, RH_THUMBX[i] );
225      dSprintf(buffer, 64, "rh_thumby%d", i);
226      INPUTMGR->addVirtualMap( buffer, SI_AXIS, RH_THUMBY[i] );
227
228      dSprintf(buffer, 64, "rh_trigger%d", i);
229      INPUTMGR->addVirtualMap( buffer, SI_AXIS, RH_TRIGGER[i] );
230
231      dSprintf(buffer, 64, "rh_shoulder%d", i);
232      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_SHOULDER[i] );
233
234      dSprintf(buffer, 64, "rh_thumb%d", i);
235      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_THUMB[i] );
236
237      dSprintf(buffer, 64, "rh_start%d", i);
238      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_START[i] );
239
240      dSprintf(buffer, 64, "rh_1button%d", i);
241      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_1[i] );
242      dSprintf(buffer, 64, "rh_2button%d", i);
243      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_2[i] );
244      dSprintf(buffer, 64, "rh_3button%d", i);
245      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_3[i] );
246      dSprintf(buffer, 64, "rh_4button%d", i);
247      INPUTMGR->addVirtualMap( buffer, SI_BUTTON, RH_4[i] );
248   }
249
250   AddInputVirtualMap(  rh_frame,      SI_INT,     RH_FRAME );
251}
252
253bool RazerHydraDevice::enable()
254{
255   // Start off with disabling the device if it is already enabled
256   disable();
257
258   // Dynamically load the Razer Hydra library and set up function pointers
259#ifdef LOG_INPUT
260   Input::log( "Enabling Razer Hydra...\n" );
261#endif
262
263   const char* dllName;
264#ifdef TORQUE_OS_WIN
265   #ifdef TORQUE_DEBUG
266      dllName = "sixensed.dll";
267   #else
268      dllName = "sixense.dll";
269   #endif
270#else
271   #ifdef LOG_INPUT
272      Input::log( "...platform not supported for Razer Hydra\n" );
273   #endif
274      return;
275#endif
276
277   mRazerHydraLib = OsLoadLibrary( dllName );
278   if(mRazerHydraLib)
279   {
280#ifdef LOG_INPUT
281      Input::log( "Razer Hydra library loaded.\n" );
282#endif
283      Con::printf("Razer Hydra Init:");
284
285      // Obtain library function pointers
286      mfnSixenseInit = (FN_SixenseInit) mRazerHydraLib->bind( "sixenseInit" );
287      mfnSixenseExit = (FN_SixenseExit) mRazerHydraLib->bind( "sixenseExit" );
288
289      mfnSixenseGetMaxBases = (FN_SixenseGetMaxBases) mRazerHydraLib->bind( "sixenseGetMaxBases" );
290      mfnSixenseSetActiveBase = (FN_SixenseSetActiveBase) mRazerHydraLib->bind( "sixenseSetActiveBase" );
291      mfnSixenseIsBaseConnected = (FN_SixenseIsBaseConnected) mRazerHydraLib->bind( "sixenseIsBaseConnected" );
292
293      mfnSixenseGetMaxControllers = (FN_SixenseGetMaxControllers) mRazerHydraLib->bind( "sixenseGetMaxControllers" );
294      mfnSixenseIsControllerEnabled = (FN_SixenseIsControllerEnabled) mRazerHydraLib->bind( "sixenseIsControllerEnabled" );
295      mfnSixenseGetNumActiveControllers = (FN_SixenseGetNumActiveControllers) mRazerHydraLib->bind( "sixenseGetNumActiveControllers" );
296
297      mfnSixenseGetHistorySize = (FN_SixenseGetHistorySize) mRazerHydraLib->bind( "sixenseGetHistorySize" );
298
299      mfnSixenseGetData = (FN_SixenseGetData) mRazerHydraLib->bind( "sixenseGetData" );
300      mfnSixenseGetAllData = (FN_SixenseGetAllData) mRazerHydraLib->bind( "sixenseGetAllData" );
301      mfnSixenseGetNewestData = (FN_SixenseGetNewestData) mRazerHydraLib->bind( "sixenseGetNewestData" );
302      mfnSixenseGetAllNewestData = (FN_SixenseGetAllNewestData) mRazerHydraLib->bind( "sixenseGetAllNewestData" );
303
304      mfnSixenseSetHemisphereTrackingMode = (FN_SixenseSetHemisphereTrackingMode) mRazerHydraLib->bind( "sixenseSetHemisphereTrackingMode" );
305      mfnSixenseGetHemisphereTrackingMode = (FN_SixenseGetHemisphereTrackingMode) mRazerHydraLib->bind( "sixenseGetHemisphereTrackingMode" );
306
307      mfnSixenseAutoEnableHemisphereTracking = (FN_SixenseAutoEnableHemisphereTracking) mRazerHydraLib->bind( "sixenseAutoEnableHemisphereTracking" );
308
309      mfnSixenseSetHighPriorityBindingEnabled = (FN_SixenseSetHighPriorityBindingEnabled) mRazerHydraLib->bind( "sixenseSetHighPriorityBindingEnabled" );
310      mfnSixenseGetHighPriorityBindingEnabled = (FN_SixenseGetHighPriorityBindingEnabled) mRazerHydraLib->bind( "sixenseGetHighPriorityBindingEnabled" );
311
312      mfnSixenseTriggerVibration = (FN_SixenseTriggerVibration) mRazerHydraLib->bind( "sixenseTriggerVibration" );
313
314      mfnSixenseSetFilterEnabled = (FN_SixenseSetFilterEnabled) mRazerHydraLib->bind( "sixenseSetFilterEnabled" );
315      mfnSixenseGetFilterEnabled = (FN_SixenseGetFilterEnabled) mRazerHydraLib->bind( "sixenseGetFilterEnabled" );
316
317      mfnSixenseSetFilterParams = (FN_SixenseSetFilterParams) mRazerHydraLib->bind( "sixenseSetFilterParams" );
318      mfnSixenseGetFilterParams = (FN_SixenseGetFilterParams) mRazerHydraLib->bind( "sixenseGetFilterParams" );
319
320      mfnSixenseSetBaseColor = (FN_SixenseSetBaseColor) mRazerHydraLib->bind( "sixenseSetBaseColor" );
321      mfnSixenseGetBaseColor = (FN_SixenseGetBaseColor) mRazerHydraLib->bind( "sixenseGetBaseColor" );
322
323      // Init the sixense library
324      S32 result = mfnSixenseInit();
325      if(result == SIXENSE_FAILURE)
326      {
327         // Problem with starting the library
328         Con::printf("   Sixense library startup failure");
329         mRazerHydraLib = NULL;
330
331         mEnabled = false;
332         mActive = false;
333
334         return false;
335      }
336
337      // Retrieve some information about the Hydra
338      mMaximumBases = mfnSixenseGetMaxBases();
339      Con::printf("   Max bases: %d", mMaximumBases);
340      mMaximumControllers = mfnSixenseGetMaxControllers();
341      Con::printf("   Max controllers: %d", mMaximumControllers);
342
343      mEnabled = true;
344
345      if(checkControllers())
346      {
347         Con::printf("   Active controllers: %d", mNumberActiveControllers);
348         mActive = true;
349      }
350      else
351      {
352         Con::printf("   Controllers not yet found.  Starting to poll.");
353         mLastActiveCheck = Platform::getRealMilliseconds();
354         mActive = false;
355      }
356
357      Con::printf("");
358
359      return true;
360   }
361   else
362   {
363#ifdef LOG_INPUT
364      Input::log( "Razer Hydra library was not found.\n" );
365#endif
366      Con::errorf("Razer Hydra library was not found.");
367
368      mEnabled = false;
369      mActive = false;
370   }
371
372   return false;
373}
374
375void RazerHydraDevice::disable()
376{
377   if(mRazerHydraLib)
378   {
379      // Shutdown the sixense library
380      mfnSixenseExit();
381
382      mRazerHydraLib = NULL;
383   }
384
385   mEnabled = false;
386}
387
388bool RazerHydraDevice::process()
389{
390   if(!mEnabled)
391      return false;
392
393   //Con::printf("RazerHydraDevice::process()");
394
395   if(!mActive)
396   {
397      // Only perform a check on a periodic basis
398      S32 time = Platform::getRealMilliseconds();
399      if((time - mLastActiveCheck) < RazerHydraConstants::HydraActiveCheckFreq)
400         return false;
401
402      mLastActiveCheck = time;
403
404      if(checkControllers())
405      {
406         Con::printf("Razer Hydra now has %d active controllers", mNumberActiveControllers);
407         mActive = true;
408      }
409      else
410      {
411         return false;
412      }
413   }
414   else if(!checkControllers())
415   {
416      // We no longer have active controllers
417      Con::printf("Razer Hydra now has NO active controllers");
418      mLastActiveCheck = Platform::getRealMilliseconds();
419      mActive = false;
420      return false;
421   }
422
423   //Build the maximum axis angle to be passed into the RazerHyrdaControllerData::setData()
424   F32 maxAxisRadius = mSin(mDegToRad(smMaximumAxisAngle));
425
426   // Get the controller data
427   mfnSixenseSetActiveBase(RazerHydraConstants::DefaultHydraBase);
428   sixenseAllControllerData acd;
429   mfnSixenseGetAllNewestData(&acd);
430
431   // Store the current data from each controller and compare with previous data
432   U32 diff[RazerHydraConstants::MaxControllers];
433   U32 metaDiff[RazerHydraConstants::MaxControllers];
434   RazerHyrdaControllerData* currentBuffer[RazerHydraConstants::MaxControllers];
435   for(U32 i=0; i<RazerHydraConstants::MaxControllers; ++i)
436   {
437      currentBuffer[i] = (mPrevData[i] == mDataBuffer[i][0]) ? mDataBuffer[i][1] : mDataBuffer[i][0];
438      currentBuffer[i]->setData(acd.controllers[i], maxAxisRadius);
439      diff[i] = mPrevData[i]->compare(currentBuffer[i]);
440      metaDiff[i] = mPrevData[i]->compareMeta(currentBuffer[i]);
441   }
442
443   // Update the previous data pointers.  We do this here in case someone calls our
444   // console functions during one of the input events below.
445   mPrevData[0] = currentBuffer[0];
446   mPrevData[1] = currentBuffer[1];
447
448   // Process each controller's meta data.
449   for(U32 i=0; i<RazerHydraConstants::MaxControllers; ++i)
450   {
451      // Docked
452      if(metaDiff[i] != RazerHyrdaControllerData::METADIFF_NONE)
453      {
454         INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_DOCKED[i], currentBuffer[i]->mIsDocked ? SI_MAKE : SI_BREAK, currentBuffer[i]->mIsDocked ? 1.0f : 0.0f);
455      }
456
457      // Position, rotation and buttons
458      if(diff[i] != RazerHyrdaControllerData::DIFF_NONE && (!currentBuffer[i]->mIsDocked || smProcessWhenDocked && currentBuffer[i]->mIsDocked))
459      {
460         // Position
461         if(smSeparatePositionEvents)
462         {
463            if(diff[i] & RazerHyrdaControllerData::DIFF_POSX)
464               INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_FLOAT, RH_POSX[i], SI_MOVE, currentBuffer[i]->mPos[0]);
465            if(diff[i] & RazerHyrdaControllerData::DIFF_POSY)
466               INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_FLOAT, RH_POSY[i], SI_MOVE, currentBuffer[i]->mPos[1]);
467            if(diff[i] & RazerHyrdaControllerData::DIFF_POSZ)
468               INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_FLOAT, RH_POSZ[i], SI_MOVE, currentBuffer[i]->mPos[2]);
469         }
470         if(smCombinedPositionEvents)
471         {
472            if(diff[i] & RazerHyrdaControllerData::DIFF_POSX || diff[i] & RazerHyrdaControllerData::DIFF_POSY || diff[i] & RazerHyrdaControllerData::DIFF_POSZ)
473            {
474               INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_POS, RH_POS[i], SI_MOVE, currentBuffer[i]->mPosPoint);
475            }
476         }
477
478         // Rotation
479         if(diff[i] & RazerHyrdaControllerData::DIFF_ROT)
480            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_ROT, RH_ROT[i], SI_MOVE, currentBuffer[i]->mRotQuat);
481
482         // Thumb stick
483         if(diff[i] & RazerHyrdaControllerData::DIFF_AXISX)
484            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_AXIS, RH_THUMBX[i], SI_MOVE, currentBuffer[i]->mThumbStick[0]);
485         if(diff[i] & RazerHyrdaControllerData::DIFF_AXISY)
486            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_AXIS, RH_THUMBY[i], SI_MOVE, currentBuffer[i]->mThumbStick[1]);
487
488         // Trigger
489         if(diff[i] & RazerHyrdaControllerData::DIFF_TRIGGER)
490            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_AXIS, RH_TRIGGER[i], SI_MOVE, currentBuffer[i]->mTrigger);
491
492         // Shoulder button
493         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON_SHOULDER)
494            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_SHOULDER[i], currentBuffer[i]->mShoulder ? SI_MAKE : SI_BREAK, currentBuffer[i]->mShoulder ? 1.0f : 0.0f);
495
496         // Thumb button
497         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON_THUMB)
498            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_THUMB[i], currentBuffer[i]->mThumb ? SI_MAKE : SI_BREAK, currentBuffer[i]->mThumb ? 1.0f : 0.0f);
499
500         // Start button
501         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON_START)
502            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_START[i], currentBuffer[i]->mStart ? SI_MAKE : SI_BREAK, currentBuffer[i]->mStart ? 1.0f : 0.0f);
503
504         // Button 1
505         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON1)
506            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_1[i], currentBuffer[i]->mButton1 ? SI_MAKE : SI_BREAK, currentBuffer[i]->mButton1 ? 1.0f : 0.0f);
507
508         // Button 2
509         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON2)
510            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_2[i], currentBuffer[i]->mButton2 ? SI_MAKE : SI_BREAK, currentBuffer[i]->mButton2 ? 1.0f : 0.0f);
511
512         // Button 3
513         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON3)
514            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_3[i], currentBuffer[i]->mButton3 ? SI_MAKE : SI_BREAK, currentBuffer[i]->mButton3 ? 1.0f : 0.0f);
515
516         // Button 4
517         if(diff[i] & RazerHyrdaControllerData::DIFF_BUTTON4)
518            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_BUTTON, RH_4[i], currentBuffer[i]->mButton4 ? SI_MAKE : SI_BREAK, currentBuffer[i]->mButton4 ? 1.0f : 0.0f);
519      }
520
521      // Left rotation as axis.  Done here as we still need to send events even when docked.
522      if(smRotationAsAxisEvents && diff[i] & RazerHyrdaControllerData::DIFF_ROTAXIS)
523      {
524         if(diff[i] & RazerHyrdaControllerData::DIFF_ROTAXISX)
525            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_AXIS, RH_ROTAXISX[i], SI_MOVE, currentBuffer[i]->mRotAxis.x);
526         if(diff[i] & RazerHyrdaControllerData::DIFF_ROTAXISY)
527            INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_AXIS, RH_ROTAXISY[i], SI_MOVE, currentBuffer[i]->mRotAxis.y);
528      }
529   }
530
531   // Send out whole frame event, but only if the special frame group is defined
532   if(smGenerateWholeFrameEvents && RazerHydraFrameStore::isFrameGroupDefined())
533   {
534      S32 id = RAZERHYDRAFS->generateNewFrame(acd, maxAxisRadius);
535      if(id != 0)
536      {
537         INPUTMGR->buildInputEvent(mDeviceType, RazerHydraConstants::DefaultHydraBase, SI_INT, RH_FRAME, SI_VALUE, id);
538      }
539   }
540
541   return true;
542}
543
544bool RazerHydraDevice::checkControllers()
545{
546   if(!mEnabled)
547      return false;
548
549   bool hasBase = (mfnSixenseIsBaseConnected(RazerHydraConstants::DefaultHydraBase) == 1);
550   if(!hasBase)
551   {
552      mNumberActiveControllers = 0;
553      return false;
554   }
555
556   mfnSixenseSetActiveBase(RazerHydraConstants::DefaultHydraBase);
557   mNumberActiveControllers = mfnSixenseGetNumActiveControllers();
558   if(mNumberActiveControllers < 1)
559      return false;
560
561   return true;
562}
563
564bool RazerHydraDevice::isControllerDocked(U32 controller)
565{
566   if(!mEnabled || !mActive)
567      return true;
568
569   if(controller >= RazerHydraConstants::MaxControllers)
570      return true;
571
572   // Results are based on the last retrieved data from the device
573   return mPrevData[controller]->mIsDocked || !mPrevData[controller]->mDataSet;
574}
575
576const Point3F& RazerHydraDevice::getControllerPosition(U32 controller)
577{
578   if(!mEnabled || !mActive)
579      return Point3F::Zero;
580
581   if(controller >= RazerHydraConstants::MaxControllers)
582      return Point3F::Zero;
583
584   // Results are based on the last retrieved data from the device
585   return mPrevData[controller]->mPosPoint;
586}
587
588const QuatF& RazerHydraDevice::getControllerRotation(U32 controller)
589{
590   if(!mEnabled || !mActive)
591      return QuatF::Identity;
592
593   if(controller >= RazerHydraConstants::MaxControllers)
594      return QuatF::Identity;
595
596   // Results are based on the last retrieved data from the device
597   return mPrevData[controller]->mRotQuat;
598}
599
600//-----------------------------------------------------------------------------
601
602DefineEngineFunction(isRazerHydraActive, bool, (),,
603   "@brief Used to determine if the Razer Hydra input device active\n\n"
604
605   "The Razer Hydra input device is considered active when the support library has been "
606   "loaded and the controller has been found.\n\n"
607
608   "@return True if the Razer Hydra input device is active.\n"
609
610   "@ingroup Game")
611{
612   if(!ManagedSingleton<RazerHydraDevice>::instanceOrNull())
613   {
614      return false;
615   }
616
617   return RAZERHYDRADEV->isActive();
618}
619
620DefineEngineFunction(isRazerHydraControllerDocked, bool, (S32 controller),,
621   "@brief Used to determine if the given Razer Hydra controller is docked\n\n"
622
623   "@param controller Controller number to check.\n"
624
625   "@return True if the given Razer Hydra controller is docked.  Also returns true if "
626   "the input device is not found or active.\n"
627
628   "@ingroup Game")
629{
630   if(!ManagedSingleton<RazerHydraDevice>::instanceOrNull())
631   {
632      return true;
633   }
634
635   return RAZERHYDRADEV->isControllerDocked(controller);
636}
637
638DefineEngineFunction(getRazerHydraControllerPos, Point3F, (S32 controller),,
639   "@brief Get the given Razer Hydra controller's last position\n\n"
640
641   "@param controller Controller number to check.\n"
642
643   "@return A Point3F containing the last known position.\n"
644
645   "@ingroup Game")
646{
647   if(!ManagedSingleton<RazerHydraDevice>::instanceOrNull())
648   {
649      return Point3F::Zero;
650   }
651
652   return RAZERHYDRADEV->getControllerPosition(controller);
653}
654
655DefineEngineFunction(getRazerHydraControllerRot, AngAxisF, (S32 controller),,
656   "@brief Get the given Razer Hydra controller's last rotation\n\n"
657
658   "@param controller Controller number to check.\n"
659
660   "@return A AngAxisF containing the last known rotation.\n"
661
662   "@ingroup Game")
663{
664   AngAxisF aa(Point3F(0, 0, 1), 0);
665
666   if(!ManagedSingleton<RazerHydraDevice>::instanceOrNull())
667   {
668      return aa;
669   }
670
671   const QuatF& qa = RAZERHYDRADEV->getControllerRotation(controller);
672   aa.set(qa);
673   aa.axis.normalize();
674
675   return aa;
676}
677
678DefineEngineFunction(getRazerHydraControllerTransform, TransformF, (S32 controller),,
679   "@brief Get the given Razer Hydra controller's last transform\n\n"
680
681   "@param controller Controller number to check.\n"
682
683   "@return A TransformF containing the last known transform.\n"
684
685   "@ingroup Game")
686{
687   TransformF trans;
688
689   if(!ManagedSingleton<RazerHydraDevice>::instanceOrNull())
690   {
691      return trans;
692   }
693
694   const Point3F& pos = RAZERHYDRADEV->getControllerPosition(controller);
695   const QuatF& qa = RAZERHYDRADEV->getControllerRotation(controller);
696
697   AngAxisF aa(qa);
698   aa.axis.normalize();
699   trans.set(pos, aa);
700
701   return trans;
702}
703