Exemplo n.º 1
0
// The hydra_monitor is a companion program which can display overlay prompts for us
// and tell us the pose of the HMD at the moment we want to calibrate.
void CServerDriver_Hydra::LaunchHydraMonitor( const char * pchDriverInstallDir )
{
	if ( m_bLaunchedHydraMonitor )
		return;

	m_bLaunchedHydraMonitor = true;

	std::ostringstream ss;

	ss << pchDriverInstallDir << "\\bin\\";
#if defined( _WIN64 )
	ss << "win64";
#elif defined( _WIN32 )
	ss << "win32";
#else
#warning Do not know how to launch hydra_monitor
#endif
	DriverLog( "hydra_monitor path: %s\n", ss.str().c_str() );

#if defined( _WIN32 )
	STARTUPINFOA sInfoProcess = { 0 };
	sInfoProcess.cb = sizeof( STARTUPINFOW );
	PROCESS_INFORMATION pInfoStartedProcess;
	BOOL okay = CreateProcessA( (ss.str() + "\\hydra_monitor.exe").c_str(), NULL, NULL, NULL, FALSE, 0, NULL, ss.str().c_str(), &sInfoProcess, &pInfoStartedProcess );
	DriverLog( "start hydra_monitor okay: %d %08x\n", okay, GetLastError() );
#else
#warning Do not know how to launch hydra_monitor
#endif
}
// The leap_monitor is a companion program which will tell us the pose of the HMD.
void CServerDriver_Leap::LaunchLeapMonitor( const char * pchDriverInstallDir )
{
    if ( m_bLaunchedLeapMonitor )
        return;

    DriverLog("CServerDriver_Leap::LaunchLeapMonitor()\n");

    m_bLaunchedLeapMonitor = true;

    std::ostringstream ss;

    ss << pchDriverInstallDir << "\\bin\\";
#if defined( _WIN64 )
    ss << "win64";
#elif defined( _WIN32 )
    ss << "win32";
#else
#error Do not know how to launch leap_monitor
#endif
    DriverLog( "leap_monitor path: %s\n", ss.str().c_str() );

#if defined( _WIN32 )
    STARTUPINFOA sInfoProcess = { 0 };
    sInfoProcess.cb = sizeof(STARTUPINFOW);
//    sInfoProcess.dwFlags = STARTF_USESHOWWINDOW;
//    sInfoProcess.wShowWindow = SW_SHOWDEFAULT;
    BOOL okay = CreateProcessA( (ss.str() + "\\leap_monitor.exe").c_str(), NULL, NULL, NULL, FALSE, 0, NULL, ss.str().c_str(), &sInfoProcess, &m_pInfoStartedProcess );
    DriverLog( "start leap_monitor okay: %d %08x\n", okay, GetLastError() );
#else
#error Do not know how to launch leap_monitor
#endif
}
vr::EVRInitError CClientDriver_Leap::Init( vr::IDriverLog * pDriverLog, vr::IClientDriverHost * pDriverHost, const char * pchUserDriverConfigDir, const char * pchDriverInstallDir )
{
    InitDriverLog( pDriverLog );
    DriverLog("CClientDriver_Leap::Init()\n");
    m_pDriverHost = pDriverHost;
    return vr::VRInitError_None;
}
CLeapHmdLatest::CLeapHmdLatest( vr::IServerDriverHost * pDriverHost, int base, int n )
    : m_pDriverHost( pDriverHost )
    , m_nBase( base )
    , m_nId( n )
    , m_bCalibrated( true )
    , m_pAlignmentPartner( NULL )
    , m_unSteamVRTrackedDeviceId( vr::k_unTrackedDeviceIndexInvalid )
{
    DriverLog("CLeapHmdLatest::CLeapHmdLatest(base=%d, n=%d)\n", base, n);
    
    memset(m_hmdPos, 0, sizeof(m_hmdPos));

    char buf[256];
    GenerateSerialNumber( buf, sizeof( buf ), base, n );
    m_strSerialNumber = buf;

    memset( &m_ControllerState, 0, sizeof( m_ControllerState ) );
    memset( &m_Pose, 0, sizeof( m_Pose ) );
    m_Pose.result = vr::TrackingResult_Uninitialized;

    m_firmware_revision = 0x0001;
    m_hardware_revision = 0x0001;

    // Load config from steamvr.vrsettings
    vr::IVRSettings *settings_;
    settings_ = m_pDriverHost->GetSettings(vr::IVRSettings_Version);

    // Load rendermodel
    char tmp_[256];
    settings_->GetString("leap", (m_nId ==  LEFT_CONTROLLER) ? "renderModel_lefthand" : (m_nId == RIGHT_CONTROLLER) ? "renderModel_righthand" : "renderModel", tmp_, sizeof(tmp_), "vr_controller_vive_1_5");
    m_strRenderModel = tmp_;

    // set the 
    m_gripAngleOffset = settings_->GetFloat("leap", (m_nId == LEFT_CONTROLLER) ? "gripAngleOffset_lefthand" : (m_nId == RIGHT_CONTROLLER) ? "gripAngleOffset_righthand" : "gripAngleOffset", 0.0);
}
void CServerDriver_Leap::Cleanup()
{
    DriverLog("CServerDriver_Leap::Cleanup()\n");

    // send a termination message to the leap monitor companion application
    if (m_bLaunchedLeapMonitor)
    {
        // Ask leap_monitor to shut down.
        PostThreadMessage(m_pInfoStartedProcess.dwThreadId, WM_QUIT, 0, 0);
        m_bLaunchedLeapMonitor = false;
    }

    // clean up our Leap::Controller object
    if (m_Controller)
    {
        m_Controller->removeListener(*this);
        delete m_Controller;
        m_Controller = NULL;
    }

    // clean up any controller objects we've created
    for (auto it = m_vecControllers.begin(); it != m_vecControllers.end(); ++it)
        delete (*it);
    m_vecControllers.clear();
}
Exemplo n.º 6
0
void CServerDriver_Hydra::ScanForNewControllers( bool bNotifyServer )
{
	for ( int base = 0; base < sixenseGetMaxBases(); ++base )
	{
		if ( sixenseIsBaseConnected( base ) )
		{
			sixenseSetActiveBase( base );
			for ( int i = 0; i < sixenseGetMaxControllers(); ++i )
			{
				if ( sixenseIsControllerEnabled( i ) )
				{
					char buf[256];
					GenerateSerialNumber( buf, sizeof( buf ), base, i );
					scope_lock lock( m_Mutex );
					if ( !FindTrackedDeviceDriver( buf, vr::ITrackedDeviceServerDriver_Version ) )
					{
						DriverLog( "added new device %s\n", buf );
						m_vecControllers.push_back( new CHydraHmdLatest( m_pDriverHost, base, i ) );
						if ( bNotifyServer && m_pDriverHost )
						{
							m_pDriverHost->TrackedDeviceAdded( m_vecControllers.back()->GetSerialNumber() );
						}
					}
				}
			}
		}
	}
}
/**
 * Called when a Leap Motion controller is plugged in, unplugged, or the device changes state.
 *
 * State changes include entering or leaving robust mode and low resource mode.
 * Note that there is no direct way to query whether the device is in these modes,
 * although you can use Controller::isLightingBad() to check if there are environmental
 * IR lighting problems.
 *
 * \include Listener_onDeviceChange.txt
 *
 * @param controller The Controller object invoking this callback function.
 * @since 1.2
 */
