Keyboard/Mouse Input class - GameCreators Forum

Author

Message

Bran flakes91093

16

Years of Service

User Offline

Joined: 13th Sep 2008

Location: Crazy Land

Posted: 19th Jan 2010 23:55 Edited at: 3rd Feb 2010 00:38

Link

I already have this posted in the code snippets board, but I wasn't sure if anybody that uses DarkGDK really goes there often since the majority of posts there are for DBP. So here it is.

Tools:

////////////////////////////////////////////////////////////////////////////////////////////////////
// file:	Utilities\Tools.h
//
// summary:	Declares the tools
//
// author:  Branflakes (Bran flakes91093)
//
// contact: Branflakes91093@live.com
////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Windows.h"
#include <math.h>

////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Tools
//
// summary:	Various tools.
////////////////////////////////////////////////////////////////////////////////////////////////////
namespace Tools
{
	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Timer class.</summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	class Timer
	{
	private:
		bool counting;
		DWORD time,
			start; // starting time.
	public:
		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Default Constructor. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		Timer();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Destructor. </summary>
		///
		/// <remarks> Branflakes, 1/23/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		~Timer();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Starts the timer. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Start();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Stops the timer. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Stop();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether or not the timer is currently running. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> true if running, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool Counting() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns the current time in milliseconds. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> current time in milliseconds. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		DWORD Time() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates this object. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Update();
	};

template<typename T>
	inline T Max(const T First, const T Second) {
		return ((First >= Second) ? First : Second);
	}
	template<typename T>
	inline T Min(const T First, const T Second) {
		return ((First <= Second) ? First : Second);
	}
	template<typename T>
	inline T Clamp(T &Val, const T Low, const T High) {
		if(Val < Low)
			return (Val = Low);
		if(Val > High)
			return (Val = High);
		return Val;
	}
}

+ Code Snippet

////////////////////////////////////////////////////////////////////////////////////////////////////
// file:	Utilities\Tools.h
//
// summary:	Declares the tools
//
// author:  Branflakes (Bran flakes91093)
//
// contact: Branflakes91093@live.com
////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Windows.h"
#include <math.h>

////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Tools
//
// summary:	Various tools.
////////////////////////////////////////////////////////////////////////////////////////////////////
namespace Tools
{
	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Timer class.</summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	class Timer
	{
	private:
		bool counting;
		DWORD time,
			start; // starting time.
	public:
		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Default Constructor. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		Timer();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Destructor. </summary>
		///
		/// <remarks> Branflakes, 1/23/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		~Timer();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Starts the timer. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Start();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Stops the timer. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Stop();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether or not the timer is currently running. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> true if running, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool Counting() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns the current time in milliseconds. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> current time in milliseconds. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		DWORD Time() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates this object. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Update();
	};

	template<typename T>
	inline T Max(const T First, const T Second) {
		return ((First >= Second) ? First : Second);
	}
	template<typename T>
	inline T Min(const T First, const T Second) {
		return ((First <= Second) ? First : Second);
	}
	template<typename T>
	inline T Clamp(T &Val, const T Low, const T High) {
		if(Val < Low)
			return (Val = Low);
		if(Val > High)
			return (Val = High);
		return Val;
	}
}

and Input:

////////////////////////////////////////////////////////////////////////////////////////////////////
// file:	Utilities\Input.h
//
// summary:	Declares the input class
//
// author:  Branflakes (Bran flakes91093)
//
// contact: Branflakes91093@live.com
////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Tools.h"

