bool FlightCameraManipulatorHIDSync::updateFrame( float dt )
        {
          if (!m_hid)
          {
            return false;
          }

          setCursorPosition( m_hid->getValue<dp::math::Vec2i>( PID_Pos ) );
          setWheelTicks( m_hid->getValue<int>( PID_Wheel ) );

          bool forward = m_hid->getValue<bool>( PID_Forward );
          bool reverse = m_hid->getValue<bool>( PID_Reverse );
  
          // set speed based on wheel and buttons
          m_speed  += getWheelTicksDelta() * 0.1f;
          if( m_speed < 0.f )
          {
            m_speed = 0.f;
          }

          if( forward || reverse )
          {
            // set forward, reverse here
            FlightCameraManipulator::setSpeed( forward ? m_speed : -m_speed );
          }
          else
          {
            // stopped
            FlightCameraManipulator::setSpeed( 0.f );
          }

          return FlightCameraManipulator::updateFrame( dt );
        }
        bool TrackballCameraManipulatorHIDSync::updateFrame( float dt )
        {
          if (!m_hid)
          {
            return false;
          }

          if ( m_hid->getValue<bool>( PID_Shift ) )
          {
            lockMajorAxis();
          }
          else
          {
            unlockMajorAxis();
          }

          bool orbit = m_hid->getValue<bool>( PID_Orbit );
          bool pan = m_hid->getValue<bool>( PID_Pan );
          bool control = m_hid->getValue<bool>( PID_Control );
          bool shift = m_hid->getValue<bool>( PID_Shift );
          bool hotspot = m_hid->getValue<bool>( PID_HotSpot );
          bool hotspot_depth = m_hid->getValue<bool>( PID_HotSpot_Depth );

          setCursorPosition( m_hid->getValue<dp::math::Vec2i>( PID_Pos ) );
          setWheelTicks( m_hid->getValue<int>( PID_Wheel ) );

          TrackballCameraManipulator::Mode mode = TrackballCameraManipulator::Mode::NONE;
          if ( hotspot )
          {
            mode = TrackballCameraManipulator::Mode::LOOKAT;
          }
          else if ( hotspot_depth)
          {
            mode = TrackballCameraManipulator::Mode::LOOKAT_DEPTH;
          }
          else 
          {
            if ( orbit && pan && control && shift )  // vertigo
            {
              mode = TrackballCameraManipulator::Mode::ZOOM_DOLLY;
            }
            if ( orbit && pan && control && !shift )  // zoom
            {
              mode = TrackballCameraManipulator::Mode::ZOOM_FOV;
            }
            if ( orbit && pan && !control && !shift )  // dolly
            {
              mode = TrackballCameraManipulator::Mode::DOLLY;
            }
            else if ( orbit && !pan && !control && !shift )
            {
              mode = TrackballCameraManipulator::Mode::ORBIT;
            }
            else if ( !orbit && pan && !control && !shift )
            {
              mode = TrackballCameraManipulator::Mode::PAN;
            }
            else if ( !orbit && pan && control && !shift )
            {
              mode = TrackballCameraManipulator::Mode::ROLL_Z;
            }
            else if ( orbit && !pan && control && !shift )
            {
              mode = TrackballCameraManipulator::Mode::ROTATE_XY;
            }
          }

          setMode( mode );

          return TrackballCameraManipulator::updateFrame( dt );
        }
        bool WalkCameraManipulatorHIDSync::updateFrame( float dt )
        {
          if (!m_hid)
          {
            return false;
          }

          dp::math::Vec2i pos = m_hid->getValue<dp::math::Vec2i>( PID_Pos );
          if( getReverseMouse() && getRenderTarget() )
          {
            pos[1] = getRenderTarget()->getHeight() - pos[1] - 1;
          }

          setCursorPosition( pos );

          setWheelTicks( m_hid->getValue<int>( PID_Wheel ) );

          // set height above terrain
          if( m_hid->getValue<bool>( PID_KeyUp ) )
          {
            setCameraHeightAboveTerrain( getCameraHeightAboveTerrain() + m_sensitivity[1] );
          }
          else if( m_hid->getValue<bool>( PID_KeyDown ) )
          {
            float hat = getCameraHeightAboveTerrain() - m_sensitivity[1];
            if( hat < 0.f )
            {
              hat = 0.f;
            }

            setCameraHeightAboveTerrain( hat );
          }

          bool forward = m_hid->getValue<bool>( PID_ButtonForward ) ||
                         m_hid->getValue<bool>( PID_KeyForward );
          bool reverse = m_hid->getValue<bool>( PID_ButtonReverse ) ||
                         m_hid->getValue<bool>( PID_KeyReverse );

          bool strafeLeft  = m_hid->getValue<bool>( PID_KeyStrafeLeft );
          bool strafeRight = m_hid->getValue<bool>( PID_KeyStrafeRight );

          float run = m_hid->getValue<bool>( PID_KeyRun ) ? 2.0f : 1.0f;

          unsigned int mode = MODE_FREELOOK;
  
          // update speed based on wheel
          m_speed += getWheelTicksDelta() * 0.1f;
          if( m_speed < 0.f )
          {
            m_speed = 0.f;
          }

          if( forward || reverse )
          {
            // set forward, reverse here
            float speed = forward ? m_speed : -m_speed;
            WalkCameraManipulator::setSpeed( speed * run );

            mode |= MODE_WALK;
          }

          if( strafeLeft )
          {
            WalkCameraManipulator::setSpeed( m_speed * run );
            mode |= MODE_STRAFE_LEFT;
          }
          else if( strafeRight )
          {
            WalkCameraManipulator::setSpeed( m_speed * run );
            mode |= MODE_STRAFE_RIGHT;
          }

          // if not moving, set speed to 0
          if( mode == MODE_FREELOOK )
          {
            // stopped
            WalkCameraManipulator::setSpeed( 0.f );
          }

          setMode( mode );

          return WalkCameraManipulator::updateFrame( dt );
        }