void CServerDriver_Leap::onDeviceChange(const Controller&controller)
{
    DriverLog("CServerDriver_Leap::onDeviceChange()\n");

    if (controller.isConnected())
    {
        bool backgroundModeAllowed = controller.config().getInt32("background_app_mode") == 2;
        if (!backgroundModeAllowed) {
            // TODO: Show dialog to request permission to allow background mode apps
            bool userPermission = true;
            if (userPermission) {
                controller.config().setInt32("background_app_mode", 2);
                controller.config().save();
            }
        }

        controller.setPolicy(Leap::Controller::POLICY_OPTIMIZE_HMD);
        controller.setPolicy(Leap::Controller::POLICY_BACKGROUND_FRAMES);

        // make sure we always get background frames even when we lose the focus to another
        // Leap-enabled application
        controller.setPolicy((Leap::Controller::PolicyFlag)(15));

        // allow other background applications to receive frames even when SteamVR has the focus.
        controller.setPolicy((Leap::Controller::PolicyFlag)(23));

        ScanForNewControllers(true);
    }
    else
    {
        for (auto it = m_vecControllers.begin(); it != m_vecControllers.end(); ++it)
            delete (*it);
        m_vecControllers.clear();
    }
}
Exemplo n.º 8
0
vr::EVRInitError CHydraHmdLatest::Activate( uint32_t unObjectId )
{
	DriverLog( "CHydraHmdLatest::Activate: %s is object id %d\n", GetSerialNumber(), unObjectId );
	m_unSteamVRTrackedDeviceId = unObjectId;

	g_ServerTrackedDeviceProvider.LaunchHydraMonitor();

	return vr::VRInitError_None;
}
vr::EVRInitError CServerDriver_Leap::Init( vr::IDriverLog * pDriverLog, vr::IServerDriverHost * pDriverHost, const char * pchUserDriverConfigDir, const char * pchDriverInstallDir )
{
    InitDriverLog( pDriverLog );
    DriverLog("CServerDriver_Leap::Init()\n");

    m_pDriverHost = pDriverHost;
    m_strDriverInstallDir = pchDriverInstallDir;

    m_Controller = new Controller;

    Controller &controller = *m_Controller;

    m_Controller->addListener(*this);

    return vr::VRInitError_None;
}
Exemplo n.º 10
0
vr::ITrackedDeviceServerDriver * CServerDriver_Hydra::GetTrackedDeviceDriver( uint32_t unWhich, const char *pchInterfaceVersion )
{
	// don't return anything if that's not the interface version we have
	if ( 0 != stricmp( pchInterfaceVersion, vr::ITrackedDeviceServerDriver_Version ) )
	{
		DriverLog( "FindTrackedDeviceDriver for version %s, which we don't support.\n",
			pchInterfaceVersion );
		return NULL;
	}

	scope_lock lock( m_Mutex );

	if ( unWhich < m_vecControllers.size() )
		return m_vecControllers[unWhich];

	return nullptr;
}
void CServerDriver_Leap::ScanForNewControllers( bool bNotifyServer )
{
    while (m_vecControllers.size() < 2)
    {
        char buf[256];
        int base = 0;
        int i = m_vecControllers.size();
        GenerateSerialNumber( buf, sizeof( buf ), base, i );
        if ( !FindTrackedDeviceDriver( buf ) )
        {
            DriverLog( "added new device %s\n", buf );
            m_vecControllers.push_back( new CLeapHmdLatest( m_pDriverHost, base, i ) );
            if ( bNotifyServer && m_pDriverHost )
            {
                m_pDriverHost->TrackedDeviceAdded( m_vecControllers.back()->GetSerialNumber() );
            }
        }
    }
}
Exemplo n.º 12
0
vr::ITrackedDeviceServerDriver * CServerDriver_Hydra::FindTrackedDeviceDriver( const char * pchId, const char *pchInterfaceVersion )
{
	// don't return anything if that's not the interface version we have
	if ( 0 != stricmp( pchInterfaceVersion, vr::ITrackedDeviceServerDriver_Version ) )
	{
		DriverLog( "FindTrackedDeviceDriver for version %s, which we don't support.\n",
			pchInterfaceVersion );
		return NULL;
	}

	scope_lock lock( m_Mutex );

	for ( auto it = m_vecControllers.begin(); it != m_vecControllers.end(); ++it )
	{
		if ( 0 == strcmp( ( *it )->GetSerialNumber(), pchId ) )
		{
			return *it;
		}
	}
	return nullptr;
}
/**
 * Called if the Leap Motion daemon/service disconnects from your application Controller.
 *
 * Normally, this callback is not invoked. It is only called if some external event
 * or problem shuts down the service or otherwise interrupts the connection.
 *
 * \include Listener_onServiceDisconnect.txt
 *
 * @param controller The Controller object invoking this callback function.
 * @since 1.2
 */