////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Input
//
// summary:	Contains specialized classes and constants to handle more than seeing 
//			whether a key is down or not. Use virtual keys.
////////////////////////////////////////////////////////////////////////////////////////////////////
namespace Input
{
	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Values that represent virtual keys. </summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	enum eKeys {
		KEY_0 = 0x30,
		KEY_1, 
		KEY_2,
		KEY_3,
		KEY_4,
		KEY_5,
		KEY_6,
		KEY_7,
		KEY_8,
		KEY_9,
		KEY_A = 0x41,
		KEY_B,
		KEY_C,
		KEY_D,
		KEY_E,
		KEY_F,
		KEY_G,
		KEY_H,
		KEY_I,
		KEY_J,
		KEY_K,
		KEY_L,
		KEY_M,
		KEY_N,
		KEY_O,
		KEY_P,
		KEY_Q,
		KEY_R,
		KEY_S,
		KEY_T,
		KEY_U,
		KEY_V,
		KEY_W,
		KEY_X,
		KEY_Y,
		KEY_Z
	};

////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Stores data for each key.</summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	struct KeyData
	{
	public:
		KeyData();
		~KeyData();
		bool pressed;
		bool released;
		bool held;
		bool dclick; // Double click.
		bool active;
		//Tools::Timer timer;
		Tools::Timer dtimer; // Double click timer.
		int hit; // Used for counting clicks to see if a key has been double clicked.
	};

////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Handles mouse and keyboard. Use virtual keys. </summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	class InputState
	{
	private:
		HWND hWnd; 
		KeyData keyData[256];
		UINT ddelay; // Double click delay
		POINT gPos; // Global mouse position
		POINT rPos; // Relative mouse position

public:
		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Default Constructor. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		InputState();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Constructor. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		InputState(const HWND hWND);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Queries if a key is active. </summary>
		///
		/// <remarks> Branflakes, 1/20/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true if the key is active, false if not. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool IsKeyActive(const BYTE vkKey) const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Query if 'vkKey' is down. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true if down, false if not. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool IsKeyDown(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Query if 'vkKey' is up. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true if up, false if not. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool IsKeyUp(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether or not the key is being held. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The vk key. </param>
		///
		/// <returns> true if it is, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool KeyHeld(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether the key is pressed. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true when pressed, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool KeyPressed(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether the key is released. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true when released, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool KeyReleased(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether the key is double clicked. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true when double clicked, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool DoubleClick(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Gets the hwnd. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> The hwnd. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		const HWND GetHWND() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Gets the double click delay. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> The double click delay. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		UINT GetDoubleClickDelay() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Global mouse x coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Global mouse x coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		UINT GlobalMouseX() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Global mouse y coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Global mouse y coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		UINT GlobalMouseY() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse x coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		///
		/// <returns> Relative mouse x coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseX(const HWND hWND) const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse x coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Relative mouse x coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseX() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse y coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		///
		/// <returns> Relative mouse y coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseY(const HWND hWND) const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse y coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Relative mouse y coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseY() const;

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the double click delay. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="Delay"> The delay. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetDoubleClickDelay(const UINT Delay);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the global mouse position. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="X"> The x coordinate. </param>
		/// <param name="Y"> The y coordinate. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetMousePosGlobal(const UINT X, const UINT Y);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the relative mouse position. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		/// <param name="X">    The x coordinate. </param>
		/// <param name="Y">    The y coordinate. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetMousePosRelative(const HWND hWND, const int X, const int Y);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets a mouse position relative. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="X"> The x coordinate. </param>
		/// <param name="Y"> The y coordinate. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetMousePosRelative(const int X, const int Y);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the hwnd. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetHWND(const HWND hWND);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Activates the key described by vkKey. </summary>
		///
		/// <remarks> Branflakes, 1/22/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void ActivateKey(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Deactivates a key. </summary>
		///
		/// <remarks> Branflakes, 1/20/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void DeactivateKey(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the keyboard. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void UpdateKeyboard();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the mouse. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void UpdateMouse();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the keyboard and mouse. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Update();

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the key described by vkKey. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void UpdateKey(const BYTE vkKey);

////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Only updates the keys that are activated. </summary>
		///
		/// <remarks> Branflakes, 1/20/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void FastUpdate();
	};

}

+ Code Snippet

////////////////////////////////////////////////////////////////////////////////////////////////////
// file:	Utilities\Input.h
//
// summary:	Declares the input class
//
// author:  Branflakes (Bran flakes91093)
//
// contact: Branflakes91093@live.com
////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Tools.h"

