Head Tracking
Head Tracking
This tutorial shows how to interface an external 6 DOF tracking or 6 DOF input device to your Valve Source SDK Mod so you can control the player with the device instead of the mouse and keyboard.
Note, for many 3 DOF (orientation only) input devices (e.g., trackball) you can simply use your device's driver to masquerade as a mouse. But with 6 DOF devices (position and orientation) you have to something more. This tutorial supports external tracking devices (6DOF or less) that can't masquerade as a mouse and possible involve position and orientation
Step 1: Create an Interface to work with Any Tracker
The first step is to create a helper interface that will be used to access your tracker. This class will have interface methods that Valve will call when it needs position and orientation information. This is a software engineering drill, but will be very useful when you want to use more than one type of tracker.
Step 1A: Create the file CPPInterfaces2.h
Put this code inside:
//
// CppInterfaces2.h
//
#define Interface class
#define implements public
#define DeclareInterface(name) __interface actual_##name {
#define DeclareBasedInterface(name, base) __interface actual_##name \
: public actual_##base {
#define EndInterface(name) }; \
Interface name : public actual_##name { \
public: \
virtual ~name() {} \
};
This is just a bunch of compiler macros that will enforce interface constraints on your code. C++ doesn't provide native interface objects, so this is a way to enforce it so yuo can have the idea of an interface object. If you want the full details, check out this article by Jose Rios
Step 1B: Create the file cl_dll\IMovementController.h.
Put this code inside:
//Include interface enforement directives
#include "CPPInterfaces2.h"
/****************************************************
* This interface is used to integrate all
* Valve movement controllers
*
*
* Each movement controller provides 6-DOF on
* a particular object (body part, other tracked object
*
* This interface assumes that any implementing class
* will perform any required post processing to transform
* tracking results into a right handed coordinate system
* with +Z up -- with units in inches.
*
*****************************************************/
DeclareInterface(IMovementController)
/**
* Returns the orientation from the tracker. Assumes angles are relative to a right handed coord system with +Z up.
* Assumes update() has been called.
*/
int getOrientation(float &pitch, float &yaw, float &roll);
/**
* Returns the position from the tracker. Assumes coordinates are relative to a right handed coord system with +Z up.
* Assumes update() has been called.
*/
int getPosition(float &x, float &y, float &z);
/**
* Returns true if the tracker is initialized and ready to track
*/
bool isTrackerInitialized();
/**
* Reads the hardware and updates local internal state variables for later read by accessors.
*/
void update();
/**
* Returns true if the tracker has good position info
*/
bool hasPositionTracking();
/**
* Returns true if the tracker has good/reliable orientation info
*/
bool hasOrientationTracking();
EndInterface(IMovementController)
Again, this is just an interface and only ensures that when you implement a tracker, you obey a set of rules that will allow you to swap out trackers at compile time very easily.
Step 2: Create an Instance of the Interface for Your Particular Tracker
The class will implement the interface in Step 1, but have tracker specific API calls and code (the "guts") that deal with the nuances of your particular tracker SDK (e.g., FACE API, Intersense API, etc).
Step 2A : Create your Instance
Header File
Create a file cl_dll\MyMovementController.h. Place this inside:
#include "IMovementController.h" // The movement control interface
#include /path/to/your/tracker/api
class MyMovementController : implements IMovementController {
/************************** Member Functions **************************/
public:
/**
* Construct a new ar_movement_controller
*/
MyMovementController();
/**
* Destructor Closes tracker and performs clean up
*/
~MyMovementController();
/**
* Returns the pitch, yaw, and roll Euler angles of the tracker
*/
int getOrientation(float &pitch, float &yaw, float &roll);
/**
* Returns the position (in inches) of the tracker
*/
int getPosition(float &x, float &y, float &z);
/**
* Returns true if the tracker has reliable position information
*/
bool hasPositionTracking(void);
/**
* Returns true if the tracker has reliable orientation information
*/
bool hasOrientationTracking(void);
/**
* Returns true if the tracker is alive/ready
*/
bool isTrackerInitialized(void);
/**
* Tells the tracker that its time/safe to update.
*/
void update(void);
};
Class File
Create a file cl_dll\MyMovementController.cpp. Place this inside:
/****************************************************************************
* Sample shell for specific tracker instance
*
* This is very dependent on what tracker and API you are using
*
* This example is a conceptual template of how it would look
*
******************************************************************************/
#include "cbase.h"
#include "MyMovementController.h"
/****************************************************************************
* Constructor
******************************************************************************/
MyMovementController::MyMovementController() {
//Put in code here that is needed to connect to your tracker and initialize it
my_tracking_api.open();
}
/****************************************************************************
* Destructor
******************************************************************************/
MyMovementController::~MyMovementController(){
//Put in code here that shuts down the tracker
my_tracking_api.close();
}
/****************************************************************************
*
* functionName: GetOrientation
* Description: Get the current orientation from the tracker
*
******************************************************************************/
int MyMovementController::getOrientation(float &pitch, float &yaw, float &roll){
//Here just set pitch, roll, yaw using your tracker API/SDK
pitch = my_tracking_api.getPitch();
yaw = my_tracking_api.getYaw();
roll = my_tracking_api.getRoll();
//Note: If you need to do any rotations, say to adding 90 degrees to turn the tracker to face
// the player, then this is a good place
return 0;
}
/****************************************************************************
*
* functionName: GetPosition
* Description: Get the current position from the tracker
*
******************************************************************************/
int MyMovementController::getPosition(float &x, float &y, float &z){
//Here just set x, y, and z using your tracker API/SDK
x = my_tracking_api.getX_Pos();
y = my_tracking_api.getY_Pos();
z = my_tracking_api.getZ_Pos();
//Note: If you need to add offsets or convert units (meter's the inches, etc) then you can
// do that here
return 0;
}
/****************************************************************************
* Cues the tracker for an update
*
******************************************************************************/
void MyMovementController::update() {
//Here use your tracker API/SDK to perform any per-frame steps that must
//be called to update the tracker
my_tracking_api.update();
}
/****************************************************************************
*
* Checkes if the tracker is alive
*
******************************************************************************/
bool MyMovementController::isTrackerInitialized() {
//Here use your tracker API/SDK to check the status of the tracker
return my_tracking_api.trackerReady();
}
/****************************************************************************
*
* Checkes if the tracker has valid orientation data
*
******************************************************************************/
bool MyMovementController::hasOrientationTracking() {
//Here use your tracker API/SDK to check the orientation of the tracker
return my_tracking_api.hasOrientationData();
}
/****************************************************************************
*
* Checkes if the tracker has valid orientation data
*
******************************************************************************/
bool MyMovementController::hasPositionTracking() {
//Here use your tracker API/SDK to check the position tracking of the tracker
return my_tracking_api.hasPositionData();
}
Step 3 : Modify Valve's in_main.cpp File
Modify cl_dll\in_main.cpp as follows.
Includes
In the includes section, include your tracker implementation from Step 2 and the interface from Step 1:
#include "IMovementController.h" #include "MyMovementController.h"
Variables
In the top of the file, add a reference to your tracker:
//The movement controller used for head tracking IMovementController* arctl_head;
Note: This is creating an interface, which will be use by all the code we add. This will allow you to easily swap out trackers without having to tweak a bunch of code.
Creation
Find the method void CInput::Init_All (void)
Add code (anywhere in the method is OK) to instantiate your tracking class:
arctl_head = new MyMovementController();
Note: This is the only place we specify the particular implementation of the tracker.
Destruction and Cleanup
Find the method void CInput::Shutdown_All(void). Add the following (anywhere):
delete arctl_head;
This forces a call to the destructor in our tracking class.
Allowing Use of the Mouse when Tracker not Ready
Find the method void IN_CenterView_f (void). Change it to this:
void IN_CenterView_f (void)
{
//Use mouse if tracker is unavailable
if(!arctl_head->isTrackerInitialized() || (useTracking == false)){
QAngle viewangles;
//arctl_head->report();
if ( UsingMouselook() == false )
{
if ( !::input->CAM_InterceptingMouse() )
{
engine->GetViewAngles( viewangles );
viewangles[PITCH] = 0;
engine->SetViewAngles( viewangles );
//prediction->SetLocalViewAngles( viewangles ); //STEVE ALBANY
}
}
}
}
This allows you to use the mouse when the tracker isn't active.
Adjusting the Player/Camera Orientation
Find the method void CInput::AdjustAngles ( float frametime ). Change it to this:
void CInput::AdjustAngles ( float frametime )
{
float speed;
QAngle viewangles;
// Determine control scaling factor ( multiplies time )
speed = DetermineKeySpeed( frametime );
// Retrieve latest view direction from engine
engine->GetViewAngles( viewangles );
//Get view angle from the tracker
if(arctl_head->isTrackerInitialized() && (useTracking == true)){
arctl_head->update();
viewangles = getCameraAngles();
//Msg("myang = %f, %f, %f\n", myAng.x, myAng.y, myAng.z);
}
else{
// Adjust YAW
AdjustYaw( speed, viewangles );
// Adjust PITCH if keyboard looking
AdjustPitch( speed, viewangles );
// Make sure values are legitimate
ClampAngles( viewangles );
}
// Store new view angles into engine view direction
engine->SetViewAngles( viewangles );
}
You'll notice the code above calls a method getCameraAngles(). Add it to the code (anywhere):
QAngle getCameraAngles() {
QAngle viewangles;
//pitch, yaw, roll
float pitch, yaw, roll;
arctl_head->getOrientation(pitch, yaw, roll);
//Note: the mapping of angles to your tracker might be different
viewangles.x = pitch;
viewangles.y = yaw;
viewangles.z = roll;
return viewangles;
}
Other
Find the method void CInput::ControllerMove( float frametime, CUserCmd *cmd ). Change it to this:
void CInput::ControllerMove( float frametime, CUserCmd *cmd )
{
//Use mouse if tracker is unavailable or tracking disabled
if(!arctl_head->isTrackerInitialized() || (useTracking == false)){
if ( IsPC() )
{
if ( !m_fCameraInterceptingMouse && m_fMouseActive )
{
MouseMove( cmd);
}
}
//arctl_head->report();
JoyStickMove( frametime, cmd);
}
}
Find the method void CInput::ExtraMouseSample( float frametime, bool active ). Change it to this:
void CInput::ExtraMouseSample( float frametime, bool active )
{
//Use mouse if tracker is unavailable or disabled
if(!arctl_head->isTrackerInitialized() || (useTracking == false)){
CUserCmd dummy;
CUserCmd *cmd = &dummy;
cmd->Reset();
//arctl_head->report();
QAngle viewangles;
if ( active )
{
// Determine view angles
AdjustAngles ( frametime );
// Determine sideways movement
ComputeSideMove( cmd );
// Determine vertical movement
ComputeUpwardMove( cmd );
// Determine forward movement
ComputeForwardMove( cmd );
// Scale based on holding speed key or having too fast of a velocity based on client maximum
// speed.
ScaleMovements( cmd );
// Allow mice and other controllers to add their inputs
ControllerMove( frametime, cmd );
}
// Retreive view angles from engine ( could have been set in IN_AdjustAngles above )
engine->GetViewAngles( viewangles );
// Set button and flag bits, don't blow away state
cmd->buttons = GetButtonBits( 0 );
// Use new view angles if alive, otherwise user last angles we stored off.
if ( g_iAlive )
{
VectorCopy( viewangles, cmd->viewangles );
VectorCopy( viewangles, m_angPreviousViewAngles );
}
else
{
VectorCopy( m_angPreviousViewAngles, cmd->viewangles );
}
// Let the move manager override anything it wants to.
g_pClientMode->CreateMove( frametime, cmd );
// Get current view angles after the client mode tweaks with it
engine->SetViewAngles( cmd->viewangles );
prediction->SetLocalViewAngles( cmd->viewangles );
}
}
Find the method void CInput::CreateMove ( int sequence_number, float input_sample_frametime, bool active ).
Look for this code:
if ( active || sv_noclipduringpause.GetInt() )
{
// Determine view angles
AdjustAngles ( input_sample_frametime );
// Allow mice and other controllers to add their inputs
ControllerMove( input_sample_frametime, cmd );
}
Add code to read the tracker:
if ( active || sv_noclipduringpause.GetInt() )
{
// Determine view angles
AdjustAngles( input_sample_frametime );
//Use tracker for position if position tracking is available and enabled
if(arctl_head->hasPositionTracking() && (useTracking == true)){
float x,y,z;
getCameraPosition(x,y,z);
char command[64];
//Msg("set_user_position %f %f %f\n", x, y, z);
sprintf(command, "set_user_position %f %f %f", x, y, z);
engine->ClientCmd(command);
}
if(!arctl_head->hasPositionTracking() || (useTracking == false)){
arctl_head->report();
// Determine sideways movement
ComputeSideMove( cmd );
// Determine vertical movement
ComputeUpwardMove( cmd );
// Determine forward movement
ComputeForwardMove( cmd );
// Scale based on holding speed key or having too fast of a velocity based on client maximum
// speed.
ScaleMovements( cmd );
}
// Allow mice and other controllers to add their inputs
ControllerMove( input_sample_frametime, cmd );
}