void CServerDriver_Leap::onServiceDisconnect(const Controller&controller)
{
    DriverLog("CServerDriver_Leap::onServiceDisconnect()\n");
}
/**
 * Called when a Leap Motion controller device is plugged into the client
 * computer, but fails to operate properly.
 *
 * Get the list containing all failed devices using Controller::failedDevices().
 * The members of this list provide the device pnpID and reason for failure.
 *
 * \include Listener_onDeviceFailure.txt
 *
 * @param controller The Controller object invoking this callback function.
 * @since 3.0
 */
void CServerDriver_Leap::onDeviceFailure(const Controller&controller)
{
    DriverLog("CServerDriver_Leap::onDeviceFailure()\n");
}
/**
 * Called when the service emits a log message to report an error, warning, or
 * status change.
 *
 * Log message text is provided as ASCII-encoded english.
 *
 * @param controller The Controller object invoking this callback function.
 * @param severity The severity of the error, if known.
 * @param timestamp The timestamp of the error in microseconds.
 * (Use Controller::now() - timestamp to compute the age of the message.)
 * @param msg The log message.
 * @since 3.0
 */
void CServerDriver_Leap::onLogMessage(const Controller&controller, MessageSeverity severity, int64_t timestamp, const char* msg)
{
    DriverLog("CServerDriver_Leap::onLogMessage(%d): %s\n", (int)severity, msg);
}
CLeapHmdLatest::~CLeapHmdLatest()
{
    DriverLog("CLeapHmdLatest::~CLeapHmdLatest(base=%d, n=%d)\n", m_nBase, m_nId);
}
void CLeapHmdLatest::PowerOff()
{
    DriverLog("CLeapHmdLatest::PowerOff()\n");
    // FIXME Implement
}
CServerDriver_Leap::~CServerDriver_Leap()
{
    DriverLog("CServerDriver_Leap::~CServerDriver_Leap()\n");
    Cleanup();
}
void CClientDriver_Leap::Cleanup()
{
    DriverLog("CClientDriver_Leap::Cleanup()\n");
}
void CServerDriver_Leap::EnterStandby()
{
    DriverLog("CServerDriver_Leap::EnterStandby()\n");
}
/**
 * Called when the Leap Motion service is paused or resumed or when a
 * controller policy is changed.
 *
 * The service can change states because the computer user changes settings
 * in the Leap Motion Control Panel application or because an application
 * connected to the service triggers a change. Any application can pause or
 * unpause the service, but only runtime policy changes you make apply to your
 * own application.
 *
 * \include Listener_onServiceChange.txt
 *
 * You can query the pause state of the controller with Controller::isPaused().
 * You can check the state of those policies you are interested in with
 * Controller::isPolicySet().
 *
 * @param controller The Controller object invoking this callback function.
 * @since 3.0
 */
void CServerDriver_Leap::onServiceChange(const Controller&controller)
{
    DriverLog("CServerDriver_Leap::onServiceChange()\n");
}
void CServerDriver_Leap::LeaveStandby()
{
    DriverLog("CServerDriver_Leap::LeaveStandby()\n");
}
Exemplo n.º 23
0
void CHydraHmdLatest::Deactivate()
{
	DriverLog( "CHydraHmdLatest::Deactivate: %s was object id %d\n", GetSerialNumber(), m_unSteamVRTrackedDeviceId );
	m_unSteamVRTrackedDeviceId = vr::k_unTrackedDeviceIndexInvalid;
}
/**
 * Called when this Listener object is removed from the Controller
 * or the Controller instance is destroyed.
 *
 * \include Listener_onExit.txt
 *
 * @param controller The Controller object invoking this callback function.
 * @since 1.0
 */
void CServerDriver_Leap::onExit(const Controller&controller)
{
    DriverLog("CServerDriver_Leap::onExit()\n");
}