chrisdenham / osgopenvrviewer Goto Github PK

vr::TrackedDevicePose_t poses[vr::k_unMaxTrackedDeviceCount];
for (int i = 0; i < vr::k_unMaxTrackedDeviceCount; ++i) poses[i].bPoseIsValid = false;
vr::VRCompositor()->WaitGetPoses(poses, vr::k_unMaxTrackedDeviceCount, NULL, 0);

// Not sure why, but the openvr hellovr_opengl example only seems interested in the
// pose transform from the first pose tracking device in the array.
// i.e. this seems to be the only one that is used to affect the view transform matrix.
// So, here we do the same.

m_position.clear();
m_orientation.clear();
for (int i = 0; i < vr::k_unMaxTrackedDeviceCount; i++)
{
    const vr::TrackedDevicePose_t& pose = poses[i];
    if (pose.bPoseIsValid)
    {

        if ((m_vrSystem->GetTrackedDeviceClass( i ) != vr::TrackedDeviceClass_HMD ) && (m_vrSystem->GetTrackedDeviceClass( i ) != vr::TrackedDeviceClass_Controller )) continue;

        osg::Matrix matrix = convertMatrix34(pose.mDeviceToAbsoluteTracking);



        /*
        pose.mDeviceToAbsoluteTracking
        vr::HmdMatrix34_t
        you'll get the position from the [0][3], [1][3] and [2][3] matrix positions.
        */
        osg::Vec3 __pos (pose.mDeviceToAbsoluteTracking.m[0][3],pose.mDeviceToAbsoluteTracking.m[1][3],pose.mDeviceToAbsoluteTracking.m[2][3]);
        m_position.push_back ( __pos );

        osg::Matrix poseTransform = osg::Matrix::inverse(matrix);
        //m_position.push_back ( poseTransform.getTrans() * m_worldUnitsPerMetre );
        m_orientation.push_back ( poseTransform.getRotate());
    }
}


ButtonsAndAnalog.clear();


// Process SteamVR controller state
for (vr::TrackedDeviceIndex_t unDevice = 0; unDevice < vr::k_unMaxTrackedDeviceCount; unDevice++)
{
    if (m_vrSystem->GetTrackedDeviceClass( unDevice ) != vr::TrackedDeviceClass_Controller ) continue;

    buttons_and_analog temp;
    temp.k_EButton_ApplicationMenu=false;
    temp.k_EButton_Grip=false;
    temp.k_EButton_SteamVR_Touchpad=false;
    temp.k_EButton_SteamVR_Trigger=false;
    temp.TrackPad_x=0;
    temp.TrackPad_y=0;
    temp.Joystick_x=0;
    temp.Joystick_y=0;
    temp.Trigger_x=0;
    temp.Trigger_y=0;

    vr::VRControllerState_t state;
    if (m_vrSystem->GetControllerState(unDevice, &state))
    {
        if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ApplicationMenu)) temp.k_EButton_ApplicationMenu = true;
        if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Trigger))  temp.k_EButton_SteamVR_Trigger = true;
        if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Grip)) temp.k_EButton_Grip = true;
        if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Touchpad)) temp.k_EButton_SteamVR_Touchpad = true;


        // Convert the axes
        for (int j = 0; j < vr::k_unControllerStateAxisCount; j++)
        {
            vr::ETrackedDeviceProperty prop = (vr::ETrackedDeviceProperty)(vr::Prop_Axis0Type_Int32 + j);
            vr::EVRControllerAxisType type = (vr::EVRControllerAxisType)vr::VRSystem()->GetInt32TrackedDeviceProperty(unDevice, prop);
            vr::VRControllerAxis_t axis = state.rAxis[j];

            if (type == vr::k_eControllerAxis_TrackPad)
            {
                temp.TrackPad_x = axis.x ;
                temp.TrackPad_y = axis.y ;
            }

            if (type == vr::k_eControllerAxis_Trigger)
            {
                temp.Trigger_x = axis.x ;
                temp.Trigger_y = axis.y ;
            }

            if (type == vr::k_eControllerAxis_Joystick)
            {
                temp.Joystick_x = axis.x ;
                temp.Joystick_y = axis.y ;
            }
        }

        //
    }

    ButtonsAndAnalog.push_back(temp);
}

float TrackPad_x;
float TrackPad_y;

float Trigger_x;
float Trigger_y;

float Joystick_x;
float Joystick_y;