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. 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(){ return position_available; }
	
	/**
	* Returns true if the tracker has reliable orientation information
	*/
	bool	hasOrientationTracking() { return position_available; }
	
	/**
	* Returns true if the tracker is alive/ready
	*/
	bool	isTrackerInitialized(){ return tracker_initialized; }
	
	/**
	* Tells the tracker that its time/safe to update.
	*/
	void	update();

	
};