////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Input
//
// summary:	Contains specialized classes and constants to handle more than seeing 
//			whether a key is down or not. Use virtual keys.
////////////////////////////////////////////////////////////////////////////////////////////////////
namespace Input
{
	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Values that represent virtual keys. </summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	enum eKeys {
		KEY_0 = 0x30,
		KEY_1, 
		KEY_2,
		KEY_3,
		KEY_4,
		KEY_5,
		KEY_6,
		KEY_7,
		KEY_8,
		KEY_9,
		KEY_A = 0x41,
		KEY_B,
		KEY_C,
		KEY_D,
		KEY_E,
		KEY_F,
		KEY_G,
		KEY_H,
		KEY_I,
		KEY_J,
		KEY_K,
		KEY_L,
		KEY_M,
		KEY_N,
		KEY_O,
		KEY_P,
		KEY_Q,
		KEY_R,
		KEY_S,
		KEY_T,
		KEY_U,
		KEY_V,
		KEY_W,
		KEY_X,
		KEY_Y,
		KEY_Z
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Stores data for each key.</summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	struct KeyData
	{
	public:
		KeyData();
		~KeyData();
		bool pressed;
		bool released;
		bool held;
		bool dclick; // Double click.
		bool active;
		//Tools::Timer timer;
		Tools::Timer dtimer; // Double click timer.
		int hit; // Used for counting clicks to see if a key has been double clicked.
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// <summary> Handles mouse and keyboard. Use virtual keys. </summary>
	///
	/// <remarks> Branflakes, 1/17/2010. </remarks>
	////////////////////////////////////////////////////////////////////////////////////////////////////
	class InputState
	{
	private:
		HWND hWnd; 
		KeyData keyData[256];
		UINT ddelay; // Double click delay
		POINT gPos; // Global mouse position
		POINT rPos; // Relative mouse position

	public:
		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Default Constructor. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		InputState();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Constructor. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		InputState(const HWND hWND);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Queries if a key is active. </summary>
		///
		/// <remarks> Branflakes, 1/20/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true if the key is active, false if not. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool IsKeyActive(const BYTE vkKey) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Query if 'vkKey' is down. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true if down, false if not. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool IsKeyDown(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Query if 'vkKey' is up. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true if up, false if not. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool IsKeyUp(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether or not the key is being held. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The vk key. </param>
		///
		/// <returns> true if it is, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool KeyHeld(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether the key is pressed. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true when pressed, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool KeyPressed(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether the key is released. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true when released, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool KeyReleased(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Returns whether the key is double clicked. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		///
		/// <returns> true when double clicked, else false. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		bool DoubleClick(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Gets the hwnd. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> The hwnd. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		const HWND GetHWND() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Gets the double click delay. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> The double click delay. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		UINT GetDoubleClickDelay() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Global mouse x coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Global mouse x coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		UINT GlobalMouseX() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Global mouse y coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Global mouse y coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		UINT GlobalMouseY() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse x coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		///
		/// <returns> Relative mouse x coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseX(const HWND hWND) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse x coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Relative mouse x coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseX() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse y coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		///
		/// <returns> Relative mouse y coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseY(const HWND hWND) const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Relative mouse y coordinate. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <returns> Relative mouse y coordinate. </returns>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		int RelativeMouseY() const;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the double click delay. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="Delay"> The delay. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetDoubleClickDelay(const UINT Delay);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the global mouse position. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="X"> The x coordinate. </param>
		/// <param name="Y"> The y coordinate. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetMousePosGlobal(const UINT X, const UINT Y);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the relative mouse position. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		/// <param name="X">    The x coordinate. </param>
		/// <param name="Y">    The y coordinate. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetMousePosRelative(const HWND hWND, const int X, const int Y);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets a mouse position relative. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="X"> The x coordinate. </param>
		/// <param name="Y"> The y coordinate. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetMousePosRelative(const int X, const int Y);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Sets the hwnd. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="hWND"> The window. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void SetHWND(const HWND hWND);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Activates the key described by vkKey. </summary>
		///
		/// <remarks> Branflakes, 1/22/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void ActivateKey(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Deactivates a key. </summary>
		///
		/// <remarks> Branflakes, 1/20/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void DeactivateKey(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the keyboard. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void UpdateKeyboard();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the mouse. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void UpdateMouse();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the keyboard and mouse. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void Update();

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Updates the key described by vkKey. </summary>
		///
		/// <remarks> Branflakes, 1/17/2010. </remarks>
		///
		/// <param name="vkKey"> The virtual key. </param>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void UpdateKey(const BYTE vkKey);

		////////////////////////////////////////////////////////////////////////////////////////////////////
		/// <summary> Only updates the keys that are activated. </summary>
		///
		/// <remarks> Branflakes, 1/20/2010. </remarks>
		////////////////////////////////////////////////////////////////////////////////////////////////////
		void FastUpdate();
	};

}

(The only reason I'm putting Tools on this is because Input::InputState relies on it)

The Input::InputState class takes input to a new level and makes everything a lot easier, instead of just using dbKeyState() and dbMouseClick(). It can check if a (virtual) key is:
-Pressed
-Held(true after one loop after of being pressed)
-Down(pressed or held)
-Up(not pressed or held)
-Released(true for one loop after the key is released)
-DoubleClick(WORKS WITH KEYBOARD AND MOUSE!!! (Every virtual key))

The namespaces also do not rely on DarkGDK one bit, so you can use them in any application (although, Input classes need the windows message pump, so they will not work in a console application)

Comments were made with AtomineerUtils, if anyone is wondering.

Attached is the project for creating a static library with an example project.

Tell me what you think!

Your_Health = (My_Mood == HAPPY) ? 100 : NULL;

Attachments

Login to view attachments

Back to top

Profile PM Email

Matty H

15

Years of Service

User Offline

Joined: 7th Oct 2008

Location: England

Posted: 22nd Jan 2010 17:57

Link

This looks awesome, everyone needs to do this kind of thing at some point in their game/engine so this could come in real handy.
It puts my attempt at this kind of thing to shame lol.

Have not got time to try it out yet, exams.

I don't know if we could use this in dosp for S3GE as I think Techlord is doing the input, I will mention it to him though.

One question, I have only browsed through it but when you update keyboard, does it iterate through every key or is there a way of only updating the keys relevant to your game?

Back to top

Profile PM Email

Bran flakes91093

16

Years of Service

User Offline

Joined: 13th Sep 2008

Location: Crazy Land

Posted: 22nd Jan 2010 21:38 Edited at: 22nd Jan 2010 22:25

Link

That's actually one of the things I started thinking about right after I posted this.

It actually updates all 255 keys, which is really unnecessary, so I recently made an option for only updating the keys that have been checked for being down/pressed/etc. It stores whether each key has been activated, and only updates the ones that are activated, when FastUpdate() is called.

Here's the new project.

EDIT: IsKeyActive(), ActivateKey(), and DeactivateKey() added.

Your_Health = (My_Mood == HAPPY) ? 100 : NULL;

Attachments

Login to view attachments

Back to top

Profile PM Email

Freedom Fighters

14

Years of Service

User Offline

Joined: 2nd Nov 2009

Location:

Posted: 22nd Jan 2010 22:59 Edited at: 23rd Jan 2010 01:12

Link

looks awesome. im going to try it out for my game. looks like it may make things easy for me. nice job.

EDIT: how do i use it in my project?

Problem Solution That Never Fails: "Build A Bridge And Get Over It"

Back to top

Profile PM

Bran flakes91093

16

Years of Service

User Offline

Joined: 13th Sep 2008

Location: Crazy Land

Posted: 23rd Jan 2010 03:23 Edited at: 23rd Jan 2010 03:25

Link

Well, you can compile it (into a .lib file) and then include it into your project by one of three ways.

First, compile Utilities in Release mode, then open your project that you are trying to use Utilities with.

1 - (The global option)(and the easiest!

) - Go to Tools->(Options...)->[+]Projects and Solutions->(VC++ Directories) and choose 'Include files' from the drop down menu. Click the new folder icon and then click the three dot button [...] on the right side. Navigate to the Utilities folder and select "<...>\Utilities\Utilities". Now select "Library files" from the drop down list and repeat the process, but this time, choose "<...>\Utilities\Release". Now click OK. You are done! Now just include "Utilities.h" at the top of your project, or any other project, and it should work if done correctly.

2 - (The semi-global option) - Go to the solution explorer window and right click your solution file for the project you would like to use Utilities in. Click Add->(Existing Project...). Now navigate to where you have the Utilities folder and select this file: "<...>\Utilities\Utilities\Utilities.vcproj". Now just include "Utilities.h" at the top of your program that you wish to use Utilities with. You are done, and can edit the Utilities project and recompile it along with your program. You must repeat this for every new project you start if you want to use Utilities in more programs.

3 - (The local option) - Just copy/paste "Utilities.h", "Utilities.cpp", "Tools.h", and "Input.h". Include them into your project and just use them like any regular .h and .cpp files. Make sure the runtime is set to /MT. Done.

Your_Health = (My_Mood == HAPPY) ? 100 : NULL;

Back to top

Profile PM Email

Freedom Fighters

14

Years of Service

User Offline

Joined: 2nd Nov 2009

Location:

Posted: 23rd Jan 2010 11:08

Link

ok i choose your third option.

how do i then use it. i tried the code from the demo and it dont work. what do i need do to make it work. i use like 6 class for each part of my program that need the key imputs, can it be global?

Problem Solution That Never Fails: "Build A Bridge And Get Over It"

Back to top

Profile PM

Bran flakes91093

16

Years of Service

User Offline

Joined: 13th Sep 2008

Location: Crazy Land

Posted: 23rd Jan 2010 17:27

Link

Well make sure the files are included within the solution explorer window. (click "Show all files" and then right-click each one and select "Include in project", then click "Show all files again" - the files you included should stay)

What's the error?

If you want to use a global variable across multiple files, just use extern.

main.cpp

+ Code Snippet

#include "DarkGDK.h"
#include "globstruct.h" // For hWnd
#include "classes.h" // Your other file

void DarkGDK()
{
    dbSyncOn();
    dbSyncRate(0);

    inputState.SetHWND(g_pGlob->hWnd);

    while(LoopGDK())
    {
        inputState.FastUpdate();
    }
}

classes.h

+ Code Snippet

#pragma once
#include "Utilities.h"

extern Input::InputState inputState; // Declaration

classes.cpp

+ Code Snippet

#include "classes.h"

inputState = Input::InputState(); // Definition. Make sure it's only defined once.

// You can now access inputState from anywhere

Your_Health = (My_Mood == HAPPY) ? 100 : NULL;

Back to top

Profile PM Email

Freedom Fighters

14

Years of Service

User Offline

Joined: 2nd Nov 2009

Location:

Posted: 24th Jan 2010 02:43

Link

ok. i did what you said but got this error

+ Code Snippet

1>Class.cpp
1>c:\documents and settings\owner\my documents\c++ projects - gdk\freedomfighters - silent fury\class.cpp(3) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
1>c:\documents and settings\owner\my documents\c++ projects - gdk\freedomfighters - silent fury\class.cpp(3) : error C2371: 'inputState' : redefinition; different basic types
1>        c:\documents and settings\owner\my documents\c++ projects - gdk\freedomfighters - silent fury\utilities.h(13) : see declaration of 'inputState'
1>c:\documents and settings\owner\my documents\c++ projects - gdk\freedomfighters - silent fury\class.cpp(3) : error C2440: 'initializing' : cannot convert from 'Input::InputState' to 'int'
1>        No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

Problem Solution That Never Fails: "Build A Bridge And Get Over It"

Back to top

Profile PM

Bran flakes91093

16

Years of Service

User Offline

Joined: 13th Sep 2008

Location: Crazy Land

Posted: 24th Jan 2010 03:09

Link

Whoops - change classes.cpp:

classes.cpp

+ Code Snippet

#include "classes.h"

Input::InputState inputState = Input::InputState();

That should work.

Your_Health = (My_Mood == HAPPY) ? 100 : NULL;

Back to top

Profile PM Email

Freedom Fighters

14

Years of Service

User Offline

Joined: 2nd Nov 2009

Location:

Posted: 24th Jan 2010 03:15

Link

thanks. now it works. awesome.

Problem Solution That Never Fails: "Build A Bridge And Get Over It"

Back to top

Profile PM

Bran flakes91093

16

Years of Service

User Offline

Joined: 13th Sep 2008

Location: Crazy Land

Posted: 3rd Feb 2010 00:38 Edited at: 3rd Feb 2010 00:38

Link

Newer version with some fixed bugs.

Your_Health = (My_Mood == HAPPY) ? 100 : NULL;

Attachments

Login to view attachments

Back to top

Profile PM Email

Sorry your browser is not supported!

Dark GDK / Keyboard/Mouse Input class

Attachments

Attachments

Attachments