add SDKs

14 files changed, 1920 insertions, 0 deletions

diff --git a/SixenseSDK/include/sixense_utils/accelerometer.hpp b/SixenseSDK/include/sixense_utils/accelerometer.hpp
new file mode 100755
index 0000000..e69de29
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/accelerometer.hpp
diff --git a/SixenseSDK/include/sixense_utils/button_states.hpp b/SixenseSDK/include/sixense_utils/button_states.hpp
new file mode 100755
index 0000000..a1d1936
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/button_states.hpp
@@ -0,0 +1,106 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_UTILS_BUTTON_STATES_HPP
+#define SIXENSE_UTILS_BUTTON_STATES_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense_utils/export.hpp"
+#include "sixense_utils/interfaces.hpp"
+
+#include <sixense.h>
+#include <sixense_math.hpp>
+
+namespace sixenseUtils {
+
+	// LaserPointer computes a ray that shoots from the controller and intersects with the screen. 
+	class SIXENSE_UTILS_EXPORT ButtonStates : public IButtonStates {
+
+	public:
+
+		ButtonStates();
+		void update( sixenseControllerData *cd );
+		bool buttonJustPressed( unsigned short which_button );
+		bool buttonJustReleased( unsigned short which_button );
+
+		void setTriggerThreshold( float thresh );
+		bool triggerJustPressed();
+		bool triggerJustReleased();
+
+		void setStickThreshold( float thresh );
+		bool stickJustPressed( Direction which );
+		bool stickJustReleased( Direction which );
+
+		void setAbsoluteTiltAngleThresholdInDeg( float thresh );
+		void setRelativeTiltAngleThresholdInDeg( float thresh );
+
+		// Relative tilts are an orientation change relative to the orientation last time setRelativeOrigin() was called
+		void setRelativeOrigin();
+		void startPointGesture();
+		void stopPointGesture();
+		bool relativeTiltJustStarted( Direction which );
+		bool relativeTiltJustStopped( Direction which );
+
+		// Absolute gestures are just relative to the world
+		bool absoluteTiltJustStarted( Direction which );
+		bool absoluteTiltJustStopped( Direction which );
+
+		float _trigger_threshold;
+
+		bool justStarted( ActionType action, int arg );
+		bool justStopped( ActionType action, int arg );
+
+	protected:
+		void updateJoystick( sixenseControllerData *cd );
+		void updateTrigger( sixenseControllerData *cd );
+		void updateButtons( sixenseControllerData *cd );
+		void updateTilt( sixenseControllerData *cd );
+
+	private:
+
+		// buttons
+		unsigned short _just_pressed;
+		unsigned short _just_released;
+		unsigned short _last_buttons;
+
+		// trigger
+		bool _trigger_just_pressed;
+		bool _trigger_just_released;
+		float _last_trigger_state;
+
+		// joystick
+		float _joystick_threshold;
+		float _last_joystick[2];
+		bool _joystick_just_pressed[4], _joystick_just_released[4]; // 4 stick directions
+
+
+		// tilt
+		float _absolute_tilt_angle_threshold_in_deg, _relative_tilt_angle_threshold_in_deg;
+		sixenseMath::Vector3 _last_point_vec;
+
+		bool _point_gesture_active;
+
+		bool _last_relative_tilt_states[6];
+		bool _relative_tilt_just_started[6], _relative_tilt_just_stopped[6]; // 6 tilt directions
+
+		bool _last_absolute_tilt_states[6];
+		bool _absolute_tilt_just_started[6], _absolute_tilt_just_stopped[6]; // 6 tilt directions
+		bool _should_zero_relative_origin;
+		sixenseMath::Matrix3 _relative_origin;
+
+	};
+
+}
+
+#pragma warning(pop)
+
+#endif
+
diff --git a/SixenseSDK/include/sixense_utils/controller_manager/controller_manager.hpp b/SixenseSDK/include/sixense_utils/controller_manager/controller_manager.hpp
new file mode 100755
index 0000000..f6b674d
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/controller_manager/controller_manager.hpp
@@ -0,0 +1,91 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef CONTROLLER_MANAGER_HPP
+#define CONTROLLER_MANAGER_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense_utils/export.hpp"
+#include "sixense_utils/interfaces.hpp"
+#include "sixense_utils/sixense_utils_string.hpp"
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <sixense.h>
+
+namespace sixenseUtils {
+
+	class SIXENSE_UTILS_EXPORT ControllerManager : public IControllerManager {
+
+	public:
+		~ControllerManager();
+
+		void setGameType( game_type gt );
+		game_type getGameType();
+
+		// Update the ControllerManager. Should be called each frame.
+		void update( sixenseAllControllerData * );
+
+		// Get the controller index for the given description, ie player 1's left hand is controller index 3
+		int getIndex( controller_desc );
+
+		// Force the user to rebind the controllers to the player slots.
+		void rebind();
+
+		// Register a callback that will get called when the mode changes
+		void registerSetupCallback( setup_callback );
+
+		// Returns true if the application should show the menu system
+		bool isMenuVisible();
+
+		// Returns the filename of the recommended texture for this step
+		const char* getTextureFileName();
+
+		// Returns a string describing this step
+		const char* getStepString();
+
+
+		ControllerManager::sound_type shouldPlaySound();
+
+		static ControllerManager *getTheControllerManager();
+
+		static controller_desc controllerDescFromString( sixense_utils_string str );
+
+		setup_step getCurrentStep();
+
+	protected:
+		ControllerManager();
+
+		game_type _game_type;
+
+		// A pointer to the current step
+		setup_step _current_step;
+
+		// A list of maps, one map of steps for each of the game_types.
+		std::vector< std::map< setup_step, class base_step*> >_steps;
+
+		int _controller_map[LAST_CONTROLLER_DESC];
+
+		setup_callback _callback;
+
+	};
+
+	// Singleton
+	SIXENSE_UTILS_EXPORT ControllerManager *getTheControllerManager();
+
+}
+
+#pragma warning(pop)
+
+#endif
+
diff --git a/SixenseSDK/include/sixense_utils/derivatives.hpp b/SixenseSDK/include/sixense_utils/derivatives.hpp
new file mode 100755
index 0000000..cd3c31f
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/derivatives.hpp
@@ -0,0 +1,63 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_UTILS_DERIVATIVES_HPP
+#define SIXENSE_UTILS_DERIVATIVES_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense.h"
+#include "sixense_math.hpp"
+
+#include <deque>
+
+#include "sixense_utils/export.hpp"
+#include "sixense_utils/interfaces.hpp"
+
+namespace sixenseUtils {
+
+	class SIXENSE_UTILS_EXPORT Derivatives : public IDerivatives {
+
+	public:
+		Derivatives( sixenseMath::Vector3 offset_vec = sixenseMath::Vector3() );
+
+		void update( sixenseControllerData *cd );
+
+		sixenseMath::Vector3 getPosition();
+		sixenseMath::Vector3 getVelocity();
+		sixenseMath::Vector3 getAcceleration();
+
+		sixenseMath::Vector3 getRSquared();
+
+		void setOffset( sixenseMath::Vector3 offset );
+		sixenseMath::Vector3 getOffset();
+
+	protected:
+		std::deque<unsigned char> _last_n_sequence;
+
+		std::deque<float> _last_n_times;
+
+		std::deque<sixenseMath::Vector3> _last_n_pos;
+
+		sixenseMath::Vector3 _pos;
+		sixenseMath::Vector3 _vel;
+		sixenseMath::Vector3 _accel;
+
+		sixenseMath::Vector3 _r_squared;
+
+		sixenseMath::Vector3 _offset_vec;
+
+	};
+
+}
+
+#pragma warning(pop)
+
+#endif
diff --git a/SixenseSDK/include/sixense_utils/event_triggers.hpp b/SixenseSDK/include/sixense_utils/event_triggers.hpp
new file mode 100755
index 0000000..53454ef
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/event_triggers.hpp
@@ -0,0 +1,110 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef EVENT_TRIGGERS_HPP
+#define EVENT_TRIGGERS_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include <sixense_math.hpp>
+
+namespace sixenseUtils {
+
+		// Classes for triggering events based on joystick or trigger positions
+
+	// These are classes that call the supplied EventTriggerBase's 'trigger()' events when triggered. They can be 
+	// created and bound to a switch.
+
+	class EventTriggerBase {
+	public:
+		virtual void trigger() const = 0;
+	};
+
+	// Do nothing
+	class NullEventTrigger : public EventTriggerBase {
+	public:
+		virtual void trigger() const {};
+	};
+
+
+
+	// These classes monitor a floating point value, and trigger their events when the value crosses
+	// a threshold, both rising and falling.
+
+	class EventSwitchBase { 
+	public:
+		EventSwitchBase( float thresh, const EventTriggerBase *positive_transition_event, const EventTriggerBase *negative_transition_event ) : _last_state(false), _thresh(thresh), _positive_transition_event(positive_transition_event), _negative_transition_event(negative_transition_event) {}
+		~EventSwitchBase() {
+			delete _positive_transition_event;
+			delete _negative_transition_event;
+		}
+		void test( float val ) {
+			if( val > _thresh  &&  !_last_state ) {
+				if( _positive_transition_event ) {
+					_positive_transition_event->trigger();
+				}
+				_last_state = true;
+			}
+			if( val < _thresh  &&  _last_state ) {
+				if( _negative_transition_event ) {
+					_negative_transition_event->trigger();
+				}
+				_last_state = false;
+			}
+		}
+
+		bool getLastState( void ) {
+			return _last_state;
+		}
+
+	protected:
+		bool _last_state;
+		float _thresh;
+		const EventTriggerBase *_positive_transition_event;
+		const EventTriggerBase *_negative_transition_event;
+
+	private:
+		EventSwitchBase() {}
+	};
+
+	class PlaneCrossEventSwitch : public EventSwitchBase {
+	public:
+		PlaneCrossEventSwitch( sixenseMath::Plane plane, float thresh, const EventTriggerBase *positive_transition_event, const EventTriggerBase *negative_transition_event ) : EventSwitchBase( thresh, positive_transition_event, negative_transition_event ),
+			_plane(plane) {}
+
+		void test( sixenseMath::Vector3 pt ) {
+			EventSwitchBase::test( -1.0f * (float)_plane.whichSide( pt ) );
+		}
+	private:
+		sixenseMath::Plane _plane;
+	};
+
+	class BinaryEventSwitch : public EventSwitchBase {
+	public:
+		BinaryEventSwitch( const EventTriggerBase *positive_transition_event, const EventTriggerBase *negative_transition_event ) : EventSwitchBase( 0.5f, positive_transition_event, negative_transition_event ) {}
+
+		void test( bool val ) {
+			EventSwitchBase::test( val ? 1.0f : 0.0f );
+		}
+	};
+
+	class ValuatorEventSwitch : public EventSwitchBase {
+	public:
+		ValuatorEventSwitch( float thresh, const EventTriggerBase *positive_transition_event, const EventTriggerBase *negative_transition_event ) : EventSwitchBase( thresh, positive_transition_event, negative_transition_event ){}
+		void test( float val ) {
+			EventSwitchBase::test( val );
+		}
+	};
+
+
+}
+#pragma warning(pop)
+
+#endif
diff --git a/SixenseSDK/include/sixense_utils/export.hpp b/SixenseSDK/include/sixense_utils/export.hpp
new file mode 100755
index 0000000..3f22ce7
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/export.hpp
@@ -0,0 +1,27 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_UTILS_EXPORT_HPP
+#define SIXENSE_UTILS_EXPORT_HPP
+
+#if defined(WIN32)
+  #ifdef SIXENSE_UTILS_STATIC_LIB
+    #define SIXENSE_UTILS_EXPORT 
+  #else
+		#ifdef BUILDING_SIXENSE_UTILS
+			#define SIXENSE_UTILS_EXPORT __declspec(dllexport)
+		#else
+			#define SIXENSE_UTILS_EXPORT __declspec(dllimport)
+		#endif
+	#endif
+#else
+  #define SIXENSE_UTILS_EXPORT 
+#endif
+
+#endif
diff --git a/SixenseSDK/include/sixense_utils/fps.hpp b/SixenseSDK/include/sixense_utils/fps.hpp
new file mode 100755
index 0000000..44bcb51
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/fps.hpp
@@ -0,0 +1,327 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_PORT_UTILS_FPS_HPP
+#define SIXENSE_PORT_UTILS_FPS_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense.h"
+#include "sixense_math.hpp"
+#include "sixense_utils/interfaces.hpp"
+
+#include <vector>
+#include <map>
+
+using sixenseMath::Vector2;
+using sixenseMath::Vector3;
+using sixenseMath::Matrix3;
+using sixenseMath::Matrix4;
+using sixenseMath::Quat;
+
+#include "export.hpp"
+
+#include "sixense_utils/derivatives.hpp"
+#include "sixense_utils/button_states.hpp"
+#include "sixense_utils/sixense_utils_string.hpp"
+
+namespace sixenseUtils {
+
+	class SIXENSE_UTILS_EXPORT FPSViewAngles : public IFPSViewAngles {
+
+	public:
+		FPSViewAngles();
+
+		void setGame( const char* game_name );
+
+		void setMode( fps_mode mode );
+		fps_mode getMode();
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		Vector3 getViewAngles(); // The final view angles, ie the feet plus the aiming from the controller
+		Vector3 getViewAngleOffset(); // The negative controller aim, used to keep the camera stationary in metroid mode
+
+		Vector3 getSpinSpeed();
+
+		void forceViewAngles( fps_mode mode, Vector3 ); // Used to initialize the view direction when switching into stick spin mode
+
+		void setFeetAnglesMetroid( Vector3 angles );
+		Vector3 getFeetAnglesMetroid();
+
+		float getTestVal();
+
+		void setParameter( fps_params param, float val );
+		float getParameter( fps_params param );
+
+		void setFov( float hfov, float vfov );
+		void getFov( float *hfov, float *vfov );
+
+		void setHoldingTurnSpeed( float horiz, float vert );
+
+		void setRatcheting( bool );
+		bool isRatcheting();
+
+		void reset();
+
+		void forceMetroidBlend( float blend_fraction );
+
+	protected:
+		void computeAimOffset1to1( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms );
+		void computeAimOffsetPointer( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms );
+
+		void computeFeetAnglesOffsetStickSpin( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms );
+		void computeFeetAnglesOffsetMetroid( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms );
+		void computeFeetAnglesOffsetRatchet( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms );
+
+		void computeSpringViewOffset();
+
+		Vector3 clampViewAngles( Vector3 angles, Vector3 max_vals );
+
+	private:
+		fps_mode _mode;
+
+		// Keep track of the game so we can do 
+		std::string _game_name;
+
+		// Different types of aim offsets
+		Vector3 _aim_offset_1to1_metroid, _aim_offset_1to1_mouselook; // need two because they're scaled differently
+		Vector3 _aim_offset_pointer;
+
+		Vector3 _spring_view_offset;
+		float _spring_vel;
+		Quat _spring_view;
+
+		// Different types of feet angles
+		Vector3 _feet_angles_stick_spin;
+		Vector3 _feet_angles_metroid;
+		Vector3 _feet_angles_ratchet;
+
+		Vector3 _feet_angles, _aim_offset_1to1;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+		ButtonStates _left_button_watcher, _right_button_watcher;
+
+		Vector3 _ratchet_base_orientation;
+
+		// Are we flicking? (0-1)
+		float _flicking;
+
+		bool _ratcheting;
+		bool _just_started_ratcheting, _just_stopped_ratcheting;
+
+		float _roll;
+
+		// Keep track of the fov
+		float _hfov, _vfov;
+
+		// This is used to blend pitch smoothly between modes
+		float _blend_pitch_val;
+
+		Vector3 _blend_view_offset;
+		Vector3 _prev_blend_view_offset;
+
+		Vector3 _mode_switch_blend_angle_start, _mode_switch_blend_angle_end, _mode_switch_blend_angles;
+
+		double _mode_switch_blend_duration_ms;
+		double _mode_switch_blend_start_time;
+
+		float _test_val;
+
+		Vector3 _holding_turn_speed;
+
+		// Allow metroid spinning to blend in over time. Useful when switching from 1-to-1 mode.
+		float _metroid_blend_start_time;
+		int _metroid_blend_in_or_out; // 0 == in, 1 == out
+
+		Vector3 _metroid_spin_speed, _stick_spin_speed;
+
+		float _force_blend_aim_metroid_start_time;
+		float _force_blend_aim_metroid_pitch_mult;
+		float _force_blend_aim_metroid_heading_mult;
+	};
+
+
+
+
+	class SIXENSE_UTILS_EXPORT FPSEvents : public IFPSEvents {
+
+	public:
+
+		FPSEvents(); 
+
+		void setGame( const char* game_name );
+
+		void setBinding( fps_event, fps_controller, fps_action, int param );
+
+		void setPointGestureButton( int );
+
+		bool isPointGestureActive();
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		bool eventActive( fps_event event_query );
+		bool eventStarted( fps_event event_query );
+		bool eventStopped( fps_event event_query );
+
+		Vector3 getGrenadeThrowVelocity();
+
+		void setParameter( fps_params param, float val );
+		float getParameter( fps_params param );
+
+	private:
+
+		typedef struct {
+			fps_event _event;
+			fps_controller _controller;
+			fps_action _action;
+			int _param;
+		} fps_binding;
+
+	protected:
+		bool testButtonBinding( fps_binding );
+		bool testJoystickBinding( fps_binding );
+		bool testTriggerBinding( fps_binding );
+		bool testTiltBinding( fps_binding );
+		bool testPointBinding( fps_binding );
+		bool testVelocityBinding( fps_binding );
+
+	private:
+
+		// keep them in a map so there's only one binding per event
+		std::map <fps_event, fps_binding> _bindings;
+
+		ButtonStates _button_states[2]; // one for each controller, in order of fps_controller, so 0=left 1=right
+
+		std::vector<bool> _event_started, _event_stopped, _event_persistent_state;
+		Derivatives _left_deriv, _right_deriv;
+		Derivatives _left_deriv_offset, _right_deriv_offset;
+
+		// Keep track of the velocity of the hand when a grenade is thrown
+		Vector3 _grenade_throw_vel;
+
+		// Keep track of the game so we can do 
+		std::string _game_name;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+		// The z depth at which one to one mode started. 
+		Vector3 _one_to_one_start_pos;
+
+		// This is set when a point gesture is in process
+		bool _point_gesture_active;
+
+		// The button that is used to engage point gestures
+		unsigned short _point_gesture_button;
+
+	};
+
+
+	class SIXENSE_UTILS_EXPORT FPSPlayerMovement : public IFPSPlayerMovement{
+
+	public:
+		FPSPlayerMovement();
+
+		void setGame( const char* game_name );
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		Vector2 getWalkDir();
+
+		void setParameter( fps_movement_params param, float val );
+		float getParameter( fps_movement_params param );
+
+	private:
+		Vector2 _walk_dir;
+		std::string _game_name;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+	};
+
+	class SIXENSE_UTILS_EXPORT FPSMeleeWeapon {
+	public:
+		FPSMeleeWeapon();
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		// Weapon movement
+		Vector3 getMeleeWeaponPos();
+		Vector3 getMeleeWeaponBladePos();
+		Matrix3 getMeleeWeaponMatrix();
+
+		// Attack
+		bool swingAttackStarted(); // since last update
+		bool isAttacking();
+		
+		// 1-to-1 mode (when the melee weapon should be moving with the controller and not animated
+		bool OneToOneModeStarted();
+		bool OneToOneModeStopped();
+		bool isInOneToOneMode();
+
+		Vector3 getSwingAttackStartPos();
+		Vector3 getSwingAttackDir();
+
+		void setToggleMode( bool mode );
+
+		void forceOneToOneMode( bool mode );
+
+		// Parameters to control the different modes
+		typedef enum {
+			SWING_START_VELOCITY,
+			SWING_STOP_VELOCITY,
+			SWING_REARM_VELOCITY,
+			BLADE_LENGTH,
+			CONTROLLER_ANGLE,
+
+			LEFT_HANDED,
+
+			LAST_MELEE_EVENTS_PARAM
+		} melee_params;
+
+		void setParameter( melee_params param, float val );
+		float getParameter( melee_params param );
+
+
+	private:
+		Derivatives _left_deriv, _right_deriv;
+		bool _armed; // Can we attack again?
+		bool _just_started_attack, _attacking;
+		bool _just_started_1to1, _just_stopped_1to1, _in_1to1_mode;
+		int _swing_wait_count; // How many frames to wait until starting a swing
+		int _swing_count; // How long have we been swinging?
+		Matrix4 _start_swing_mat;
+		Vector3 _swing_dir_vec; // Direction we are attacking in
+		Vector3 _swing_start_pos; // Position swing started from
+
+		float _last_trigger_pos;
+
+		Vector3 _weap_pos, _last_weap_pos;
+		Matrix3 _weap_mat, _last_weap_mat;
+
+		Vector3 _weap_blade_pos;
+
+		bool _toggle_mode;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+	};
+
+}
+
+#endif
+
+#pragma warning(pop)
+
diff --git a/SixenseSDK/include/sixense_utils/fps_rewrite.hpp b/SixenseSDK/include/sixense_utils/fps_rewrite.hpp
new file mode 100755
index 0000000..f1ddd19
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/fps_rewrite.hpp
@@ -0,0 +1,270 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_PORT_UTILS_FPS_HPP
+#define SIXENSE_PORT_UTILS_FPS_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense.h"
+#include "sixense_math.hpp"
+#include "sixense_utils/interfaces.hpp"
+
+#include <vector>
+#include <map>
+
+using sixenseMath::Vector2;
+using sixenseMath::Vector3;
+using sixenseMath::Matrix3;
+using sixenseMath::Matrix4;
+using sixenseMath::Quat;
+
+#include "export.hpp"
+
+#include "sixense_utils/derivatives.hpp"
+#include "sixense_utils/button_states.hpp"
+#include "sixense_utils/sixense_utils_string.hpp"
+
+namespace sixenseUtils {
+
+	class SIXENSE_UTILS_EXPORT FPSViewAngles : public IFPSViewAngles {
+
+	public:
+		FPSViewAngles();
+
+		void setGame( const char* game_name );
+
+		void setMode( fps_mode mode );
+		fps_mode getMode();
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		Vector3 getViewAngles(); // The final view angles, ie the feet plus the aiming from the controller
+		Vector3 getViewAngleOffset(); // The negative controller aim, used to keep the camera stationary in metroid mode
+
+		Vector3 getSpinSpeed();
+
+		void forceViewAngles( fps_mode mode, Vector3 ); // Used to initialize the view direction when switching into stick spin mode
+
+		void setFeetAnglesMetroid( Vector3 angles );
+		Vector3 getFeetAnglesMetroid();
+
+		float getTestVal();
+
+		void setParameter( fps_params param, float val );
+		float getParameter( fps_params param );
+
+		void setFov( float hfov, float vfov );
+		void getFov( float *hfov, float *vfov );
+
+		void setHoldingTurnSpeed( float horiz, float vert );
+
+		void setRatcheting( bool );
+		bool isRatcheting();
+
+		void reset();
+
+		void forceMetroidBlend( float blend_fraction );
+
+	protected:
+		Vector2 _feet_angles;
+		Vector2 _torso_angles;
+		Vector2 _view_offset;
+
+		Vector2 _ratchet_base_angles;
+
+	private:
+		fps_mode _mode;
+
+		// Keep track of the game so we can do 
+		std::string _game_name;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+		bool _ratcheting;
+		bool _just_started_ratcheting, _just_stopped_ratcheting;
+	};
+
+
+
+
+	class SIXENSE_UTILS_EXPORT FPSEvents : public IFPSEvents {
+
+	public:
+
+		FPSEvents(); 
+
+		void setGame( const char* game_name );
+
+		void setBinding( fps_event, fps_controller, fps_action, int param );
+
+		void setPointGestureButton( int );
+
+		bool isPointGestureActive();
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		bool eventActive( fps_event event_query );
+		bool eventStarted( fps_event event_query );
+		bool eventStopped( fps_event event_query );
+
+		Vector3 getGrenadeThrowVelocity();
+
+		void setParameter( fps_params param, float val );
+		float getParameter( fps_params param );
+
+	private:
+
+		typedef struct {
+			fps_event _event;
+			fps_controller _controller;
+			fps_action _action;
+			int _param;
+		} fps_binding;
+
+	protected:
+		bool testButtonBinding( fps_binding );
+		bool testJoystickBinding( fps_binding );
+		bool testTriggerBinding( fps_binding );
+		bool testTiltBinding( fps_binding );
+		bool testPointBinding( fps_binding );
+		bool testVelocityBinding( fps_binding );
+
+	private:
+
+		// keep them in a map so there's only one binding per event
+		std::map <fps_event, fps_binding> _bindings;
+
+		ButtonStates _button_states[2]; // one for each controller, in order of fps_controller, so 0=left 1=right
+
+		std::vector<bool> _event_started, _event_stopped, _event_persistent_state;
+		Derivatives _left_deriv, _right_deriv;
+		Derivatives _left_deriv_offset, _right_deriv_offset;
+
+		// Keep track of the velocity of the hand when a grenade is thrown
+		Vector3 _grenade_throw_vel;
+
+		// Keep track of the game so we can do 
+		std::string _game_name;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+		// The z depth at which one to one mode started. 
+		Vector3 _one_to_one_start_pos;
+
+		// This is set when a point gesture is in process
+		bool _point_gesture_active;
+
+		// The button that is used to engage point gestures
+		unsigned short _point_gesture_button;
+
+	};
+
+
+	class SIXENSE_UTILS_EXPORT FPSPlayerMovement : public IFPSPlayerMovement{
+
+	public:
+		FPSPlayerMovement();
+
+		void setGame( const char* game_name );
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		Vector2 getWalkDir();
+
+		void setParameter( fps_movement_params param, float val );
+		float getParameter( fps_movement_params param );
+
+	private:
+		Vector2 _walk_dir;
+		std::string _game_name;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+	};
+
+	class SIXENSE_UTILS_EXPORT FPSMeleeWeapon {
+	public:
+		FPSMeleeWeapon();
+
+		int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f );
+
+		// Weapon movement
+		Vector3 getMeleeWeaponPos();
+		Vector3 getMeleeWeaponBladePos();
+		Matrix3 getMeleeWeaponMatrix();
+
+		// Attack
+		bool swingAttackStarted(); // since last update
+		bool isAttacking();
+		
+		// 1-to-1 mode (when the melee weapon should be moving with the controller and not animated
+		bool OneToOneModeStarted();
+		bool OneToOneModeStopped();
+		bool isInOneToOneMode();
+
+		Vector3 getSwingAttackStartPos();
+		Vector3 getSwingAttackDir();
+
+		void setToggleMode( bool mode );
+
+		void forceOneToOneMode( bool mode );
+
+		// Parameters to control the different modes
+		typedef enum {
+			SWING_START_VELOCITY,
+			SWING_STOP_VELOCITY,
+			SWING_REARM_VELOCITY,
+			BLADE_LENGTH,
+			CONTROLLER_ANGLE,
+
+			LEFT_HANDED,
+
+			LAST_MELEE_EVENTS_PARAM
+		} melee_params;
+
+		void setParameter( melee_params param, float val );
+		float getParameter( melee_params param );
+
+
+	private:
+		Derivatives _left_deriv, _right_deriv;
+		bool _armed; // Can we attack again?
+		bool _just_started_attack, _attacking;
+		bool _just_started_1to1, _just_stopped_1to1, _in_1to1_mode;
+		int _swing_wait_count; // How many frames to wait until starting a swing
+		int _swing_count; // How long have we been swinging?
+		Matrix4 _start_swing_mat;
+		Vector3 _swing_dir_vec; // Direction we are attacking in
+		Vector3 _swing_start_pos; // Position swing started from
+
+		float _last_trigger_pos;
+
+		Vector3 _weap_pos, _last_weap_pos;
+		Matrix3 _weap_mat, _last_weap_mat;
+
+		Vector3 _weap_blade_pos;
+
+		bool _toggle_mode;
+
+		// Parameters to control the different modes
+		std::vector<float> _param_vals;
+
+	};
+
+}
+
+#endif
+
+#pragma warning(pop)
+
diff --git a/SixenseSDK/include/sixense_utils/interfaces.hpp b/SixenseSDK/include/sixense_utils/interfaces.hpp
new file mode 100755
index 0000000..5470221
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/interfaces.hpp
@@ -0,0 +1,442 @@
+#ifndef SIXENSE_UTILS_INTERFACES_HPP
+#define SIXENSE_UTILS_INTERFACES_HPP
+
+#include <sixense.h>
+#include <sixense_math.hpp>
+
+namespace sixenseUtils {
+
+	class IButtonStates {
+	public:
+
+		typedef enum {
+			DIR_UP,
+			DIR_DOWN,
+			DIR_LEFT,
+			DIR_RIGHT,
+			DIR_CW,
+			DIR_CCW,
+			DIR_FORWARD,
+			DIR_BACKWARD
+		} Direction;
+
+		typedef enum {
+			ACTION_BUTTON_PRESS,
+			ACTION_JOYSTICK_MOVE,
+			ACTION_TRIGGER_PRESS,
+			ACTION_TILT_GESTURE,
+			ACTION_POINT_GESTURE, 
+			ACTION_VELOCITY_GESTURE
+		} ActionType;
+
+		virtual void update( sixenseControllerData *cd )=0;
+		virtual bool buttonJustPressed( unsigned short which_button )=0;
+		virtual bool buttonJustReleased( unsigned short which_button )=0;
+
+		virtual void setTriggerThreshold( float thresh )=0;
+		virtual bool triggerJustPressed()=0;
+		virtual bool triggerJustReleased()=0;
+
+		virtual void setStickThreshold( float thresh )=0;
+		virtual bool stickJustPressed( Direction which )=0;
+		virtual bool stickJustReleased( Direction which )=0;
+
+		virtual void setAbsoluteTiltAngleThresholdInDeg( float thresh )=0;
+		virtual void setRelativeTiltAngleThresholdInDeg( float thresh )=0;
+
+		// Relative tilts are an orientation change relative to the orientation last time setRelativeOrigin() was called
+		virtual void setRelativeOrigin()=0;
+		virtual void startPointGesture()=0;
+		virtual void stopPointGesture()=0;
+		virtual bool relativeTiltJustStarted( Direction which )=0;
+		virtual bool relativeTiltJustStopped( Direction which )=0;
+
+		// Absolute gestures are just relative to the world
+		virtual bool absoluteTiltJustStarted( Direction which )=0;
+		virtual bool absoluteTiltJustStopped( Direction which )=0;
+
+		virtual bool justStarted( ActionType action, int arg )=0;
+		virtual bool justStopped( ActionType action, int arg )=0;
+
+	};
+
+	class IDerivatives {
+	public:
+		virtual void update( sixenseControllerData *cd )=0;
+
+		virtual sixenseMath::Vector3 getPosition()=0;
+		virtual sixenseMath::Vector3 getVelocity()=0;
+		virtual sixenseMath::Vector3 getAcceleration()=0;
+
+		virtual sixenseMath::Vector3 getRSquared()=0;
+
+		virtual void setOffset( sixenseMath::Vector3 offset )=0;
+		virtual sixenseMath::Vector3 getOffset()=0;
+	};
+
+	class IFPSViewAngles {
+
+	public:
+		virtual void setGame( const char* game_name )=0;
+
+		typedef enum {
+			MOUSELOOK,
+			FREE_AIM_TWO_CONTROLLER,
+			FREE_AIM_ONE_CONTROLLER,
+			DUAL_ANALOG
+		} fps_mode;
+
+		virtual void setMode( fps_mode mode )=0;
+		virtual fps_mode getMode()=0;
+
+		virtual int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f )=0;
+
+		virtual sixenseMath::Vector3 getViewAngles()=0; // The final view angles, ie the feet plus the aiming from the controller
+		virtual sixenseMath::Vector3 getViewAngleOffset()=0; // The negative controller aim, used to keep the camera stationary in metroid mode
+
+		virtual sixenseMath::Vector3 getSpinSpeed()=0;
+
+		virtual void forceViewAngles( fps_mode mode, sixenseMath::Vector3 )=0; // Used to initialize the view direction when switching into stick spin mode
+
+		virtual void setFeetAnglesMetroid( sixenseMath::Vector3 angles )=0;
+		virtual sixenseMath::Vector3 getFeetAnglesMetroid()=0;
+
+		virtual float getTestVal()=0;
+
+		// Parameters to control the different modes
+		typedef enum {
+			CONTROLLER_ANGLE_MODE,
+
+			AIM_1TO1_HEADING_MULTIPLIER,
+			AIM_1TO1_PITCH_MULTIPLIER,
+			AIM_1TO1_RATCHET_VERTICAL,
+
+			AIM_METROID_HEADING_MULTIPLIER,
+			AIM_METROID_PITCH_MULTIPLIER,
+			AIM_METROID_DEAD_ZONE_RADIUS,
+			AIM_METROID_ACCEL_BAND_SIZE,
+			AIM_METROID_MAX_SPEED,
+			AIM_METROID_AUTO_LEVEL_RATE,
+			AIM_METROID_ACCEL_BAND_EXPONENT,
+			AIM_METROID_SWITCH_BLEND_TIME_ENTER,
+			AIM_METROID_SWITCH_BLEND_TIME_EXIT,
+
+			FEET_ANGLES_OFFSET_STICK_SPIN_HORIZ_MULTIPLIER,
+			FEET_ANGLES_OFFSET_STICK_SPIN_VERT_MULTIPLIER,
+			FEET_ANGLES_OFFSET_STICK_SPIN_INVERT_PITCH,
+			FEET_ANGLES_OFFSET_STICK_SPIN_EXPONENT,
+
+			PITCH_CHANGE_BLEND_VAL,
+
+			SPRING_VIEW_ENABLED,
+			SPRING_VIEW_MIN_SPRING,
+			SPRING_VIEW_MAX_SPRING,
+			SPRING_VIEW_MIN_ANGLE,
+			SPRING_VIEW_MAX_ANGLE,
+
+			FEET_ANGLES_ALLOW_VERT_STICK_SPIN,
+
+			AIM_METROID_ACCEL_BAND_POWER,
+
+			HOLDING_TURN_SPEED,
+
+			ROLL_CORRECTION_BLEND,
+			EXIT_METROID_BLEND,
+
+			LEFT_HANDED,
+
+			LAST_FPS_VIEW_ANGLES_PARAM
+		} fps_params;
+
+		virtual void setParameter( fps_params param, float val )=0;
+		virtual float getParameter( fps_params param )=0;
+
+		virtual void setFov( float hfov, float vfov )=0;
+		virtual void getFov( float *hfov, float *vfov )=0;
+
+		virtual void setHoldingTurnSpeed( float horiz, float vert )=0;
+
+		virtual void setRatcheting( bool )=0;
+		virtual bool isRatcheting()=0;
+
+		virtual void reset()=0;
+
+		virtual void forceMetroidBlend( float blend_fraction )=0;
+	};
+
+	class IFPSEvents {
+
+	public:
+		typedef enum {
+			WALK_LEFT,
+			WALK_RIGHT,
+			WALK_FORWARD,
+			WALK_BACK,
+			JUMP,
+			USE,
+			PRIMARY_FIRE,
+			SECONDARY_FIRE,
+			ZOOM,
+			MELEE,
+			LEAN_LEFT,
+			LEAN_RIGHT,
+			CROUCH,
+			SPRINT,
+			THROW_GRENADE,
+			FLASHLIGHT,
+			NIGHTVISION,
+			RELOAD,
+			NEXT_WEAPON,
+			PREV_WEAPON,
+			ESC_KEY,
+			EQUIP_GRENADE,
+			MEDPACK_SWITCH,
+			GIVE,
+			NEXT_PRIMARY_WEAPON,
+			ONE_TO_ONE_CARRY,
+			EQUIP_MELEE,
+			EQUIP_MACHINEGUN,
+			EQUIP_PISTOL,
+			RATCHET,
+			LAST_FPS_EVENT
+		} fps_event;
+
+		typedef enum {
+			CONTROLLER_LEFT,
+			CONTROLLER_RIGHT
+		} fps_controller;
+
+		typedef enum {
+			ACTION_BUTTON_PRESS,
+			ACTION_JOYSTICK_MOVE,
+			ACTION_TRIGGER_PRESS,
+			ACTION_TILT_GESTURE,
+			ACTION_POINT_GESTURE, 
+			ACTION_VELOCITY_GESTURE
+		} fps_action;
+
+		typedef enum {
+			DIR_UP,
+			DIR_DOWN,
+			DIR_LEFT,
+			DIR_RIGHT,
+			DIR_FORWARD,
+			DIR_BACKWARD,
+			DIR_CW,
+			DIR_CCW
+		} fps_direction;
+
+		virtual void setGame( const char* game_name )=0;
+
+		virtual void setBinding( fps_event, fps_controller, fps_action, int param )=0;
+
+		virtual void setPointGestureButton( int )=0;
+
+		virtual bool isPointGestureActive()=0;
+
+		virtual int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f )=0;
+
+		virtual bool eventActive( fps_event event_query )=0;
+		virtual bool eventStarted( fps_event event_query )=0;
+		virtual bool eventStopped( fps_event event_query )=0;
+
+		virtual sixenseMath::Vector3 getGrenadeThrowVelocity()=0;
+
+		// Parameters to control the different modes
+		typedef enum {
+			MELEE_SENSITIVITY,
+			WEAPON_SELECT_SENSITIVITY,
+			CROUCH_SENSITIVITY,
+			JUMP_SENSITIVITY,
+			RELOAD_SENSITIVITY,
+			THROW_SENSITIVITY,
+
+			CONTROLLER_ANGLE_MODE,
+
+			AUTO_ONE_TO_ONE_START_VEL,
+			AUTO_ONE_TO_ONE_START_ACCEL,
+			AUTO_ONE_TO_ONE_START_ACCEL_TIMER,
+			AUTO_ONE_TO_ONE_START_ANGLE_THRESH,
+
+			AUTO_ONE_TO_ONE_STOP_XY_DIST,
+			AUTO_ONE_TO_ONE_STOP_Z_DIST,
+
+			LEFT_HANDED,
+
+			LAST_FPS_EVENTS_PARAM
+		} fps_params;
+
+		virtual void setParameter( fps_params param, float val )=0;
+		virtual float getParameter( fps_params param )=0;
+
+
+	};
+
+	class IFPSPlayerMovement {
+	public:
+		virtual void setGame( const char* game_name )=0;
+
+		virtual int update( sixenseControllerData *left_cd, sixenseControllerData *right_cd, float frametime_in_ms=0.0f )=0;
+
+		virtual sixenseMath::Vector2 getWalkDir()=0;
+
+		// Parameters to control the different modes
+		typedef enum {
+			DEAD_ZONE_PERCENT,
+			EXPONENTIAL,
+			USE_RIGHT_HAND,
+
+			LEFT_HANDED,
+
+			LAST_FPS_MOVEMENT_PARAM
+		} fps_movement_params;
+
+		virtual void setParameter( fps_movement_params param, float val )=0;
+		virtual float getParameter( fps_movement_params param )=0;
+
+	};
+
+	class ILaserPointer {
+	public:
+		virtual void setScreenSize( sixenseMath::Vector2 width_and_height_in_mm )=0;
+		virtual void setScreenCenterOffsetFromBase( sixenseMath::Vector3 offset_in_mm )=0;
+
+		virtual sixenseMath::Vector2 getScreenSize()=0;
+		virtual sixenseMath::Vector3 getScreenCenterOffsetFromBase()=0;
+
+		virtual sixenseMath::Vector2 getIntersection( sixenseMath::Vector3 position, sixenseMath::Matrix3 rotation )=0;
+	};
+
+	class IMousePointer {
+	public:
+		virtual sixenseMath::Vector2 update( sixenseControllerData *cd )=0;
+
+		virtual void setSensitivity( float sensitivity )=0;
+		virtual void setAcceleration( float acceleration )=0;
+		virtual void setSlideEnabled( bool slide_enabled )=0;
+		virtual void setAspectRatio( float aspect_ratio )=0;
+
+		virtual float getRollAngle()=0;
+
+		virtual void setCenter()=0;
+	};
+
+	class IControllerManager {
+	public:
+
+		// Define the steps the manager goes through for the different modes
+		typedef enum {
+
+			SETUP_COMPLETE,
+
+			// P1C1 = One player, 1 controller
+
+			// One player one controller
+			P1C1_START, //1
+			P1C1_POWER_UP_0,
+			P1C1_POWER_UP_DONE,
+			P1C1_AIM_P1L,
+			P1C1_DONE,
+			P1C1_OUT_OF_RANGE,
+			P1C1_IDLE, // 7
+
+			// One player two controllers
+			P1C2_START, // 8 
+			P1C2_POWER_UP_0,
+			P1C2_POWER_UP_1,
+			P1C2_POWER_UP_DONE,
+			P1C2_AIM_P1L, // 12
+			P1C2_AIM_P1R,
+			P1C2_DONE,
+			P1C2_OUT_OF_RANGE,
+			P1C2_IDLE // 16
+
+		} setup_step;
+
+
+		typedef enum {
+			NO_SOUND,
+			SUCCESS_BEEP,
+			FAIL_BEEP
+		} sound_type;
+
+		typedef void (*setup_callback)( setup_step );
+
+		typedef enum {
+			ONE_PLAYER_ONE_CONTROLLER,
+			ONE_PLAYER_TWO_CONTROLLER,
+			TWO_PLAYER_ONE_CONTROLLER,
+			TWO_PLAYER_TWO_CONTROLLER,
+			THREE_PLAYER_ONE_CONTROLLER,
+			THREE_PLAYER_TWO_CONTROLLER,
+			FOUR_PLAYER_ONE_CONTROLLER,
+			FOUR_PLAYER_TWO_CONTROLLER
+		} game_type;
+
+		typedef enum {
+			P1L,
+			P1R,
+			P2L,
+			P2R,
+			P3L,
+			P3R,
+			P4L,
+			P4R, 
+			LAST_CONTROLLER_DESC
+		} controller_desc;
+
+		virtual void setGameType( game_type gt )=0;
+		virtual game_type getGameType()=0;
+
+		// Update the controller_manager. Should be called each frame.
+		virtual void update( sixenseAllControllerData * )=0;
+
+		// Get the controller index for the given description, ie player 1's left hand is controller index 3
+		virtual int getIndex( controller_desc )=0;
+
+		// Force the user to rebind the controllers to the player slots.
+		virtual void rebind()=0;
+
+		// Register a callback that will get called when the mode changes
+		virtual void registerSetupCallback( setup_callback )=0;
+
+		// Returns true if the application should show the menu system
+		virtual bool isMenuVisible()=0;
+
+		// Returns the filename of the recommended texture for this step
+		virtual const char* getTextureFileName()=0;
+
+		// Returns a string describing this step
+		virtual const char* getStepString()=0;
+
+
+		virtual IControllerManager::sound_type shouldPlaySound()=0;
+
+		virtual setup_step getCurrentStep()=0;
+
+	};
+
+	class IMouseAndKeyboard {
+	public:
+		virtual void sendMouseClick( int click, int release ) = 0; // 0 = none, 1 = left, 2 = right
+		virtual void sendMouseClick( int click, int release, int delay) = 0; // 0 = none, 1 = left, 2 = right
+		virtual void sendMouseWheelMove( int dir ) = 0; // in 'clicks', + = forwards - = backwards
+		virtual void sendKeyState( char key, int press, int release ) = 0;
+		virtual void sendKeyState( char key, int press, int release, int delay ) = 0;
+		virtual void releaseKey( char key ) = 0;
+		virtual void releaseMouseButton( int release ) = 0;
+		virtual void sendAbsoluteMouseMove( float x, float y ) = 0;
+		virtual void sendRelativeMouseMove( float x, float y ) = 0;
+		virtual void sendAbsoluteMouseMoveInPixels( int x, int y ) = 0;
+
+		virtual void getMousePos( int *x, int *y ) = 0;
+		virtual void getPrimaryScreenResolution( int *x, int *y ) = 0;
+
+		virtual void sendMouseClick( float x, float y, int click, int release ) = 0;
+
+		// This should be called once per 10ms or so...
+		virtual void processQueue() = 0;
+	};
+}
+
+#endif
diff --git a/SixenseSDK/include/sixense_utils/keyboard_and_mouse_win32.hpp b/SixenseSDK/include/sixense_utils/keyboard_and_mouse_win32.hpp
new file mode 100755
index 0000000..16223b9
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/keyboard_and_mouse_win32.hpp
@@ -0,0 +1,227 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_UTILS_KEYBOARD_AND_MOUSE_WIN32_HPP
+#define SIXENSE_UTILS_KEYBOARD_AND_MOUSE_WIN32_HPP
+
+#include "export.hpp"
+
+#include "sixense_utils/interfaces.hpp"
+
+namespace sixenseUtils {
+
+	const int key_esc = 0x01;
+
+#define KEY_ESCAPE          0x01
+#define KEY_1               0x02
+#define KEY_2               0x03
+#define KEY_3               0x04
+#define KEY_4               0x05
+#define KEY_5               0x06
+#define KEY_6               0x07
+#define KEY_7               0x08
+#define KEY_8               0x09
+#define KEY_9               0x0A
+#define KEY_0               0x0B
+#define KEY_MINUS           0x0C    /* - on main keyboard */
+#define KEY_EQUALS          0x0D
+#define KEY_BACK            0x0E    /* backspace */
+#define KEY_TAB             0x0F
+#define KEY_Q               0x10
+#define KEY_W               0x11
+#define KEY_E               0x12
+#define KEY_R               0x13
+#define KEY_T               0x14
+#define KEY_Y               0x15
+#define KEY_U               0x16
+#define KEY_I               0x17
+#define KEY_O               0x18
+#define KEY_P               0x19
+#define KEY_LBRACKET        0x1A
+#define KEY_RBRACKET        0x1B
+#define KEY_RETURN          0x1C    /* Enter on main keyboard */
+#define KEY_LCONTROL        0x1D
+#define KEY_A               0x1E
+#define KEY_S               0x1F
+#define KEY_D               0x20
+#define KEY_F               0x21
+#define KEY_G               0x22
+#define KEY_H               0x23
+#define KEY_J               0x24
+#define KEY_K               0x25
+#define KEY_L               0x26
+#define KEY_SEMICOLON       0x27
+#define KEY_APOSTROPHE      0x28
+#define KEY_GRAVE           0x29    /* accent grave */
+#define KEY_LSHIFT          0x2A
+#define KEY_BACKSLASH       0x2B
+#define KEY_Z               0x2C
+#define KEY_X               0x2D
+#define KEY_C               0x2E
+#define KEY_V               0x2F
+#define KEY_B               0x30
+#define KEY_N               0x31
+#define KEY_M               0x32
+#define KEY_COMMA           0x33
+#define KEY_PERIOD          0x34    /* . on main keyboard */
+#define KEY_SLASH           0x35    /* / on main keyboard */
+#define KEY_RSHIFT          0x36
+#define KEY_MULTIPLY        0x37    /* * on numeric keypad */
+#define KEY_LMENU           0x38    /* left Alt */
+#define KEY_SPACE           0x39
+#define KEY_CAPITAL         0x3A
+#define KEY_F1              0x3B
+#define KEY_F2              0x3C
+#define KEY_F3              0x3D
+#define KEY_F4              0x3E
+#define KEY_F5              0x3F
+#define KEY_F6              0x40
+#define KEY_F7              0x41
+#define KEY_F8              0x42
+#define KEY_F9              0x43
+#define KEY_F10             0x44
+#define KEY_NUMLOCK         0x45
+#define KEY_SCROLL          0x46    /* Scroll Lock */
+#define KEY_NUMPAD7         0x47
+#define KEY_NUMPAD8         0x48
+#define KEY_NUMPAD9         0x49
+#define KEY_SUBTRACT        0x4A    /* - on numeric keypad */
+#define KEY_NUMPAD4         0x4B
+#define KEY_NUMPAD5         0x4C
+#define KEY_NUMPAD6         0x4D
+#define KEY_ADD             0x4E    /* + on numeric keypad */
+#define KEY_NUMPAD1         0x4F
+#define KEY_NUMPAD2         0x50
+#define KEY_NUMPAD3         0x51
+#define KEY_NUMPAD0         0x52
+#define KEY_DECIMAL         0x53    /* . on numeric keypad */
+#define KEY_F11             0x57
+#define KEY_F12             0x58
+#define KEY_F13             0x64    /*                     (NEC PC98) */
+#define KEY_F14             0x65    /*                     (NEC PC98) */
+#define KEY_F15             0x66    /*                     (NEC PC98) */
+
+#define KEY_KANA            0x70    /* (Japanese keyboard)            */
+#define KEY_CONVERT         0x79    /* (Japanese keyboard)            */
+#define KEY_NOCONVERT       0x7B    /* (Japanese keyboard)            */
+#define KEY_YEN             0x7D    /* (Japanese keyboard)            */
+#define KEY_BREAK			0x7E
+#define KEY_NUMPADEQUALS    0x8D    /* = on numeric keypad (NEC PC98) */
+#define KEY_CIRCUMFLEX      0x90    /* (Japanese keyboard)            */
+#define KEY_AT              0x91    /*                     (NEC PC98) */
+#define KEY_COLON           0x92    /*                     (NEC PC98) */
+#define KEY_UNDERLINE       0x93    /*                     (NEC PC98) */
+#define KEY_KANJI           0x94    /* (Japanese keyboard)            */
+#define KEY_STOP            0x95    /*                     (NEC PC98) */
+#define KEY_AX              0x96    /*                     (Japan AX) */
+#define KEY_UNLABELED       0x97    /*                        (J3100) */
+#define KEY_NUMPADENTER     0x9C    /* Enter on numeric keypad */
+#define KEY_RCONTROL        0x9D
+#define KEY_NUMPADCOMMA     0xB3    /* , on numeric keypad (NEC PC98) */
+#define KEY_DIVIDE          0xB5    /* / on numeric keypad */
+#define KEY_SYSRQ           0xB7
+#define KEY_RMENU           0xB8    /* right Alt */
+#define KEY_HOME            0xC7    /* Home on arrow keypad */
+#define KEY_UP              0xC8    /* UpArrow on arrow keypad */
+#define KEY_PRIOR           0xC9    /* PgUp on arrow keypad */
+#define KEY_LEFT            0xCB    /* LeftArrow on arrow keypad */
+#define KEY_RIGHT           0xCD    /* RightArrow on arrow keypad */
+#define KEY_END             0xCF    /* End on arrow keypad */
+#define KEY_DOWN            0xD0    /* DownArrow on arrow keypad */
+#define KEY_NEXT            0xD1    /* PgDn on arrow keypad */
+#define KEY_INSERT          0xD2    /* Insert on arrow keypad */
+#define KEY_DELETE          0xD3    /* Delete on arrow keypad */
+#define KEY_LWIN            0xDB    /* Left Windows key */
+#define KEY_RWIN            0xDC    /* Right Windows key */
+#define KEY_APPS            0xDD    /* AppMenu key */
+
+	class SIXENSE_UTILS_EXPORT mouseAndKeyboardWin32 {
+	public:
+		static void sendMouseClick( int click, int release ); // 0 = none, 1 = left, 2 = right
+		static void sendMouseClick( int click, int release, int delay); // 0 = none, 1 = left, 2 = right
+		static void sendMouseWheelMove( int dir ); // in 'clicks', + = forwards - = backwards
+		static void sendKeyState( char key, int press, int release );
+		static void sendKeyState( char key, int press, int release, int delay );
+		static void releaseKey( char key );
+		static void releaseMouseButton( int release );
+		static void sendAbsoluteMouseMove( float x, float y );
+		static void sendRelativeMouseMove( float x, float y );
+		static void sendAbsoluteMouseMoveInPixels( int x, int y );
+
+		static void getMousePos( int *x, int *y );
+		static void getPrimaryScreenResolution( int *x, int *y );
+
+		static void sendMouseClick( float x, float y, int click, int release );
+
+		// This should be called once per 10ms or so...
+		static void processQueue();
+
+	private:
+		static double _last_click_time;
+		static float _last_absolute_mouse_pos_x;
+		static float _last_absolute_mouse_pos_y;
+		static float _last_absolute_mouse_pos_x_when_clicked;
+		static float _last_absolute_mouse_pos_y_when_clicked;
+	};
+
+	// Define a non-static class for use by the factory constructor. These calls just
+	// pass through to the static calls above.
+	class MouseAndKeyboardWin32 : public IMouseAndKeyboard {
+	public:
+		virtual void sendMouseClick( int click, int release ) {
+			mouseAndKeyboardWin32::sendMouseClick( click, release );
+		}
+		virtual void sendMouseClick( int click, int release, int delay) {
+			mouseAndKeyboardWin32::sendMouseClick( click, release, delay );
+		}
+		virtual void sendMouseWheelMove( int dir ) {
+			mouseAndKeyboardWin32::sendMouseWheelMove( dir );
+		}
+		virtual void sendKeyState( char key, int press, int release ) {
+			mouseAndKeyboardWin32::sendKeyState( key, press, release );
+		}
+		virtual void sendKeyState( char key, int press, int release, int delay ) {
+			mouseAndKeyboardWin32::sendKeyState( key, press, release, delay );
+		}
+		virtual void releaseKey( char key ) {
+			mouseAndKeyboardWin32::releaseKey( key );
+		}
+		virtual void releaseMouseButton( int release ) {
+			mouseAndKeyboardWin32::releaseMouseButton( release );
+		}
+		virtual void sendAbsoluteMouseMove( float x, float y ) {
+			mouseAndKeyboardWin32::sendAbsoluteMouseMove( x, y );
+		}
+		virtual void sendRelativeMouseMove( float x, float y ) {
+			mouseAndKeyboardWin32::sendRelativeMouseMove( x, y );
+		}
+		virtual void sendAbsoluteMouseMoveInPixels( int x, int y ) {
+			mouseAndKeyboardWin32::sendAbsoluteMouseMoveInPixels( x, y );
+		}
+		virtual void getMousePos( int *x, int *y ) {
+			mouseAndKeyboardWin32::getMousePos( x, y );
+		}
+		virtual void getPrimaryScreenResolution( int *x, int *y ) {
+			mouseAndKeyboardWin32::getPrimaryScreenResolution( x, y );
+		}
+
+		virtual void sendMouseClick( float x, float y, int click, int release ) {
+			mouseAndKeyboardWin32::sendMouseClick( x, y, click, release );
+		}
+		// This should be called once per 10ms or so...
+		virtual void processQueue() {
+			mouseAndKeyboardWin32::processQueue();
+		}
+
+	};
+
+}
+
+#endif
+
diff --git a/SixenseSDK/include/sixense_utils/laser_pointer.hpp b/SixenseSDK/include/sixense_utils/laser_pointer.hpp
new file mode 100755
index 0000000..d845ae9
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/laser_pointer.hpp
@@ -0,0 +1,81 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_PORT_UTILS_LASER_POINTER_HPP
+#define SIXENSE_PORT_UTILS_LASER_POINTER_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense_utils/export.hpp"
+#include "sixense_utils/interfaces.hpp"
+
+#include "sixense_math.hpp"
+
+using sixenseMath::Vector2;
+using sixenseMath::Vector3;
+using sixenseMath::Matrix3;
+
+namespace sixenseUtils {
+
+	// LaserPointer computes a ray that shoots from the controller and intersects with the screen. 
+	class SIXENSE_UTILS_EXPORT LaserPointer {
+
+	public:
+		LaserPointer();
+
+		void setScreenSize( Vector2 width_and_height_in_mm );
+		void setScreenCenterOffsetFromBase( Vector3 offset_in_mm );
+
+		Vector2 getScreenSize();
+		Vector3 getScreenCenterOffsetFromBase();
+
+		Vector2 getIntersection( Vector3 position, Matrix3 rotation );
+
+	private:
+		Vector2 _width_and_height_in_mm;
+		Vector3 _offset_in_mm;
+
+	};
+
+
+	// This class can be used to compute the required parameters for the LaserPointer by having the user aim the controller at the
+	// corners of the screen.
+	class SIXENSE_UTILS_EXPORT LaserPointerCalib {
+	public:
+
+		LaserPointerCalib() { _has_computed = false; }
+
+		// Calibrate using 4 ray casts, bottom left and top right from 2 distinct positions in space
+		bool compute( 
+			Vector3 bottom_left_ray_from_point_A, 
+			Vector3 top_right_ray_from_point_A, 
+			Vector3 bottom_left_ray_from_point_B, 
+			Vector3 top_right_ray_from_point_B );
+
+		// Calibrate using 2 ray casts plus the screen size, bottom left and top right
+		bool compute(
+			float screen_width_in_mm, float screen_aspect, 
+			Vector3 bottom_left_ray_from_point_A, 
+			Vector3 top_right_ray_from_point_A );
+
+		bool hasComputed() { return _has_computed; }
+		Vector2 getScrenSize();
+		Vector3 setScreenCenterOffsetFromBase();
+
+	private:
+		bool _has_computed;
+		Vector2 _width_and_height_in_mm;
+		Vector3 _offset_in_mm;
+	};
+};
+
+#pragma warning(pop)
+
+#endif
diff --git a/SixenseSDK/include/sixense_utils/mouse_pointer.hpp b/SixenseSDK/include/sixense_utils/mouse_pointer.hpp
new file mode 100755
index 0000000..fb16e6a
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/mouse_pointer.hpp
@@ -0,0 +1,76 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_UTILS_MOUSE_POINTER_HPP
+#define SIXENSE_UTILS_MOUSE_POINTER_HPP
+
+#pragma warning(push)
+#pragma warning( disable:4251 )
+
+#include "sixense_utils/export.hpp"
+#include "sixense_utils/interfaces.hpp"
+
+using sixenseMath::Vector2;
+using sixenseMath::Vector3;
+using sixenseMath::Matrix3;
+
+namespace sixenseUtils {
+
+	class SIXENSE_UTILS_EXPORT MousePointer : public IMousePointer {
+
+	public:
+		MousePointer();
+		sixenseMath::Vector2 update( sixenseControllerData *cd );
+
+		void setSensitivity( float sensitivity );
+		void setAcceleration( float acceleration );
+		void setSlideEnabled( bool slide_enabled );
+		void setAspectRatio( float aspect_ratio );
+		void setLockRelativeToWindow(bool lock);
+		void setLockRelativeToClientBounds(bool client);
+
+		Vector2 getMouseOffset() { return mouse_offset; }
+		void setMouseOffset( Vector2 offset ) { mouse_offset = offset; }
+		float getRollAngle();
+
+		void setCenter();
+		void setWindowCenter();
+
+	private:
+		bool _slide_enabled;
+		float _aspect_ratio;
+		float _sensitivity;
+		float _screen_width_in_mm;
+
+		// velocity params
+		float _min_vel, _max_vel;
+		float _acceleration;
+	
+		// This offset is the position of the center of the virtual screen relative to the base
+		Vector2 mouse_offset;
+
+		// Keep track of the previous mouse pos so we can compute velocity
+		Vector2 _last_mouse_pos;
+
+		// Keep track of the last accel so we can filter it
+		float _last_accel;
+
+		float _roll_angle;
+
+		bool _center_mouse_requested;
+		bool _center_mouse_on_window;
+		
+		bool _lock_relative_to_window;
+		bool _lock_relative_using_client_bounds;
+	};
+}
+
+#pragma warning(pop)
+
+#endif
diff --git a/SixenseSDK/include/sixense_utils/sixense_utils_string.hpp b/SixenseSDK/include/sixense_utils/sixense_utils_string.hpp
new file mode 100755
index 0000000..31ee7c6
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/sixense_utils_string.hpp
@@ -0,0 +1,77 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#ifndef SIXENSE_UTILS_STRING_HPP
+#define SIXENSE_UTILS_STRING_HPP
+
+SIXENSE_UTILS_EXPORT void* sixense_utils_alloc(size_t);
+SIXENSE_UTILS_EXPORT void sixense_utils_free(void*); 
+
+#include <string>
+#include <cstddef>
+
+template<class MY_TYPE>
+class sixense_utils_allocator
+{
+public:
+	typedef size_t              size_type;
+	typedef ptrdiff_t   difference_type;
+	typedef MY_TYPE*    pointer;
+	typedef const MY_TYPE*      const_pointer;
+	typedef MY_TYPE&    reference;
+	typedef const MY_TYPE&      const_reference;
+	typedef MY_TYPE             value_type;
+
+	sixense_utils_allocator () {}
+	template <class U> sixense_utils_allocator(const sixense_utils_allocator<U>&) {}
+	template <class U> struct rebind { typedef sixense_utils_allocator<U> other; };
+
+	pointer allocate(size_type n, std::allocator<void>::const_pointer hint = 0)
+	{
+		return reinterpret_cast<pointer>(sixense_utils_alloc(n * sizeof(MY_TYPE)));
+	}
+	void construct(pointer p, const_reference val)
+	{
+		::new(p) MY_TYPE(val);
+	}
+	void destroy(pointer p)
+	{
+		p->~MY_TYPE();
+	}
+	void deallocate(pointer p, size_type n)
+	{
+		sixense_utils_free(p);
+	}
+	size_type max_size() const throw()
+	{
+		return ~size_type(0);
+	}
+};
+
+template<class MY_TYPE>
+bool operator==(const sixense_utils_allocator<MY_TYPE>& left, const sixense_utils_allocator<MY_TYPE>& right) throw()
+{
+	return true;
+}
+
+template<class MY_TYPE>
+bool operator!=(const sixense_utils_allocator<MY_TYPE>& left, const sixense_utils_allocator<MY_TYPE>& right) throw()
+{
+	return false;
+}
+
+namespace sixenseUtils {
+
+	typedef std::basic_string< char, std::char_traits<char>, sixense_utils_allocator<char> > sixense_utils_string;
+
+}
+
+
+#endif
+
diff --git a/SixenseSDK/include/sixense_utils/time.hpp b/SixenseSDK/include/sixense_utils/time.hpp
new file mode 100755
index 0000000..314ed64
--- /dev/null
+++ b/SixenseSDK/include/sixense_utils/time.hpp
@@ -0,0 +1,23 @@
+/*
+ *
+ * SIXENSE CONFIDENTIAL
+ *
+ * Copyright (C) 2011 Sixense Entertainment Inc.
+ * All Rights Reserved
+ *
+ */
+
+#include "sixense_utils/export.hpp"
+
+namespace sixenseUtils {
+
+	class SIXENSE_UTILS_EXPORT Time {
+	public:
+		static double getTimeInMilliseconds();
+
+		// Return the number of milliseconds since this was last called with the given token
+		static double getElapsedMilliseconds( int token );
+	};
+
+}
+