Merge branch 'New-inputsystem' of https://github.com/dean11/Danbias into Gtest

Code/DanBias.sln

@@ -776,5 +776,6 @@ Global
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE} = {1322B12B-5E37-448A-AAAF-F637460DCB23}
 		{604A12A7-07BF-4482-BDF3-7101C811F121} = {C83A6FAD-E71F-4B1E-9D63-E93E61DDC012}
 		{C8CBA520-5D7D-4D61-A8DA-6E05FD132BCB} = {C83A6FAD-E71F-4B1E-9D63-E93E61DDC012}
+		{67D0FB00-FF1F-4DE4-84BD-664AE93D25EE} = {C83A6FAD-E71F-4B1E-9D63-E93E61DDC012}
 	EndGlobalSection
 EndGlobal

Code/Game/GameClient/DanBiasGame_Impl.cpp

@@ -9,73 +9,88 @@
 #include "GameClientState\MainState.h"
 #include "GameClientState\LanMenuState.h"
 #include "GameClientState\NetLoadState.h"
+#include "Utilities.h"
 #include <Protocols.h>
 #include "NetworkClient.h"
 #include <GameServerAPI.h>
 
 #include "../WindowManager/WindowShell.h"
-#include "L_inputClass.h"
 #include "WinTimer.h"
 #include "vld.h"
 
 #include "EventHandler/EventHandler.h"
 
-#include "GameClientState\SharedStateContent.h"
+#include "GameClientState/SharedStateContent.h"
+#include "Utilities.h"
 
 using namespace ::Oyster;
 using namespace ::Oyster::Event;
 using namespace ::Oyster::Network;
 using namespace ::Utility::DynamicMemory;
 using namespace ::DanBias::Client;
+using namespace ::Utility::DynamicMemory;
 
+LRESULT CALLBACK WindowCallBack(HWND handle, UINT message, WPARAM wParam, LPARAM lParam );
 void ClientEventFunction( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e );
 
+#pragma region Game Data
 namespace DanBias
 {
-#pragma region Game Data
 	class DanBiasGamePrivateData
 	{
 	public:
 		WindowShell* window;
-		InputClass inputObj;
 		Utility::WinTimer timer;
 
 		UniquePointer<Client::GameClientState> state;
-		SharedStateContent sharedStateContent;
 		NetworkClient networkClient;
 
+		SharedStateContent sharedStateContent;
 
 		bool serverOwner;
 		float capFrame;
 
 		DanBiasGamePrivateData()
 		{
-			this->capFrame = 0;
+			this->sharedStateContent.network			= nullptr;
+			this->sharedStateContent.mouseDevice		= nullptr;
+			this->sharedStateContent.keyboardDevice		= nullptr;
+			this->sharedStateContent.mouseSensitivity	= Utility::Value::Radian( 0.1f );
+			this->serverOwner							= false;
+			this->capFrame								= 0;
+		}
+
+		~DanBiasGamePrivateData()
+		{
+			//SafeDeleteInstance( this->sharedStateContent.mouseDevice );
+			//SafeDeleteInstance( this->sharedStateContent.keyboardDevice );
 		}
 	} data;
-
+}
 #pragma endregion
 
-
+namespace DanBias
+{
 	//--------------------------------------------------------------------------------------
 	// Interface API functions
 	//--------------------------------------------------------------------------------------
-	DanBiasClientReturn DanBiasGame::Initiate(DanBiasGameDesc& desc)
+	DanBiasClientReturn DanBiasGame::Initiate( DanBiasGameDesc& desc )
 	{
 		WindowShell::CreateConsoleWindow();
 		//if(! data.window->CreateWin(WindowShell::WINDOW_INIT_DESC(L"Window", cPOINT(1600, 900), cPOINT())))
 
 		WindowShell::WINDOW_INIT_DESC winDesc;
-		winDesc.windowSize.x = 1280;
+		winDesc.windowSize.x		= 1920;
-		winDesc.windowSize.y = 720;
+		winDesc.windowSize.y		= 1080;
+		winDesc.windowProcCallback	= WindowCallBack;
 
 		if(! data.window->CreateWin(winDesc) )
 			return DanBiasClientReturn_Error;
 
-		if( FAILED( InitDirect3D() ) )
+		if( FAILED( InitInput(data.window->GetHWND()) ) )
 			return DanBiasClientReturn_Error;
 
-		if( FAILED( InitInput() ) )
+		if( FAILED( InitDirect3D() ) )
 			return DanBiasClientReturn_Error;
 
 		data.serverOwner = false;
@@ -83,7 +98,6 @@ namespace DanBias
 		data.networkClient.SetMessagePump( ClientEventFunction );
 
 		data.sharedStateContent.network = &data.networkClient;
-		data.sharedStateContent.input	= &data.inputObj;
 
 		// Start in main menu state
 		data.state = new Client::MainState();
@@ -138,11 +152,10 @@ namespace DanBias
 	//--------------------------------------------------------------------------------------
 	HRESULT DanBiasGame::InitDirect3D()
 	{
-		
 		Oyster::Graphics::API::Option p;
 		p.modelPath = L"..\\Content\\Models\\";
 		p.texturePath = L"..\\Content\\Textures\\";
-		p.Resolution = Oyster::Math::Float2( 1280.0f, 720.0f );
+		p.Resolution = Oyster::Math::Float2( 1920.0f, 1080.0f );
 		//! @todo fix proper amb value
 		p.AmbientValue = 1.3f;
 
@@ -154,35 +167,27 @@ namespace DanBias
 	//--------------------------------------------------------------------------------------
 	// Init the input
 	//-------------------------------------------------------------------------------------
-	HRESULT DanBiasGame::InitInput() 
+	HRESULT DanBiasGame::InitInput( HWND handle ) 
 	{
-		if(!data.inputObj.Initialize(data.window->GetHINSTANCE(), data.window->GetHWND(), data.window->GetHeight(), data.window->GetWidth()))
+		data.sharedStateContent.mouseDevice = dynamic_cast<Input::Mouse*>( ::Input::InputManager::Instance()->CreateDevice(Input::Enum::SAIType_Mouse, handle) );
+		if( !data.sharedStateContent.mouseDevice )
 		{
-			MessageBox(0, L"Could not initialize the input object.", L"Error", MB_OK);
+			MessageBox( 0, L"Could not initialize the mouseDevice.", L"Error", MB_OK );
 			return E_FAIL;
 		}
+		
+		data.sharedStateContent.keyboardDevice= dynamic_cast<Input::Keyboard*>( ::Input::InputManager::Instance()->CreateDevice(Input::Enum::SAIType_Keyboard, handle) );
+		if( !data.sharedStateContent.keyboardDevice )
+		{
+			MessageBox( 0, L"Could not initialize the raw keyboard device.", L"Error", MB_OK );
+			return E_FAIL;
+		}
+
 		return S_OK;
 	}
 	
 	DanBiasGame::Result DanBiasGame::Update(float deltaTime)
 	{
-		{ // updating mouse input
-		  // TODO: Is obosolete when Dennis's input system is wired in
-			POINT mousePos;
-			GetCursorPos( &mousePos );
-
-			RECT windowVertex;
-			GetWindowRect( data.window->GetHWND(), &windowVertex );
-
-			float mouseNormalisedX = (float)(mousePos.x - windowVertex.left);
-			mouseNormalisedX /= (float)(windowVertex.right - windowVertex.left);
-
-			float mouseNormalisedY = (float)(mousePos.y - windowVertex.top);
-			mouseNormalisedY /= (float)(windowVertex.bottom - windowVertex.top);
-
-			data.inputObj.Update( mouseNormalisedX, mouseNormalisedY );
-		}
-
 		if( data.serverOwner )
 		{
 			DanBias::GameServerAPI::ServerUpdate();
@@ -252,6 +257,8 @@ namespace DanBias
 			data.networkClient.Disconnect();
 
 		data.state = nullptr;
+
+		Input::InputManager::DestroyInputManager();
 		EventHandler::Instance().Clean();
 		Graphics::API::Clean();
 
@@ -262,6 +269,22 @@ namespace DanBias
 
 } //End namespace DanBias
 
+LRESULT CALLBACK WindowCallBack(HWND handle, UINT message, WPARAM wParam, LPARAM lParam )
+{
+	switch ( message ) 
+	{
+		case WM_DESTROY:
+			PostQuitMessage( 0 );
+		break;
+		case WM_INPUT:
+			message = 0;
+		break;
+		default: break;
+	}
+
+	return DefWindowProc( handle, message, wParam, lParam );
+}
+
 void ClientEventFunction( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e )
 {
 	if( DanBias::data.state )

Code/Game/GameClient/GameClient.vcxproj

@@ -106,7 +106,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>DANBIAS_GAME_DLL_EXPORT;WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input\Include;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -123,7 +123,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>DANBIAS_GAME_DLL_EXPORT;WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input\Include;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -142,7 +142,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>DANBIAS_GAME_DLL_EXPORT;WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input\Include;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -163,7 +163,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>DANBIAS_GAME_DLL_EXPORT;WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input\Include;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -253,10 +253,12 @@
     <ClInclude Include="GameClientState\RespawnUI.h" />
     <ClInclude Include="GameClientState\SharedStateContent.h" />
     <ClInclude Include="GameClientState\StatsUI.h" />
+    <ClInclude Include="Include\DanBiasGame.h" />
     <ClInclude Include="Include\GameClient.h" />
     <ClInclude Include="GameClientState\LobbyState.h" />
     <ClInclude Include="GameClientState\C_Object.h" />
     <ClInclude Include="GameClientState\Buttons\TextField.h" />
+    <ClInclude Include="Win32Input.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Code/Game/GameClient/GameClientState/Buttons/TextField.h

@@ -78,7 +78,7 @@ namespace DanBias { namespace Client
 	{
 		::Oyster::Math::Float lineStep = this->fontHeight + this->lineSpacing;
 		::Oyster::Math::Float2 rowSize = ::Oyster::Math::Float2( this->size.x, this->fontHeight );
-		::Oyster::Math::Float3 fieldTopLeft = this->pos - Float3( this->size * 0.25f, 0.0f );
+		::Oyster::Math::Float3 fieldTopLeft = this->pos - Float3( this->size * 0.25f, 0.001f );
 		::Oyster::Math::Float3 topLeft = fieldTopLeft;
 
 		if( this->isBottomAligned )

Code/Game/GameClient/GameClientState/GameState.cpp

@@ -27,7 +27,8 @@ struct  GameState::MyData
 	MyData(){}
 	GameClientState::ClientState nextState;
 	NetworkClient *nwClient;
-	InputClass *input;
+	::Input::Mouse *mouseInput;
+	::Input::Keyboard *keyboardInput;
 
 	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_StaticObj>> *staticObjects;
 	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_DynamicObj>> *dynamicObjects;
@@ -66,7 +67,8 @@ bool GameState::Init( SharedStateContent &shared )
 
 	this->privData->nextState = GameClientState::ClientState_Same;
 	this->privData->nwClient = shared.network;
-	this->privData->input = shared.input;
+	this->privData->mouseInput = shared.mouseDevice;
+	this->privData->keyboardInput = shared.keyboardDevice;
 	this->privData->staticObjects = &shared.staticObjects;
 	this->privData->dynamicObjects = &shared.dynamicObjects;
 	this->privData->lights = &shared.lights;
@@ -86,15 +88,14 @@ bool GameState::Init( SharedStateContent &shared )
 	gfxOp.GlobalTint = Math::Float3(1,1,1);
 	Graphics::API::SetOptions(gfxOp);
 
-	//tell server ready
-	this->privData->nwClient->Send( Protocol_General_Status(Protocol_General_Status::States_ready) );
-			
 	// DEGUG KEYS
 	this->key_Reload_Shaders = false;
 	this->key_Wireframe_Toggle = false;
 	this->renderWhireframe = false;
 	// !DEGUG KEYS
 
+	shared.keyboardDevice->ReleaseTextTarget();
+
 	auto light = this->privData->lights->begin();
 	for( ; light != this->privData->lights->end(); ++light )
 	{
@@ -102,7 +103,7 @@ bool GameState::Init( SharedStateContent &shared )
 	}
 
 	// create UI states
-	this->gameUI = new GamingUI(this->privData->input, this->privData->nwClient, &this->privData->camera);
+	this->gameUI = new GamingUI(&shared, &this->privData->camera);
 	this->respawnUI = new RespawnUI(this->privData->nwClient, 20);
 	this->statsUI = new StatsUI();
 	this->currGameUI = gameUI; 
@@ -110,6 +111,9 @@ bool GameState::Init( SharedStateContent &shared )
 	((RespawnUI*)respawnUI)->Init();
 	((StatsUI*)statsUI)->Init();
 
+	//tell server ready
+	this->privData->nwClient->Send( Protocol_General_Status(Protocol_General_Status::States_ready) );
+
 	return true;
 }
 
@@ -215,8 +219,7 @@ bool GameState::Render()
 		}
 	}
 
-#ifdef _DEBUG
+#ifdef _DEBUG //RB DEBUG render wire frame 
-	//RB DEBUG render wire frame 
 		if(this->renderWhireframe)
 		{
 			Oyster::Graphics::API::StartRenderWireFrame();
@@ -266,8 +269,7 @@ bool GameState::Render()
 				}
 			}
 		}
-		//!RB DEBUG 
+#endif //!RB DEBUG 
-#endif
 
 	Oyster::Graphics::API::StartGuiRender();
 	// render gui elemnts
@@ -333,6 +335,7 @@ bool GameState::Release()
 		delete respawnUI;
 		respawnUI = NULL;
 	}
+	
 	if(gameUI)
 	{
 		gameUI->Release();
@@ -354,18 +357,19 @@ void GameState::ChangeState( ClientState next )
 {
 	this->privData->nextState = next;
 }
+
 void GameState::ReadKeyInput()
 {
-	// DEGUG KEYS
+#ifdef _DEBUG // DEGUG KEYS
 
 	// Reload shaders
-	if( this->privData->input->IsKeyPressed(DIK_R) )
+	if( this->privData->keyboardInput->IsKeyDown(::Input::Enum::SAKI_R) )
 	{
 		if( !this->key_Reload_Shaders )
 		{
-#ifdef _DEBUG
+
-			Oyster::Graphics::API::ReloadShaders();
+			Graphics::API::ReloadShaders();
-#endif
+
 			this->key_Reload_Shaders = true;
 		}
 	} 
@@ -373,7 +377,7 @@ void GameState::ReadKeyInput()
 		this->key_Reload_Shaders = false;
 
 	// toggle wire frame render
-	if( this->privData->input->IsKeyPressed(DIK_T) )
+	if( this->privData->keyboardInput->IsKeyDown(::Input::Enum::SAKI_T) )
 	{
 		if( !this->key_Wireframe_Toggle )
 		{
@@ -391,9 +395,10 @@ void GameState::ReadKeyInput()
 		this->currGameUI = gameUI;
 		// !DEBUG
 	}
+#endif // !DEGUG KEYS
 
 	// toggle wire frame render
-	if( this->privData->input->IsKeyPressed(DIK_TAB) )
+	if( this->privData->keyboardInput->IsKeyDown(::Input::Enum::SAKI_Tab) )
 	{
 		if( !this->key_showStats )
 		{

Code/Game/GameClient/GameClientState/GameStateUI.h

@@ -42,17 +42,4 @@ namespace DanBias { namespace Client
 	};
 } }
 
-namespace Utility { namespace DynamicMemory
-{ // template specializationto allowuse of dynamicmemory tools
-	template<>
-	inline void SafeDeleteInstance( ::DanBias::Client::GameStateUI *dynamicInstance )
-	{
-		if( dynamicInstance )
-		{
-			dynamicInstance->Release();
-			delete dynamicInstance;
-		}
-	}
-} }
-
 #endif

Code/Game/GameClient/GameClientState/GamingUI.cpp

@@ -7,23 +7,22 @@ using namespace ::Oyster::Network;
 using namespace ::GameLogic;
 using namespace ::Utility::Value;
 using namespace ::Oyster::Math;
+using namespace ::Input;
 
 GamingUI::GamingUI() :
 	GameStateUI()
 {
 	/* Should never be called! */
-	this->input = nullptr;
+	this->sharedData	= nullptr;
-	this->netClient = nullptr;
+	this->camera		= nullptr;
-	this->camera = nullptr;
+	this->plane			= nullptr;
-	this->plane	= nullptr;
+	this->text			= nullptr;
-	this->text	= nullptr;
 }
 
-GamingUI::GamingUI( InputClass *input, NetworkClient *connection, Camera_FPSV2 *camera ) :
+GamingUI::GamingUI( SharedStateContent* shared, Camera_FPSV2 *camera ) :
 	GameStateUI()
 {
-	this->input = input;
+	this->sharedData = shared;
-	this->netClient = connection;
 	this->camera = camera;
 }
 
@@ -33,7 +32,14 @@ bool GamingUI::Init()
 	// z value should be between 0.5 - 0.9 so that it will be behind other states
 	// add textures and text
 	this->plane	=  new Plane_UI(L"box_tex.png", Float3(0.5f, 0.0f, 0.5f), Float2(0.3f, 0.1f));
-	this->text	=  new Text_UI(L"hej", Float3(0.3f,0.0f,0.1f), Float2(0.1f,0.1f));
+	this->text	=  new Text_UI(L"hej", Float3(0.5f,0.0f,0.1f), Float2(0.1f,0.1f));
+
+	this->sharedData = sharedData;
+
+	// setting input mode to all raw
+	this->sharedData->keyboardDevice->Activate();
+	this->sharedData->mouseDevice->Activate();
+	this->sharedData->mouseDevice->AddMouseEvent(this);
 
 	return true; 
 }
@@ -70,6 +76,9 @@ bool GamingUI::Release()
 		delete this->plane;
 	if(this->text)
 		delete this->text;
+
+	this->sharedData = 0;
+
 	return true;
 }
 void GamingUI::SetHPtext( std::wstring hp )
@@ -78,39 +87,39 @@ void GamingUI::SetHPtext( std::wstring hp )
 }
 void GamingUI::ReadKeyInput()
 {
-	if( this->input->IsKeyPressed(DIK_W) )
+	if( this->sharedData->keyboardDevice->IsKeyDown(::Input::Enum::SAKI_W) )
-	{
+	{ // move forward
-		this->netClient->Send( Protocol_PlayerMovementForward() );
+		this->sharedData->network->Send( Protocol_PlayerMovementForward() );
 	}
 
-	if( this->input->IsKeyPressed(DIK_S) )
+	if( this->sharedData->keyboardDevice->IsKeyDown(::Input::Enum::SAKI_S) )
-	{
+	{ // move backward
-		this->netClient->Send( Protocol_PlayerMovementBackward() );
+		this->sharedData->network->Send( Protocol_PlayerMovementBackward() );
 	}
 
-	if( this->input->IsKeyPressed(DIK_A) )
+	if( this->sharedData->keyboardDevice->IsKeyDown(::Input::Enum::SAKI_A) )
-	{
+	{ // strafe left
-		this->netClient->Send( Protocol_PlayerMovementLeft() );
+		this->sharedData->network->Send( Protocol_PlayerMovementLeft() );
 	}
 
-	if( this->input->IsKeyPressed(DIK_D) )
+	if( this->sharedData->keyboardDevice->IsKeyDown(::Input::Enum::SAKI_D) )
-	{
+	{ // strafe right
-		this->netClient->Send( Protocol_PlayerMovementRight() );
+		this->sharedData->network->Send( Protocol_PlayerMovementRight() );
 	}
 
-//send delta mouse movement 
+	if( this->sharedData->keyboardDevice->IsKeyDown(::Input::Enum::SAKI_Space) )
-	{
+	{ // jump
-		static const float mouseSensitivity = Radian( 1.0f );
+		if(!this->key_Jump)
-		this->camera->PitchDown( this->input->GetPitch() * mouseSensitivity );
-		float yaw = this->input->GetYaw();
-		//if( yaw != 0.0f )	//This made the camera reset to a specific rotation.
 		{
-			this->netClient->Send( Protocol_PlayerLeftTurn(yaw * mouseSensitivity,camera->GetLook()) );
+			this->sharedData->network->Send( Protocol_PlayerJump() );
+			this->key_Jump = true;
 		}
 	}
+	else 
+		this->key_Jump = false;
 
 	// shoot
-	if( this->input->IsKeyPressed(DIK_Z) )
+	if( this->sharedData->mouseDevice->IsBtnDown(::Input::Enum::SAMI_MouseLeftBtn) )
 	{
 		if( !this->key_Shoot )
 		{
@@ -118,13 +127,14 @@ void GamingUI::ReadKeyInput()
 			playerShot.primaryPressed = true;
 			playerShot.secondaryPressed = false;
 			playerShot.utilityPressed = false;
-			this->netClient->Send( playerShot );
+			this->sharedData->network->Send( playerShot );
 			this->key_Shoot = true;
 		}
 	} 
 	else 
 		this->key_Shoot = false;
-	if( this->input->IsKeyPressed(DIK_X) )
+	
+	if( this->sharedData->mouseDevice->IsBtnDown(::Input::Enum::SAMI_MouseRightBtn) )
 	{
 		if( !this->key_Shoot )
 		{
@@ -132,13 +142,14 @@ void GamingUI::ReadKeyInput()
 			playerShot.primaryPressed = false;
 			playerShot.secondaryPressed = true;
 			playerShot.utilityPressed = false;
-			this->netClient->Send( playerShot );
+			this->sharedData->network->Send( playerShot );
 			this->key_Shoot = true;
 		}
 	} 
 	else 
 		this->key_Shoot = false;
-	if( this->input->IsKeyPressed(DIK_C) )
+	
+	if( this->sharedData->mouseDevice->IsBtnDown(::Input::Enum::SAMI_MouseMiddleBtn) )
 	{
 		if( !this->key_Shoot )
 		{
@@ -146,30 +157,28 @@ void GamingUI::ReadKeyInput()
 			playerShot.primaryPressed = false;
 			playerShot.secondaryPressed = false;
 			playerShot.utilityPressed = true;
-			this->netClient->Send( playerShot );
+			this->sharedData->network->Send( playerShot );
 			this->key_Shoot = true;
 		}
 	} 
 	else 
 		this->key_Shoot = false;
 
-	// jump
+	if( this->sharedData->keyboardDevice->IsKeyDown(::Input::Enum::SAKI_Escape) )
-	if( this->input->IsKeyPressed(DIK_SPACE) )
-	{
-		if(!this->key_Jump)
-		{
-			this->netClient->Send( Protocol_PlayerJump() );
-			this->key_Jump = true;
-		}
-	}
-	else 
-		this->key_Jump = false;
-
-	if( this->input->IsKeyPressed(DIK_ESCAPE) )
 	{
 		this->nextState = GameStateUI::UIState_shut_down;
 	} 
-	// !DEGUG KEYS
-	// TODO: implement sub-menu
 }
 
+
+void GamingUI::OnMouseMoveVelocity ( Input::Struct::SAIPointInt2D coordinate, Input::Mouse* sender )
+{ 
+	//send delta mouse movement 
+	{
+		this->camera->PitchDown( (-coordinate.y) * this->sharedData->mouseSensitivity );;
+		//if( deltaPos.x != 0.0f ) //This made the camera reset to a specific rotation. Why?
+		{
+			this->sharedData->network->Send( Protocol_PlayerLeftTurn((coordinate.x) * this->sharedData->mouseSensitivity, this->camera->GetLook()) );
+		}
+	}
+}

Code/Game/GameClient/GameClientState/GamingUI.h

@@ -2,17 +2,19 @@
 #define DANBIAS_CLIENT_GAMING_UI_H
 
 #include "GameStateUI.h"
-#include "L_inputClass.h"
+#include "Input.h"
 #include "Camera_FPSV2.h"
 #include "Buttons\Text_UI.h"
 #include "Buttons\Plane_UI.h"
+#include "InputManager.h"
+#include "SharedStateContent.h"
 
 namespace DanBias { namespace Client
 {
-	class GamingUI : public GameStateUI
+	class GamingUI : public GameStateUI, Input::Mouse::MouseEvent
 	{
 	public:
-		GamingUI( InputClass *input, ::Oyster::Network::NetworkClient *connection, Camera_FPSV2 *camera );
+		GamingUI( SharedStateContent* shared, Camera_FPSV2 *camera );
 		virtual ~GamingUI();
 		bool Init();
 
@@ -24,9 +26,17 @@ namespace DanBias { namespace Client
 		bool Release();
 		void SetHPtext( std::wstring hp );
 
+	private: /* Overidden mouse methods */
+		void OnMouse				( const Input::Struct::MouseEventData& eventData )						override { }
+		void OnMousePress			( Input::Enum::SAMI key, Input::Mouse* sender )							override { }
+		void OnMouseDown			( Input::Enum::SAMI key, Input::Mouse* sender )							override { }
+		void OnMouseRelease			( Input::Enum::SAMI key, Input::Mouse* sender )							override { }
+		void OnMouseMovePixelPos	( Input::Struct::SAIPointInt2D coordinate, Input::Mouse* sender )		override { }
+		void OnMouseMoveVelocity	( Input::Struct::SAIPointInt2D coordinate, Input::Mouse* sender )		override;
+		void OnMouseScroll			( int delta, Input::Mouse* sender )										override { }
+
 	private:
-		InputClass *input;
+		SharedStateContent *sharedData;
-		::Oyster::Network::NetworkClient *netClient;
 		Camera_FPSV2 *camera;
 
 		// TODO add multiple UI elements

Code/Game/GameClient/GameClientState/LanMenuState.cpp

@@ -9,6 +9,8 @@
 #include "GameState.h"
 #include "../Network/NetworkAPI/NetworkClient.h"
 
+#include <Protocols.h>
+
 #include "EventHandler\EventHandler.h"
 #include "Buttons\ButtonRectangle.h"
 #include "Buttons\TextField.h"
@@ -21,6 +23,7 @@ using namespace ::Oyster;
 using namespace ::Oyster::Network;
 using namespace ::Oyster::Event;
 using namespace ::Oyster::Math3D;
+using namespace ::GameLogic;
 
 struct  LanMenuState::MyData
 {
@@ -28,12 +31,17 @@ struct  LanMenuState::MyData
 
 	GameClientState::ClientState nextState;
 	NetworkClient *nwClient;
-	InputClass *input;
+	::Input::Mouse *mouseInput;
-	Graphics::API::Texture background;
+	::Input::Keyboard *keyboardInput;
+	Float3 mousePos;
+	Graphics::API::Texture background, mouseCursor;
 	EventButtonCollection guiElements;
 
 	TextField<LanMenuState*> *connectIP;
 	unsigned short connectPort;
+
+	std::string ip;
+
 } privData;
 
 void OnButtonInteract_Connect( Oyster::Event::ButtonEvent<LanMenuState*>& e );
@@ -53,28 +61,29 @@ bool LanMenuState::Init( SharedStateContent &shared )
 
 	this->privData->nextState = GameClientState::ClientState_Same;
 	this->privData->nwClient = shared.network;
-	this->privData->input = shared.input;
+	this->privData->mouseInput = shared.mouseDevice;
+	this->privData->keyboardInput = shared.keyboardDevice;
 
 	this->privData->background = Graphics::API::CreateTexture( L"color_white.png" );
+	this->privData->mouseCursor = Graphics::API::CreateTexture( L"cursor.png" );
 
 	// create guiElements
-	this->privData->connectIP = new TextField<LanMenuState*>( L"color_white.png", Float4(1.0f), Float4(0.0f), this, Float3(0.5f, 0.3f, 0.5f), Float2(0.8f, 0.09f), ResizeAspectRatio_None );
+	this->privData->connectIP = new TextField<LanMenuState*>( L"noedge-btn-ipfield.png", Float4(1.0f), Float4(1.0f), this, Float3(0.5f, 0.2f, 0.9f), Float2(0.5f, 0.05f), ResizeAspectRatio_Height );
 	this->privData->connectIP->ReserveLines( 1 );
 	this->privData->connectIP->AppendText( L"127.0.0.1" );
 	//this->privData->connectIP->AppendText( L"194.47.150.206" ); // HACK: connecting to Dennis's server
 	//this->privData->connectIP->AppendText( L"194.47.150.189" ); // HACK: connecting to Robins server
-
+	this->privData->connectIP->SetFontHeight( 0.035f );
-	this->privData->connectIP->SetFontHeight( 0.08f );
 	this->privData->connectIP->SetLineSpacing( 0.005f );
-	this->privData->connectIP->SetTopAligned();
+	this->privData->connectIP->SetBottomAligned();
 	
 	this->privData->guiElements.AddButton( this->privData->connectIP );
 
 	ButtonRectangle<LanMenuState*> *guiElements;
-	guiElements = new ButtonRectangle<LanMenuState*>( L"color_white.png", L"Connect", Float4(1.0f),Float4(0.0f),Float4(0.0f),Float4(0.0f), OnButtonInteract_Connect, this, Float3(0.5f, 0.4f, 0.5f), Float2(0.3f, 0.05f), ResizeAspectRatio_None );
+	guiElements = new ButtonRectangle<LanMenuState*>( L"noedge-btn-join.png", L"", Float4(1.0f),Float4(1.0f),Float4(1.2f),Float4(1.5f), OnButtonInteract_Connect, this, Float3(0.5f, 0.4f, 0.5f), Float2(0.5f, 0.18f), ResizeAspectRatio_None );
 	this->privData->guiElements.AddButton( guiElements );
 
-	guiElements = new ButtonRectangle<LanMenuState*>( L"color_white.png", L"Exit", Float4(1.0f),Float4(0.0f),Float4(0.0f),Float4(0.0f), OnButtonInteract_Exit, this, Float3(0.5f, 0.5f, 0.5f), Float2(0.3f, 0.05f), ResizeAspectRatio_None );
+	guiElements = new ButtonRectangle<LanMenuState*>( L"noedge-btn-back.png", L"", Float4(1.0f),Float4(1.0f),Float4(1.2f),Float4(1.5f), OnButtonInteract_Exit, this, Float3(0.5f, 0.8f, 0.5f), Float2(0.5f, 0.18f), ResizeAspectRatio_None );
 	this->privData->guiElements.AddButton( guiElements );
 
 	// bind guiElements collection to the singleton eventhandler
@@ -82,6 +91,14 @@ bool LanMenuState::Init( SharedStateContent &shared )
 
 	this->privData->connectPort = 15151;
 
+	this->privData->keyboardInput->BindTextTarget( &(*this->privData->connectIP)[0] );
+	this->privData->keyboardInput->Activate();
+
+	if(!this->privData->nwClient->StartListeningForBroadcasting(this->privData->connectPort))
+	{
+		return false;
+	}
+
 	return true;
 }
 
@@ -89,12 +106,17 @@ GameClientState::ClientState LanMenuState::Update( float deltaTime )
 {
 	MouseInput mouseState;
 	{
-		this->privData->input->GetMousePos( mouseState.x, mouseState.y );
+		::Input::Struct::SAIPointFloat2D pos;
-		mouseState.mouseButtonPressed = this->privData->input->IsMousePressed();
+		this->privData->mouseInput->GetNormalizedPosition( pos );
-	}
 
+		this->privData->mousePos.x = mouseState.x = pos.x;
+		this->privData->mousePos.y = mouseState.y = pos.y;
+		mouseState.mouseButtonPressed = this->privData->mouseInput->IsBtnDown( ::Input::Enum::SAMI_MouseLeftBtn );
+	}
 	EventHandler::Instance().Update( mouseState );
 
+	this->privData->nwClient->Update();
+
 	return this->privData->nextState;
 }
 
@@ -104,6 +126,7 @@ bool LanMenuState::Render( )
 
 	Graphics::API::StartGuiRender();
 
+	Graphics::API::RenderGuiElement( this->privData->mouseCursor, this->privData->mousePos, Float2(0.15f, 0.24), Float4(1.0f) );
 	Graphics::API::RenderGuiElement( this->privData->background, Float3(0.5f, 0.5f, 1.0f), Float2(1.0f) );
 	this->privData->guiElements.RenderTexture();
 
@@ -116,6 +139,11 @@ bool LanMenuState::Render( )
 
 bool LanMenuState::Release()
 {
+	if(privData)
+	{
+		this->privData->nwClient->StopListeningForBroadcasting();
+	}
+
 	privData = NULL;
 	return true;
 }
@@ -124,7 +152,7 @@ void LanMenuState::ChangeState( ClientState next )
 {
 	switch( next )
 	{
-	case GameClientState::ClientState_Lobby:
+	case GameClientState::ClientState_NetLoad:
 		// attempt to connect to lobby
 		if( !this->privData->nwClient->Connect(this->privData->connectPort, (*this->privData->connectIP)[0]) )
 			return;
@@ -132,6 +160,8 @@ void LanMenuState::ChangeState( ClientState next )
 	default: break;
 	}
 
+	this->privData->keyboardInput->ReleaseTextTarget();
+
 	this->privData->nextState = next;
 }
 
@@ -140,7 +170,7 @@ void OnButtonInteract_Connect( Oyster::Event::ButtonEvent<LanMenuState*>& e )
 	switch( e.state )
 	{
 	case ButtonState_Released:
-		e.owner->ChangeState( GameClientState::ClientState_Lobby );
+		e.owner->ChangeState( GameClientState::ClientState_NetLoad );
 		break;
 	default: break;
 	}
@@ -156,3 +186,41 @@ void OnButtonInteract_Exit( Oyster::Event::ButtonEvent<LanMenuState*>& e )
 	default: break;
 	}
 }
+
+const GameClientState::NetEvent& LanMenuState::DataRecieved( const NetEvent &message )
+{
+	if( message.args.type == NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend )
+	{ // TODO: Reconnect
+		const char *breakpoint = "temp trap";
+		this->privData->nwClient->Disconnect();
+		this->ChangeState( GameClientState::ClientState_Main );
+	}
+
+	// fetching the id data.
+	short ID = message.args.data.protocol[0].value.netShort;
+
+	CustomNetProtocol data = message.args.data.protocol;
+
+	switch(ID)
+	{
+	case protocol_Broadcast_Test:
+		{
+			Protocol_Broadcast_Test decoded(data);
+
+			unsigned short port = decoded.port;
+			std::string ip = decoded.ip;
+			std::string name = decoded.name;
+			printf("Broadcast message: %d: %s: %s\n", port, ip.c_str(), name.c_str());
+
+			//this->privData->connectPort = port;
+			//this->privData->ip = ip;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+
+	return message;
+}

Code/Game/GameClient/GameClientState/LanMenuState.h

@@ -21,6 +21,8 @@ namespace DanBias
 			virtual bool Release();
 			void ChangeState( ClientState next );
 			
+			virtual const NetEvent & DataRecieved( const NetEvent &message );
+
 		private:
 			struct MyData;
 			::Utility::DynamicMemory::UniquePointer<MyData> privData;

Code/Game/GameClient/GameClientState/LobbyAdminState.cpp

@@ -22,7 +22,7 @@ struct LobbyAdminState::MyData
 
 	GameClientState::ClientState nextState;
 	NetworkClient *nwClient;
-	InputClass *input;
+	::Input::Mouse *mouseInput;
 	Graphics::API::Texture background;
 	EventButtonCollection guiElements;
 } privData;
@@ -43,7 +43,7 @@ bool LobbyAdminState::Init( SharedStateContent &shared )
 
 	this->privData->nextState = GameClientState::ClientState_Same;
 	this->privData->nwClient = shared.network;
-	this->privData->input = shared.input;
+	this->privData->mouseInput = shared.mouseDevice;
 
 	this->privData->background = Graphics::API::CreateTexture( L"grass_md.png" );
 
@@ -61,21 +61,15 @@ bool LobbyAdminState::Init( SharedStateContent &shared )
 
 GameClientState::ClientState LobbyAdminState::Update( float deltaTime )
 {
-	// Wishlist:
-	// picking 
-	// mouse events
-	// different menus
-	// play sounds
-	// update animation
-	// send data to server
-	// check data from server
-
 	MouseInput mouseState;
 	{
-		this->privData->input->GetMousePos( mouseState.x, mouseState.y );
+		::Input::Struct::SAIPointInt2D pos;
-		mouseState.mouseButtonPressed = this->privData->input->IsMousePressed();
+		this->privData->mouseInput->GetPixelPosition( pos );
-	}
 
+		mouseState.x = pos.x;
+		mouseState.y = pos.y;
+		mouseState.mouseButtonPressed = this->privData->mouseInput->IsBtnDown( ::Input::Enum::SAMI_MouseLeftBtn );
+	}
 	EventHandler::Instance().Update( mouseState );
 
 	return this->privData->nextState;

Code/Game/GameClient/GameClientState/LobbyState.cpp

@@ -22,8 +22,9 @@ struct LobbyState::MyData
 
 	GameClientState::ClientState nextState;
 	NetworkClient *nwClient;
-	InputClass *input;
+	::Input::Mouse *mouseInput;
-	Graphics::API::Texture background;
+	Float3 mousePos;
+	Graphics::API::Texture background, mouseCursor;;
 	EventButtonCollection guiElements;
 } privData;
 
@@ -43,9 +44,10 @@ bool LobbyState::Init( SharedStateContent &shared )
 
 	this->privData->nextState = GameClientState::ClientState_Same;
 	this->privData->nwClient = shared.network;
-	this->privData->input = shared.input;
+	this->privData->mouseInput = shared.mouseDevice;
 
 	this->privData->background = Graphics::API::CreateTexture( L"grass_md.png" );
+	this->privData->mouseCursor = Graphics::API::CreateTexture( L"cursor_md.png" );
 
 	// create buttons
 	ButtonRectangle<LobbyState*> *button;
@@ -61,21 +63,15 @@ bool LobbyState::Init( SharedStateContent &shared )
 
 GameClientState::ClientState LobbyState::Update( float deltaTime )
 {
-	// Wishlist:
-	// picking 
-	// mouse events
-	// different menus
-	// play sounds
-	// update animation
-	// send data to server
-	// check data from server
-
 	MouseInput mouseState;
 	{
-		this->privData->input->GetMousePos( mouseState.x, mouseState.y );
+		::Input::Struct::SAIPointFloat2D pos;
-		mouseState.mouseButtonPressed = this->privData->input->IsMousePressed();
+		this->privData->mouseInput->GetNormalizedPosition( pos );
-	}
 
+		this->privData->mousePos.x = mouseState.x = pos.x;
+		this->privData->mousePos.y = mouseState.y = pos.y;
+		mouseState.mouseButtonPressed = this->privData->mouseInput->IsBtnDown( ::Input::Enum::SAMI_MouseLeftBtn );
+	}
 	EventHandler::Instance().Update( mouseState );
 
 	return this->privData->nextState;
@@ -85,6 +81,7 @@ bool LobbyState::Render( )
 	Graphics::API::NewFrame();
 	Graphics::API::StartGuiRender();
 
+	Graphics::API::RenderGuiElement( this->privData->mouseCursor, this->privData->mousePos, Float2(0.01f), Float4(1.0f) );
 	Graphics::API::RenderGuiElement( this->privData->background, Float3(0.5f, 0.5f, 1.0f), Float2(1.0f) );
 	this->privData->guiElements.RenderTexture();
 

Code/Game/GameClient/GameClientState/MainState.cpp

@@ -9,6 +9,7 @@
 
 #include "EventHandler\EventHandler.h"
 #include "Buttons\ButtonRectangle.h"
+#include "Buttons\ButtonEllipse.h"
 
 using namespace ::DanBias::Client;
 using namespace ::Oyster;
@@ -24,12 +25,14 @@ struct MainState::MyData
 
 	GameClientState::ClientState nextState;
 	NetworkClient *nwClient;
-	InputClass *input;
+	::Input::Mouse *mouseInput;
-	Graphics::API::Texture background;
+	Float3 mousePos;
+	Graphics::API::Texture background, mouseCursor;
 	EventButtonCollection guiElements;
 };
 
 void OnButtonInteract_Create( Oyster::Event::ButtonEvent<MainState*>& e );
+void OnButtonInteract_Settings( Oyster::Event::ButtonEvent<MainState*>& e );
 void OnButtonInteract_Join( Oyster::Event::ButtonEvent<MainState*>& e );
 void OnButtonInteract_Quit( Oyster::Event::ButtonEvent<MainState*>& e );
 
@@ -47,24 +50,30 @@ bool MainState::Init( SharedStateContent &shared )
 
 	this->privData->nextState = GameClientState::ClientState_Same;
 	this->privData->nwClient = shared.network;
-	this->privData->input = shared.input;
+	this->privData->mouseInput = shared.mouseDevice;
+	//this->privData->mouseInput->
+	this->privData->mousePos = Float3( 0.0f );
 
 	this->privData->background = Graphics::API::CreateTexture( L"color_white.png" );
+	this->privData->mouseCursor = Graphics::API::CreateTexture( L"cursor.png" );
 
 	// create buttons
 	ButtonRectangle<MainState*> *button;
-	Float4 TextCol = Float4(1.0f,0.0f,1.0f,1.0f);
+	Float4 TextCol = Float4(0.1f,0.1f,0.1f,1.0f);
-	Float4 BackCol = Float4(1.0f,1.0f,1.0f,0.5f);
+	Float4 BackCol = Float4(1.0f);
-	Float4 HoverCol = Float4(0.0f,1.0f,0.0f,1.0f);
+	Float4 HoverCol = Float4(1.2f);
-	Float4 PressCol = Float4(0.0f,0.0f,1.0f,1.0f);
+	Float4 PressCol = Float4(1.5f);
 	
-	button = new ButtonRectangle<MainState*>( L"color_white.png", L"Create",TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Create, this, Float3(0.5f, 0.2f, 0.5f), Float2(0.3f, 0.1f));
+	//button = new ButtonRectangle<MainState*>( L"color_white.png", L"Create",TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Create, this, Float3(0.5f, 0.2f, 0.5f), Float2(0.3f, 0.1f));
+	//this->privData->guiElements.AddButton( button );
+
+	button = new ButtonRectangle<MainState*>( L"noedge-btn-lan.png", L"", TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Join, this, Float3(0.5f, 0.2f, 0.5f), Float2(0.5f, 0.18f));
 	this->privData->guiElements.AddButton( button );
 
-	button = new ButtonRectangle<MainState*>( L"color_white.png", L"Join", TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Join, this, Float3(0.5f, 0.4f, 0.5f), Float2(0.3f, 0.1f));
+	button = new ButtonRectangle<MainState*>( L"noedge-btn-settings.png", L"", TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Settings, this, Float3(0.5f, 0.4f, 0.5f), Float2(0.5f, 0.18f));
 	this->privData->guiElements.AddButton( button );
 
-	button = new ButtonRectangle<MainState*>( L"color_white.png", L"Quit", TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Quit, this, Float3(0.5f, 0.8f, 0.5f), Float2(0.3f, 0.1f));
+	button = new ButtonRectangle<MainState*>( L"noedge-btn-quit.png", L"", TextCol, BackCol, HoverCol, PressCol, OnButtonInteract_Quit, this, Float3(0.5f, 0.8f, 0.5f), Float2(0.5f, 0.18f));
 	this->privData->guiElements.AddButton( button );
 
 	// bind button collection to the singleton eventhandler
@@ -77,16 +86,13 @@ GameClientState::ClientState MainState::Update( float deltaTime )
 {
 	MouseInput mouseState;
 	{
-		bool test = this->privData->input->IsMousePressed();
+		::Input::Struct::SAIPointFloat2D pos;
-		if(test)
+		this->privData->mouseInput->GetNormalizedPosition( pos );
-		{ // HACK: debug trap still in use?
-			int i = 0;
-		};
 
-		this->privData->input->GetMousePos( mouseState.x, mouseState.y );
+		this->privData->mousePos.x = mouseState.x = pos.x;
-		mouseState.mouseButtonPressed = this->privData->input->IsMousePressed();
+		this->privData->mousePos.y = mouseState.y = pos.y;
+		mouseState.mouseButtonPressed = this->privData->mouseInput->IsBtnDown( ::Input::Enum::SAMI_MouseLeftBtn );
 	}
-
 	EventHandler::Instance().Update( mouseState );
 
 	return this->privData->nextState;
@@ -97,7 +103,12 @@ bool MainState::Render()
 	Graphics::API::NewFrame();
 	Graphics::API::StartGuiRender();
 
-	Graphics::API::RenderGuiElement( this->privData->background, Float3(0.5f, 0.5f, 0.9f), Float2(1.0f), Float4(63.0f/255.0f,73.0f/255.0f,127.0f/255.0f,0.6f) );
+	if(this->privData->mouseInput->IsBtnDown(Input::Enum::SAMI_MouseLeftBtn))
+		Graphics::API::RenderGuiElement( this->privData->mouseCursor, this->privData->mousePos, Float2(0.15f), Float4(1.0f) );
+	else
+		Graphics::API::RenderGuiElement( this->privData->mouseCursor, this->privData->mousePos, Float2(0.15f, 0.24), Float4(1.0f) );
+
+	Graphics::API::RenderGuiElement( this->privData->background, Float3(0.5f, 0.5f, 0.9f), Float2(1.0f), Float4(0.0f, 0.0f, 0.0f, 1.0f) );
 	this->privData->guiElements.RenderTexture();
 
 	Graphics::API::StartTextRender();
@@ -112,6 +123,7 @@ bool MainState::Release()
 	if( this->privData )
 	{
 		Graphics::API::DeleteTexture( this->privData->background );
+		Graphics::API::DeleteTexture( this->privData->mouseCursor );
 		EventHandler::Instance().ReleaseCollection( &this->privData->guiElements );
 
 		this->privData = NULL;
@@ -136,6 +148,17 @@ void OnButtonInteract_Create( Oyster::Event::ButtonEvent<MainState*>& e )
 	}
 }
 
+void OnButtonInteract_Settings( Oyster::Event::ButtonEvent<MainState*>& e )
+{
+	switch( e.state )
+	{
+	case ButtonState_Released:
+		//e.owner->ChangeState( GameClientState::ClientState_LobbyCreate );
+		break;
+	default: break;
+	}
+}
+
 void OnButtonInteract_Join( Oyster::Event::ButtonEvent<MainState*>& e )
 {
 	switch( e.state )

Code/Game/GameClient/GameClientState/SharedStateContent.h

@@ -15,7 +15,7 @@
 #include "C_obj\C_DynamicObj.h"
 #include "C_Light.h"
 #include "NetworkClient.h"
-#include "L_inputClass.h"
+#include "Input.h"
 
 namespace DanBias { namespace Client
 {
@@ -26,7 +26,11 @@ namespace DanBias { namespace Client
 		::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_DynamicObj>> dynamicObjects;
 		::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_Light>> lights;
 		::Oyster::Network::NetworkClient *network;
-		InputClass* input;
+
+		::Input::Mouse *mouseDevice;
+		::Input::Keyboard *keyboardDevice;
+
+		float mouseSensitivity;
 	};
 } }
 

Code/Game/GameClient/Include/DanBiasGame.h

@@ -55,7 +55,7 @@ namespace DanBias
 			};
 
 			static HRESULT	InitDirect3D();
-			static HRESULT	InitInput();
+			static HRESULT	InitInput( HWND handle );
 
 			static Result Update(float deltaTime);
 			static HRESULT Render();

Code/Game/GameClient/Win32Input.h

@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////////////
+// Created by [Dennis Andersen] [2013]
+/////////////////////////////////////////////////////////////////////
+#ifndef INCLUDE_GUARD_RAW_INPUT_H
+#define INCLUDE_GUARD_RAW_INPUT_H
+
+
+#include "..\InputManager.h"
+#include "Win32Keyboard.h"
+#include "Win32Mouse.h"
+#include <vector>
+#define NOMINMAX
+#include <Windows.h>
+#include <map>
+
+/**
+*	TODO:
+*		1. Cordinate system
+*			1.1. Pixel cordinates DONE
+*			1.2. 0 - 1 cordinate DONW
+*			1.3. Origo in middle of the screen ( -1 to 1 )
+*/
+
+//RIDEV_INPUTSINK to receive all keyboard input regardless of focus
+
+//dx = +2*(x/w) -1
+//dx = -2*(y/h) +1
+
+
+namespace Input
+{
+	enum RawInput_Usage
+	{
+		RawInput_Usage_pointer				= 1,
+		RawInput_Usage_mouse				= 2,
+		RawInput_Usage_joystick				= 4,
+		RawInput_Usage_gamepad				= 5,
+		RawInput_Usage_keyboard				= 6,
+		RawInput_Usage_keypad				= 7,
+		RawInput_Usage_multiAxisController	= 8,
+		RawInput_Usage_TabletPCcontrols		= 9,
+	};
+
+	class Win32Input	:public InputManager
+	{
+	public:
+		Win32Input();
+		virtual~Win32Input();
+
+		InputObject* CreateDevice(const Enum::SAIType inputType, Typedefs::WindowHandle targetApplication) override;
+		void ToggleInputSystem(bool enable) override;
+		void Destroy() override;
+
+	private:
+		std::vector<Win32Keyboard*> keyboard;
+		std::vector<Win32Mouse*> mouse;
+
+		bool enabled;
+		bool exclusive;
+		HWND targetHwin;
+
+	private:
+		static Win32Input* instance;
+		static LRESULT RawInputParser(HWND h, LPARAM l);
+		static LRESULT CALLBACK RawWindowCallback(HWND h, UINT m, WPARAM w, LPARAM l);
+		static void WindowActivate(bool activate);
+	};
+}
+#endif
+

Code/Game/GameProtocols/GeneralProtocols.h

@@ -72,5 +72,50 @@ namespace GameLogic
 		Oyster::Network::CustomNetProtocol protocol;
 	};
 
+	//#define protocol_Broadcast_Test							102
+	struct Protocol_Broadcast_Test :public Oyster::Network::CustomProtocolObject
+	{
+		unsigned short port;
+		std::string ip;
+		std::string name;
+
+		Protocol_Broadcast_Test()
+		{ 
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[0].value.netShort = protocol_Broadcast_Test;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_UnsignedShort;
+			this->protocol[2].type = Oyster::Network::NetAttributeType_CharArray;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_CharArray;
+			this->port = 0;
+		}
+		Protocol_Broadcast_Test(unsigned short port, std::string ip, std::string name)
+		{ 
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[0].value.netShort = protocol_Broadcast_Test;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_UnsignedShort;
+			this->port = port;
+			this->protocol[2].type = Oyster::Network::NetAttributeType_CharArray;
+			this->ip = ip;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_CharArray;
+			this->name = name;
+		}
+		Protocol_Broadcast_Test(Oyster::Network::CustomNetProtocol& p)
+		{
+			this->port = p[1].value.netUShort;
+			this->ip.assign(p[2].value.netCharPtr);
+			this->name.assign(p[3].value.netCharPtr);
+		}
+		Oyster::Network::CustomNetProtocol GetProtocol() override
+		{
+			this->protocol[1].value = this->port;
+			this->protocol.Set(2, ip);
+			this->protocol.Set(3, name);
+			
+			return protocol;		 
+		}							 
+
+	private:
+		Oyster::Network::CustomNetProtocol protocol;
+	};
 }
 #endif //!GAMELOGIC_CONTROL_PROTOCOLS_H

Code/Game/GameProtocols/ProtocolIdentificationID.h

@@ -20,6 +20,7 @@
 #define protocol_GeneralMIN								100
 #define protocol_General_Status						100
 #define protocol_General_Text						101
+#define protocol_Broadcast_Test							102
 #define protocol_GeneralMAX								199
 
 

Code/Game/GameServer/Implementation/GameServer.cpp

@@ -10,6 +10,8 @@
 #include "..\GameLobby.h"
 #include "..\GameSession.h"
 
+#include "..\GameProtocols\GeneralProtocols.h"
+
 #include <NetworkServer.h>
 #include <NetworkClient.h>
 
@@ -18,6 +20,9 @@
 #include <WinTimer.h>
 #include <thread>
 
+//For conversion from wstring to string
+#include <codecvt>
+
 using namespace DanBias;
 using namespace Oyster::Network;
 using namespace Oyster::Thread;
@@ -41,12 +46,26 @@ namespace
 }
 
 
+std::string wstring_to_utf8 (const std::wstring& str)
+{
+    std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
+    return myconv.to_bytes(str);
+}
 
 DanBiasServerReturn GameServerAPI::ServerInitiate(const ServerInitDesc& desc)
 {
 	ServerOptions opt;
 	opt.mainOptions.listenPort = desc.listenPort;
 	opt.mainOptions.ownerSession = &lobby;
+
+	std::string serverName = wstring_to_utf8(desc.serverName);
+
+	GameLogic::Protocol_Broadcast_Test broadcastMessage(opt.mainOptions.listenPort, "127.0.0.1", serverName);
+
+	opt.broadcastOptions.broadcast = true;
+	opt.broadcastOptions.broadcastInterval = 1.0f;
+	opt.broadcastOptions.broadcastMessage = broadcastMessage.GetProtocol();
+
 	if(server.Init(opt) == NetworkServer::ServerReturnCode_Error)
 	{
 		return DanBiasServerReturn_Error;
@@ -55,6 +74,9 @@ DanBiasServerReturn GameServerAPI::ServerInitiate(const ServerInitDesc& desc)
 
 	std::printf("Server created!\t-\t%s: [%i]\n\n", server.GetLanAddress().c_str(), desc.listenPort);
 	
+	GameLogic::Protocol_Broadcast_Test broadcastMessage2(opt.mainOptions.listenPort, server.GetLanAddress(), serverName);
+	server.SetBroadcastMessage(broadcastMessage2.GetProtocol());
+
 	return DanBiasServerReturn_Sucess;
 }
 void GameServerAPI::ServerStart()

Code/LabProjects/RawDeviceLab/RawDeviceLab.vcxproj

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{32DD438B-8C9C-49EF-9EA5-EB48951D869A}</ProjectGuid>
+    <RootNamespace>Test</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Code/LabProjects/RawDeviceLab/main.cpp

@@ -0,0 +1,243 @@
+#include <Windows.h>
+
+const unsigned short raw_input_usage_keyboard = 6;
+const unsigned short raw_input_usage_mouse = 2;
+HWND winHandle;
+bool isPointAndClickMode;
+float normalizedMousePosX, normalizedMousePosY;
+
+LRESULT CALLBACK RawWindowCallback(HWND h, UINT m, WPARAM w, LPARAM l);
+LRESULT RawInputParser(HWND h, LPARAM l);
+void Update( );
+
+//int main()
+int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdShow)
+{
+	WNDCLASSEXW wc;
+	wc.cbSize		 = sizeof(WNDCLASSEXW);
+	wc.hIconSm		 = NULL;
+	wc.style         = NULL;
+	wc.lpfnWndProc   = RawWindowCallback; 
+	wc.cbClsExtra    = NULL;
+	wc.cbWndExtra    = NULL;
+	wc.hInstance     = hinst;
+	wc.hIcon         = NULL;
+	wc.hCursor       = NULL;
+	wc.hbrBackground = NULL;
+	wc.lpszMenuName  = NULL;
+	wc.lpszClassName = L"RawInputTest";
+
+	if( !RegisterClassExW(&wc) )
+	{
+		const char *breakpoint = "";
+	}
+
+	winHandle = CreateWindowExW( 0, L"RawInputTest", L"RawInputTest", WS_OVERLAPPEDWINDOW | WS_CAPTION, 0, 0, 600, 400, NULL, NULL, hinst, NULL );
+	ShowWindow( winHandle, cmdShow );
+
+	if( !winHandle )
+	{
+		const char *breakpoint = "";
+	}
+
+	isPointAndClickMode = true;
+	normalizedMousePosX =
+	normalizedMousePosY = 0.5f;
+
+	MSG msg = {0};
+	while( true )
+	{
+		if( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
+		{ 
+			if (msg.message == WM_QUIT)	break;
+			DispatchMessage(&msg);
+		}
+		else
+		{
+			Update();
+		}
+	}
+	return 0;
+}
+
+LRESULT CALLBACK RawWindowCallback(HWND h, UINT m, WPARAM w, LPARAM l)
+{
+	LRESULT val = 0;
+	switch (m)
+	{
+		case WM_INPUT:
+			{
+				RawInputParser( h, l );
+			}
+			break;
+		case WM_KEYUP:
+			{
+				if( w == 16 )
+				{
+					const char *breakpoint = "";
+
+					RAWINPUTDEVICE rid;
+					rid.usUsagePage = 0x01;
+					rid.hwndTarget = winHandle;
+					rid.usUsage = raw_input_usage_keyboard;
+					rid.dwFlags = RIDEV_NOLEGACY;
+					if( RegisterRawInputDevices(&rid, 1, sizeof(RAWINPUTDEVICE)) == FALSE )
+					{
+						const char *breakpoint = "";
+					}
+				}
+			}
+			break;	
+		case WM_RBUTTONUP:
+			{
+				const char *breakpoint = "";
+	
+				RAWINPUTDEVICE rid;
+				rid.usUsagePage = 0x01;
+				rid.hwndTarget = winHandle;
+				rid.usUsage = raw_input_usage_mouse;
+				rid.dwFlags = RIDEV_NOLEGACY | RIDEV_CAPTUREMOUSE;
+				if( RegisterRawInputDevices(&rid, 1, sizeof(RAWINPUTDEVICE)) == TRUE )
+				{
+					ShowCursor( false );
+					isPointAndClickMode = false;
+				}
+				else
+				{
+					const char *breakpoint = "";
+				}				
+			}
+			break;
+		case WM_ACTIVATE:
+			{
+				const char *breakpoint = "";
+			}
+			break;
+		break;
+		case WM_CREATE:
+			{
+				const char *breakpoint = "";
+			}
+			break;
+		case WM_DESTROY:
+			PostQuitMessage( 0 );
+		break;
+		default: break;
+	}
+
+	return DefWindowProc(h, m, w, l);
+}
+
+LRESULT RawInputParser(HWND h, LPARAM l)
+{
+	//Get The size of the raw data buffer
+	UINT bufferSize;
+	GetRawInputData((HRAWINPUT)l, RID_INPUT, NULL, &bufferSize, sizeof(RAWINPUTHEADER));
+	if (bufferSize < 1) 
+	{ return 0; } 
+
+	//Create and read the raw input data
+	LPBYTE rawBuffer = new BYTE[bufferSize];
+	UINT readBytes = GetRawInputData((HRAWINPUT)l, RID_INPUT, rawBuffer, &bufferSize,  sizeof(RAWINPUTHEADER));
+	if ( readBytes != bufferSize )
+	{
+		delete [] rawBuffer;
+		return 0;
+	}
+
+	HRESULT result = 0;
+	RAWINPUT* raw = (RAWINPUT*)rawBuffer;
+
+	if( raw->header.dwType == RIM_TYPEKEYBOARD )	
+	{	
+		if( (raw->data.keyboard.Flags & RI_KEY_BREAK) && raw->data.keyboard.VKey == 16 )
+		{
+			const char *breakpoint = "";
+
+			RAWINPUTDEVICE rid;
+			rid.usUsagePage = 0x01;
+			rid.hwndTarget = NULL;
+			rid.usUsage = raw_input_usage_keyboard;
+			rid.dwFlags = RIDEV_REMOVE;
+			if( RegisterRawInputDevices(&rid, 1, sizeof(RAWINPUTDEVICE)) == FALSE )
+			{
+				const char *breakpoint = "";
+			}
+		}
+	}
+	else if( raw->header.dwType == RIM_TYPEMOUSE )
+	{
+		if( raw->data.mouse.usButtonFlags & RI_MOUSE_MIDDLE_BUTTON_UP )
+		{
+			const char *breakpoint = "";
+
+			RAWINPUTDEVICE rid;
+			rid.usUsagePage = 0x01;
+			rid.hwndTarget = NULL;
+			rid.usUsage = raw_input_usage_mouse;
+			rid.dwFlags = RIDEV_REMOVE;
+			if( RegisterRawInputDevices(&rid, 1, sizeof(RAWINPUTDEVICE)) == TRUE )
+			{
+				RECT winRect;
+				GetWindowRect( winHandle, &winRect );
+				SetCursorPos( (winRect.left + winRect.right) >> 1, (winRect.top + winRect.bottom) >> 1 );
+				isPointAndClickMode = true;
+			}
+			else
+			{
+				const char *breakpoint = "";
+			}
+		}
+	}
+	else result = DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER));	
+
+	delete [] rawBuffer;
+	return result;
+}
+
+void Update( )
+{
+	if( isPointAndClickMode )
+	{
+		{ // Calculating and storing the normalizedMousePos values
+			POINT clientReach, clientCenter, mousePos;
+
+			RECT winRect, clientRect;
+			GetClientRect( winHandle, &clientRect );
+			GetWindowRect( winHandle, &winRect );
+
+			LONG borderThickness = (winRect.right - winRect.left - clientRect.right) >> 1;
+
+			clientReach.x = clientRect.right >> 1;
+			clientReach.y = clientRect.bottom >> 1;
+
+			clientCenter.x = (winRect.left + winRect.right) >> 1;
+			clientCenter.y = winRect.bottom - clientReach.y - borderThickness;
+
+			GetCursorPos( &mousePos );
+
+			normalizedMousePosX = ((float)(mousePos.x - clientCenter.x + clientReach.x)) / (float)clientRect.right;
+			normalizedMousePosY = ((float)(mousePos.y - clientCenter.y + clientReach.y)) / (float)clientRect.bottom;
+		}
+
+		// Check if normalizedMousePos intersects client surface [(0,0), (1,1)]
+		bool mouseIsNowWithinBounds = true;
+		if     ( normalizedMousePosX < 0.0f ) mouseIsNowWithinBounds = false;
+		else if( normalizedMousePosX > 1.0f ) mouseIsNowWithinBounds = false;
+		else if( normalizedMousePosY < 0.0f ) mouseIsNowWithinBounds = false;
+		else if( normalizedMousePosY > 1.0f ) mouseIsNowWithinBounds = false;
+
+		// Detect onEnter or onExit case
+		static bool mouseWereWithinBounds = false;
+		if( mouseIsNowWithinBounds & !mouseWereWithinBounds )
+		{ // onEnter
+			ShowCursor( false );
+			mouseWereWithinBounds = mouseIsNowWithinBounds;
+		}
+		else if( !mouseIsNowWithinBounds & mouseWereWithinBounds )
+		{ // onExit
+			ShowCursor( true );
+			mouseWereWithinBounds = mouseIsNowWithinBounds;
+		}
+	}
+}

Code/Misc/Input/Include/ApplicationKeyboard.h

@@ -1,22 +0,0 @@
-/////////////////////////////////////////////////////////////////////
-// Created by [Dan Andersson] [2014]
-/////////////////////////////////////////////////////////////////////
-#ifndef INPUT_APPLICATION_KEBOARD_H
-#define INPUT_APPLICATION_KEBOARD_H
-
-#include "InputObject.h"
-#include <vector>
-
-namespace Input
-{
-	class AplicationKeyboard : public InputObject
-	{
-	public:
-
-	protected:
-		AplicationKeyboard();
-		~AplicationKeyboard();
-	};
-}
-
-#endif // !INPUT_KEBOARD_H

Code/Misc/Input/Include/Common.h

@@ -31,20 +31,30 @@ namespace Input
 			ButtonState_Down,			// When the button is held down
 			ButtonState_Release,		// When button is released (once)
 			ButtonState_Up,				// Default state, will not be proccesed as a callback!
+			ButtonState_Unknown,
 		};
 	}
 	/*********************************************************************/
 	namespace Struct
 	{
-		struct SAIPoint2D
+		struct SAIPointInt2D
 		{
 			int x;
 			int y;
-			SAIPoint2D() :x(0), y(0) { }
+			SAIPointInt2D() :x(0), y(0) { }
-			SAIPoint2D(int _x, int _y) :x(_x), y(_y) { }
+			SAIPointInt2D(int _x, int _y) :x(_x), y(_y) { }
 			int Length() { return (abs(x) + abs(y)); }
 		};
 
+		struct SAIPointFloat2D
+		{
+			float x;
+			float y;
+			SAIPointFloat2D() :x(0.0f), y(0.0f) { }
+			SAIPointFloat2D(float _x, float _y) :x(_x), y(_y) { }
+			float Length() { return (fabs(x) + fabs(y)); }
+		};
+
 		struct InputData;
 	}
 	/*********************************************************************/

Code/Misc/Input/Include/InputManager.h

@@ -18,12 +18,17 @@ namespace Input
 			/**
 			* @return Returns an instance of the default input manager.
 			*/
-			static InputManager*					Instance						();
+			static InputManager*			Instance						();
 
 			/**
 			* @return Returns a new input manager. Should be destroyd with DestroyInputManager function.
 			*/
-			static InputManager*					CreateInputManager				();
+			static InputManager*			CreateInputManager				();
+
+			/**
+			* @return Destroys the default input manager.
+			*/
+			static void						DestroyInputManager				();
 
 			/**
 			* @return Destroys a input manager.
@@ -37,7 +42,9 @@ namespace Input
 			* @see InputDescription
 			* @return Returns a handle to a device that can be rethrown to a specific device.
 			*/
-			virtual InputObject*			CreateDevice					(const Enum::SAIType inputType, Typedefs::WindowHandle targetApplication = 0)	= 0;
+			virtual InputObject*			CreateDevice					( const Enum::SAIType inputType, Typedefs::WindowHandle targetApplication )	= 0;
+			virtual Keyboard*				CreateKeyboardDevice			( Typedefs::WindowHandle targetApplication ) { return (Keyboard*)CreateDevice(Enum::SAIType_Keyboard, targetApplication); }
+			virtual Mouse*					CreateMouseDevice				( Typedefs::WindowHandle targetApplication ) { return (Mouse*)CreateDevice(Enum::SAIType_Mouse, targetApplication); }
 
 			/**	Enables or Disables the Input proccessing.
 			*	@param The toggler.

Code/Misc/Input/Include/InputObject.h

@@ -13,8 +13,9 @@ namespace Input
 	public:
 		inline Enum::SAIType Type() { return type; }
 
-		virtual inline void Enable () { isEnabled = true; };
+		virtual void Activate () = 0;
-		virtual inline void Disable () { isEnabled = false;  };
+		virtual void Deactivate () = 0;
+		virtual bool IsActive() = 0;
 	
 	protected:
 		InputObject(Enum::SAIType type) { this->type = type; }
@@ -22,9 +23,6 @@ namespace Input
 	
 	private:
 		Enum::SAIType type;
-
-	protected:
-		bool isEnabled;
 	};
 }
 

Code/Misc/Input/Include/Keyboard.h

@@ -49,6 +49,10 @@ namespace Input
 			SAKI_7					,
 			SAKI_8					,
 			SAKI_9					,
+			SAKI_Add				,
+			SAKI_Comma				,
+			SAKI_Minus				,
+			SAKI_Period				,
 			SAKI_A					,
 			SAKI_B					,
 			SAKI_C					,
@@ -131,11 +135,23 @@ namespace Input
 		};
 	}
 	//-----------------------------------------------------------------------------------------------------------------------------
+	namespace Struct
+	{
+		struct KeyboardEventData
+		{
+			Enum::SAKI key;
+			Enum::ButtonState state;
+			Keyboard* sender;
+			void* tag;
+		};
+	}
+	//-----------------------------------------------------------------------------------------------------------------------------
 	namespace Typedefs
 	{
-		typedef void(*OnKeyPressCallback)(Enum::SAKI key, const wchar_t[40], Keyboard* sender);
+		typedef void(*OnKeyEventCallback)	(const Struct::KeyboardEventData& eventData);
-		typedef void(*OnKeyDownCallback)(Enum::SAKI key, const wchar_t[40], Keyboard* sender);
+		typedef void(*OnKeyPressCallback)	(Enum::SAKI key, Keyboard* sender, void* tag);
-		typedef void(*OnKeyReleaseCallback)(Enum::SAKI key, const wchar_t[40], Keyboard* sender);
+		typedef void(*OnKeyDownCallback)	(Enum::SAKI key, Keyboard* sender, void* tag);
+		typedef void(*OnKeyReleaseCallback)	(Enum::SAKI key, Keyboard* sender, void* tag);
 	}
 	//-----------------------------------------------------------------------------------------------------------------------------
 
@@ -145,68 +161,65 @@ namespace Input
 		class KeyboardEvent
 		{
 		public:
-			virtual void OnKeyPress(Enum::SAKI key, const wchar_t[40], Keyboard* sender) { }
+			virtual void OnKeyEvent		(const Struct::KeyboardEventData& eventData)	{  }
-			virtual void OnKeyDown(Enum::SAKI key, const wchar_t[40], Keyboard* sender) { }
+			virtual void OnKeyPress		(Enum::SAKI key, Keyboard* sender)				{  }
-			virtual void OnKeyRelease(Enum::SAKI key, const wchar_t[40], Keyboard* sender) { }
+			virtual void OnKeyDown		(Enum::SAKI key, Keyboard* sender)				{  }
+			virtual void OnKeyRelease	(Enum::SAKI key, Keyboard* sender)				{  }
 		};
 
 	public: /* Manual check functions */
+		virtual ~Keyboard();
+
 		virtual bool IsKeyUp (Enum::SAKI key) = 0;
 		virtual bool IsKeyDown (Enum::SAKI key) = 0;
-		virtual const wchar_t* GetAsText(Enum::SAKI key) = 0;
+		virtual wchar_t* GetAsText(Enum::SAKI key) = 0;
+
+	public: /* From InputObject */
+		virtual void Activate () override		= 0;
+		virtual void Deactivate () override		= 0;
+		virtual bool IsActive() override		= 0;
+
+	public: /* object subscribe functions */
+		void AddKeyboardEvent			(KeyboardEvent* object);
+		void RemoveKeyboardEvent		(KeyboardEvent* object);
+		void operator+=					(KeyboardEvent* object);
+		void operator-=					(KeyboardEvent* object);
 
 	public: /* global subscribe callback functions */
-		void AddOnKeyPressCallback (Typedefs::OnKeyPressCallback func);
+		void AddOnKeyEventCallback		(Typedefs::OnKeyEventCallback func, void* tag);
-		void AddOnKeyDownCallback (Typedefs::OnKeyDownCallback func);
+		void AddOnKeyPressCallback		(Typedefs::OnKeyPressCallback func, void* tag);
-		void AddOnKeyReleaseCallback (Typedefs::OnKeyReleaseCallback func);
+		void AddOnKeyDownCallback		(Typedefs::OnKeyDownCallback func, void* tag);
+		void AddOnKeyReleaseCallback	(Typedefs::OnKeyReleaseCallback func, void* tag);
 
-		void RemoveOnKeyPressCallback (Typedefs::OnKeyPressCallback func);
+		void RemoveOnKeyEventCallback	(Typedefs::OnKeyEventCallback func);
-		void RemoveOnKeyDownCallback (Typedefs::OnKeyDownCallback func);
+		void RemoveOnKeyPressCallback	(Typedefs::OnKeyPressCallback func);
+		void RemoveOnKeyDownCallback	(Typedefs::OnKeyDownCallback func);
 		void RemoveOnKeyReleaseCallback (Typedefs::OnKeyReleaseCallback func);
 
 	public:
-		void operator+= (KeyboardEvent* object);
+		
-		void operator-= (KeyboardEvent* object);
+
+		void BindTextTarget( ::std::wstring *field );
+		void ReleaseTextTarget();
+
+	public:
+		struct KeyboardCallbackList;
 
 	protected:
 		Keyboard();
-		~Keyboard();
 
-	protected:
+	protected: /* Internal event proc */
-		struct KeyboardCallbackList
+		void InternalOnEvent(Struct::KeyboardEventData& data);
-		{
+		void InternalOnKeyPress(Enum::SAKI key);
-			enum CallbackDataType
+		void InternalOnKeyDown(Enum::SAKI key);
-			{
+		void InternalOnKeyRelease(Enum::SAKI key);
-				CallbackDataType_OnPress,
-				CallbackDataType_OnDown,
-				CallbackDataType_OnRelease
-			} type;
-			union CallbackData
-			{
-				Typedefs::OnKeyPressCallback		keyPressCallback;
-				Typedefs::OnKeyDownCallback		keyDownCallback;
-				Typedefs::OnKeyReleaseCallback	keyReleaseCallback;
-
-				CallbackData (){ memset(this, 0, sizeof(CallbackData)); }
-				CallbackData (Typedefs::OnKeyPressCallback o){ keyPressCallback = o; }
-				bool operator ==(CallbackData o){ return o.keyDownCallback == keyDownCallback; }
-				bool operator ==(Typedefs::OnKeyPressCallback o ){ return o == keyPressCallback; }
-				operator bool(){ return this->keyDownCallback != 0; }
-			} function;
-			KeyboardCallbackList *next;
-			KeyboardCallbackList(CallbackData func, CallbackDataType t) :function(func), next(0), type(t) { }
-		};
-
-	protected:
-		void ClearList(KeyboardCallbackList* first);
-		void AddToList(Keyboard::KeyboardCallbackList* first, KeyboardCallbackList::CallbackData data, KeyboardCallbackList::CallbackDataType type);
-		void RemoveFromList(KeyboardCallbackList* first, KeyboardCallbackList::CallbackData data);
-		bool ExistsInList(KeyboardCallbackList* first, KeyboardCallbackList::CallbackData data);
-		bool ExistsInList(std::vector<KeyboardEvent*>& list, KeyboardEvent* data);
 
 	protected:
 		std::vector<KeyboardEvent*>		keyEventSubscrivers;
 		KeyboardCallbackList*			callbackList;
+		::std::wstring*					textTarget;
+		::std::wstring::size_type		writePos;
+		bool							active;
 	};
 }
 

Code/Misc/Input/Include/Mouse.h

@@ -38,16 +38,35 @@ namespace Input
 			SAMI_MouseBtnX18,
 			SAMI_MouseBtnX19,
 			SAMI_MouseBtnX20,
+			SAMI_MouseMove,
+			SAMI_MouseScroll,
 			SAMI_Unknown,
 		};
 	}
 	//-----------------------------------------------------------------------------------------------------------------------------
+	namespace Struct
+	{
+		struct MouseEventData
+		{
+			Enum::SAMI type;
+			Enum::ButtonState buttonState;
+			Struct::SAIPointInt2D pixelPos;
+			Struct::SAIPointFloat2D normalizedPos;
+			Struct::SAIPointInt2D velocity;
+			Mouse* sender;
+			int scrollDelta;
+			void* tag;
+		};
+	}
+	//-----------------------------------------------------------------------------------------------------------------------------
 	namespace Typedefs
 	{
+		typedef void(*OnMouseCallback)( const Struct::MouseEventData& eventData );
 		typedef void(*OnMousePressCallback)(Enum::SAMI btn, Mouse* sender);
 		typedef void(*OnMouseDownCallback)(Enum::SAMI btn, Mouse* sender);
 		typedef void(*OnMouseReleaseCallback)(Enum::SAMI btn, Mouse* sender);
-		typedef void(*OnMouseMoveCallback)(Struct::SAIPoint2D, Mouse* sender);
+		typedef void(*OnMouseMovePixelPosCallback)(Struct::SAIPointInt2D cord, Mouse* sender);
+		typedef void(*OnMouseMoveVelocityCallback)(Struct::SAIPointInt2D cord, Mouse* sender);
 		typedef void(*OnMouseScrollCallback)(int delta, Mouse* sender);
 	}
 	//-----------------------------------------------------------------------------------------------------------------------------
@@ -55,87 +74,81 @@ namespace Input
 	class Mouse	:public InputObject
 	{
 	public:
+
 		class MouseEvent
 		{
 		public:
-			virtual void OnMousePress	( Enum::SAMI key, Mouse* sender )							{ }
+			virtual void OnMouse				( const Struct::MouseEventData& eventData )							{ }
-			virtual void OnMouseDown	( Enum::SAMI key, Mouse* sender )							{ }
+			virtual void OnMousePress			( Enum::SAMI key, Mouse* sender )							{ }
-			virtual void OnMouseRelease	( Enum::SAMI key, Mouse* sender )							{ }
+			virtual void OnMouseDown			( Enum::SAMI key, Mouse* sender )							{ }
-			virtual void OnMouseMove	( Struct::SAIPoint2D coordinate, Mouse* sender )			{ }
+			virtual void OnMouseRelease			( Enum::SAMI key, Mouse* sender )							{ }
-			virtual void OnMouseScroll	( int delta, Mouse* sender )								{ }
+			virtual void OnMouseMovePixelPos	( Struct::SAIPointInt2D coordinate, Mouse* sender )			{ }
+			virtual void OnMouseMoveVelocity	( Struct::SAIPointInt2D coordinate, Mouse* sender )			{ }
+			virtual void OnMouseScroll			( int delta, Mouse* sender )								{ }
 		};
 	
-	public:
+	public: /* Manual check functions */
-		virtual bool				IsBtnUp(Enum::SAMI key) = 0;
+		virtual bool						IsBtnUp(Enum::SAMI key) const = 0;
-		virtual bool				IsBtnDown(Enum::SAMI key) = 0;
+		virtual bool						IsBtnDown(Enum::SAMI key) const = 0;
-		virtual int					GetWheelDelta() = 0;
+		virtual int							GetWheelDelta() const = 0;
-		virtual Struct::SAIPoint2D	GetPixelPosition(Struct::SAIPoint2D targetMem = Struct::SAIPoint2D()) = 0;
+		virtual Struct::SAIPointInt2D&		GetPixelPosition(Struct::SAIPointInt2D& targetMem = Struct::SAIPointInt2D()) const = 0;
+		virtual Struct::SAIPointFloat2D&	GetNormalizedPosition(Struct::SAIPointFloat2D& targetMem = Struct::SAIPointFloat2D()) = 0;
+		virtual Struct::SAIPointFloat2D&	GetDeltaPosition(Struct::SAIPointFloat2D& targetMem = Struct::SAIPointFloat2D()) const = 0;
 
-	public:
+	public: /* From InputObject */
-		void AddOnMousePressCallback( Typedefs::OnMousePressCallback func);
+		virtual void Activate () override		= 0;
-		void AddOnMouseDownCallback( Typedefs::OnMouseDownCallback func );
+		virtual void Deactivate () override		= 0;
-		void AddOnMouseReleaseCallback( Typedefs::OnMouseReleaseCallback func );
+		virtual bool IsActive() override		= 0;
-		void AddOnMouseMoveCallback( Typedefs::OnMouseMoveCallback func );
-		void AddOnMouseScrollCallback( Typedefs::OnMouseScrollCallback func );
 
+	public: /* global subscribe callback functions */
+		void AddMouseEvent(MouseEvent* object);
+		void RemoveMouseEvent(MouseEvent* object);
+		void operator+= (MouseEvent* object);
+		void operator-= (MouseEvent* object);
+
+	public: /* global subscribe callback functions */
+		void AddOnMouseCallback( Typedefs::OnMouseCallback func, void* tag);
+		void AddOnMousePressCallback( Typedefs::OnMousePressCallback func, void* tag);
+		void AddOnMouseDownCallback( Typedefs::OnMouseDownCallback func, void* tag );
+		void AddOnMouseReleaseCallback( Typedefs::OnMouseReleaseCallback func, void* tag );
+		void AddOnMouseMovePixelPosCallback( Typedefs::OnMouseMovePixelPosCallback func, void* tag );
+		void AddOnMouseMoveVelocityCallback( Typedefs::OnMouseMoveVelocityCallback func, void* tag );
+		void AddOnMouseScrollCallback( Typedefs::OnMouseScrollCallback func, void* tag );
+
+		void RemoveOnMouseCallback( Typedefs::OnMouseCallback func);
 		void RemoveOnMousePressCallback( Typedefs::OnMousePressCallback func);
 		void RemoveOnMouseDownCallback( Typedefs::OnMouseDownCallback func );
 		void RemoveOnMouseReleaseCallback( Typedefs::OnMouseReleaseCallback func );
-		void RemoveOnMouseMoveCallback( Typedefs::OnMouseMoveCallback func );
+		void RemoveOnMouseMovePixelPosCallback( Typedefs::OnMouseMovePixelPosCallback  func );
+		void RemoveOnMouseMoveVelocityCallback( Typedefs::OnMouseMoveVelocityCallback  func );
 		void RemoveOnMouseScrollCallback( Typedefs::OnMouseScrollCallback func );
 
 		void SetPixelPos(int x, int y);
 		void ToggleCursor(bool toggler);
 
-	private:
+	public:
-		void operator+= (MouseEvent* object);
+		struct MouseCallbackList;
-		void operator-= (MouseEvent* object);
 
 	protected:
 		Mouse();
-		~Mouse();
+		virtual ~Mouse();
 
 	protected:
-		struct MouseCallbackList
+		void InternalOnEvent(Struct::MouseEventData & data);
-		{
+		void InternalOnBtnPress(Enum::SAMI key);
-			enum CallbackDataType
+		void InternalOnBtnDown(Enum::SAMI key);
-			{
+		void InternalOnBtnRelease(Enum::SAMI key);
-				CallbackDataType_OnPress,
+		void InternalOnMove(Struct::SAIPointInt2D pixelPos, Struct::SAIPointInt2D velocity);
-				CallbackDataType_OnDown,
+		void InternalOnScroll(int delta);
-				CallbackDataType_OnRelease,
-				CallbackDataType_OnMove,
-				CallbackDataType_OnScroll,
-			} type;
-			union CallbackData
-			{
-				Typedefs::OnMousePressCallback mousePressCallback;
-				Typedefs::OnMouseDownCallback mouseDownCallback;
-				Typedefs::OnMouseReleaseCallback mouseReleaseCallback;
-				Typedefs::OnMouseMoveCallback mouseMoveCallback;
-				Typedefs::OnMouseScrollCallback mouseScrollCallback;
-				void* dummy;
-
-				CallbackData (){ memset(this, 0, sizeof(CallbackData)); }
-				CallbackData (void* d){ dummy = d; }
-				bool operator ==(CallbackData o){ return o.dummy == dummy; }
-				bool operator ==(void* o ){ return o == dummy; }
-				operator bool(){ return this->dummy != 0; }
-			} function;
-			MouseCallbackList *next;
-			MouseCallbackList(CallbackData func, CallbackDataType t) :function(func), next(0), type(t) { }
-		};
-
-	protected:
-		void ClearList(MouseCallbackList* first);
-		void AddToList(MouseCallbackList* first, MouseCallbackList::CallbackData data, MouseCallbackList::CallbackDataType type);
-		void RemoveFromList(MouseCallbackList* first, MouseCallbackList::CallbackData data);
-		bool ExistsInList(MouseCallbackList* first, MouseCallbackList::CallbackData data);
-		bool ExistsInList(std::vector<MouseEvent*>& list, MouseEvent* data);
 
 	protected:
 		std::vector<MouseEvent*>	mouseSubscribers;
 		MouseCallbackList*			callbackList;
-		Struct::SAIPoint2D			pixelPos;
+		Struct::SAIPointInt2D		pixelPos;
+		Struct::SAIPointInt2D		velocity;
+		Struct::SAIPointFloat2D		normalPos;
+		Struct::SAIPointFloat2D		deltaPos;
+		
 		bool						isCurorLocked;
 		int							wheelDelta;
 	};

Code/Misc/Input/Include/Win32/Win32ApplicationKeyboard.h

@@ -1,24 +0,0 @@
-/////////////////////////////////////////////////////////////////////
-// Created by [Dan Andersson] [2014]
-/////////////////////////////////////////////////////////////////////
-#ifndef INPUT_WIN32_APPLICATION_KEBOARD_H
-#define INPUT_WIN32_APPLICATION_KEBOARD_H
-
-#include "..\ApplicationKeyboard.h"
-//#include <Windows.h>
-
-namespace Input
-{
-	class Win32ApplicationKeyboard :public AplicationKeyboard
-	{
-	public:
-		Win32ApplicationKeyboard();
-		~Win32ApplicationKeyboard();
-
-
-	private:
-
-	};
-}
-
-#endif // !INPUT_WIN32_APPLICATION_KEBOARD_H

Code/Misc/Input/Include/Win32/Win32Input.h

@@ -9,14 +9,15 @@
 #include "Win32Keyboard.h"
 #include "Win32Mouse.h"
 #include <vector>
+#define NOMINMAX
 #include <Windows.h>
 #include <map>
 
 /**
 *	TODO:
 *		1. Cordinate system
-*			1.1. Pixel cordinates
+*			1.1. Pixel cordinates DONE
-*			1.2. 0 - 1 cordinate
+*			1.2. 0 - 1 cordinate DONW
 *			1.3. Origo in middle of the screen ( -1 to 1 )
 */
 
@@ -42,46 +43,6 @@ namespace Input
 
 	class Win32Input	:public InputManager
 	{
-	//	private:
-	//		SubscribeList<INPUT_CALLBACK, const InputData*>*			_procInput;
-	//
-	//		bool														_enabled;
-	//		bool														_mouseEnabled;
-	//		bool														_KeyboardEnabled;
-	//		bool														_exclusive;
-	//		List<RawInputDeviceInstance>								_deviceList;
-	//		
-	//		List<InputData>											_mouseInput;
-	//		List<InputData>											_keyboardInput;
-	//		
-	//		HHOOK														_msgHook;
-	//
-	//	private:
-	//		Win32Input													();	
-	//		~Win32Input													();
-	//		
-	//		bool _addDevice												(const RAWINPUTDEVICE* k, const int& count);
-	//		RAWINPUT*_TranslateRawInput									(LPARAM l);
-	//		void _proccessRawMouseData									(RAWMOUSE&);
-	//		void _proccessRawKeyboardData								(RAWKEYBOARD&);
-	//
-	//		static LRESULT CALLBACK WM_INPUT_TRANSLATE					(int nCode, WPARAM wParam, LPARAM lParam);
-	//
-	//	public:
-	//
-	//		static Win32Input* Self										();
-	//		static void Destroy											();
-	//		
-	//		const wchar_t*			Input_GetError						() const;
-	//
-	//		bool					Input_AddDevice						(IN const HWND& targetApplication);
-	//		bool					Input_AddDevice						(IN const RAWINPUTDEVICE*, IN const int&);
-	//
-	//		void					Input_Subscribe						(IN INPUT_CALLBACK fnc);
-	//		void					Input_Unsubscribe					(IN INPUT_CALLBACK fnc);
-	//
-	//		void					Input_Disable						();
-	//		void					Input_Enable						();
 	public:
 		Win32Input();
 		virtual~Win32Input();
@@ -95,12 +56,11 @@ namespace Input
 		std::vector<Win32Mouse*> mouse;
 
 		bool enabled;
-		bool exclusive;
 		HWND targetHwin;
 
 	private:
 		static Win32Input* instance;
-		static void RawInputParser(HWND h, LPARAM l);
+		static LRESULT RawInputParser(HWND h, LPARAM l);
 		static LRESULT CALLBACK RawWindowCallback(HWND h, UINT m, WPARAM w, LPARAM l);
 		static void WindowActivate(bool activate);
 	};

Code/Misc/Input/Include/Win32/Win32Keyboard.h

@@ -5,6 +5,7 @@
 #define INPUT_KEYBOARD_H
 
 #include "..\Keyboard.h"
+#define NOMINMAX
 #include <Windows.h>
 
 namespace Input
@@ -12,24 +13,34 @@ namespace Input
 	class Win32Keyboard :public Keyboard
 	{
 	public:
-		Win32Keyboard();
+		Win32Keyboard(HWND target);
 		~Win32Keyboard();
 
 		bool IsKeyUp (Enum::SAKI key) override;
 		bool IsKeyDown (Enum::SAKI key) override;
-		const wchar_t* GetAsText(Enum::SAKI key) override;
+		wchar_t* GetAsText(Enum::SAKI key) override;
 
-		void ProccessKeyboardData (bool isUp, Enum::SAKI key, unsigned int makeCode, bool isE0);
+	public: /* From InputObject */
+		void Activate () override;
+		void Deactivate () override;
+		inline bool IsActive() override { return this->isActive; }
+
+		void ProccessKeyboardData (RAWKEYBOARD keyboard);
+		bool Create( );
 
 	private:
+		void MapKey(RAWKEYBOARD& rawKB, Enum::SAKI& out_key, bool& isE0);
+		
 		struct Keys
 		{
 			bool isE0;
 			bool isDown;
 			unsigned int makecode;
 		};
+		RAWINPUTDEVICE device;
 		static const int MAXKEYS = 256;
 		Keys keys[MAXKEYS];
+		bool isActive;
 	};
 }
 

Code/Misc/Input/Include/Win32/Win32Mouse.h

@@ -12,15 +12,22 @@ namespace Input
 	class Win32Mouse :public Mouse
 	{
 	public:
-		Win32Mouse();
+		Win32Mouse(HWND target);
 		~Win32Mouse();
 
-		bool IsBtnUp(Enum::SAMI key) override;
+		bool IsBtnUp(Enum::SAMI key) const override;
-		bool IsBtnDown(Enum::SAMI key) override;
+		bool IsBtnDown(Enum::SAMI key) const override;
-		int GetWheelDelta()  override;
+		int GetWheelDelta()  const override;
-		Struct::SAIPoint2D GetPixelPosition(Struct::SAIPoint2D targetMem = Struct::SAIPoint2D())  override;
+		Struct::SAIPointInt2D& GetPixelPosition(Struct::SAIPointInt2D &targetMem = Struct::SAIPointInt2D())  const override;
+		Struct::SAIPointFloat2D& GetNormalizedPosition(Struct::SAIPointFloat2D &targetMem = Struct::SAIPointFloat2D()) override;
+		Struct::SAIPointFloat2D& GetDeltaPosition(Struct::SAIPointFloat2D& targetMem = Struct::SAIPointFloat2D()) const override;
 	
-		void ProccessMouseData (bool isDown, Enum::SAMI btn, int delta, Struct::SAIPoint2D velocity, unsigned int makeCode);
+		void Activate () override;
+		void Deactivate () override;
+		inline bool IsActive() override { return this->isActive; }
+
+		void ProccessMouseData (RAWMOUSE mouse);
+		bool Create( );
 
 	private:
 		struct Buttons
@@ -28,8 +35,12 @@ namespace Input
 			unsigned int makeCode;
 			bool isDown;
 		};
-		static const int MAXBUTTONS = 25;
+		static const int MAXBUTTONS =Enum::SAMI_Unknown;
-		Buttons buttons[25];
+		Buttons buttons[MAXBUTTONS];
+		RAWINPUTDEVICE device;
+		Struct::SAIPointInt2D windowSize;
+		bool isActive;
+		Struct::SAIPointInt2D winCursPos;
 	};
 }
 

Code/Misc/Input/Input.vcxproj

@@ -28,7 +28,6 @@
     <ClCompile Include="Source\Win32\Win32Mouse.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="Include\ApplicationKeyboard.h" />
     <ClInclude Include="Include\Common.h" />
     <ClInclude Include="Include\Input.h" />
     <ClInclude Include="Include\InputManager.h" />
@@ -36,7 +35,6 @@
     <ClInclude Include="Include\Keyboard.h" />
     <ClInclude Include="Include\Mouse.h" />
     <ClInclude Include="Include\PreReq.h" />
-    <ClInclude Include="Include\Win32\Win32ApplicationKeyboard.h" />
     <ClInclude Include="Include\Win32\Win32Input.h" />
     <ClInclude Include="Include\Win32\Win32Keyboard.h" />
     <ClInclude Include="Include\Win32\Win32Mouse.h" />
@@ -93,28 +91,32 @@
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
+    <IncludePath>$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
+    <IncludePath>$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
+    <IncludePath>$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
+    <IncludePath>$(IncludePath)</IncludePath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

Code/Misc/Input/Main.cpp

@@ -1,101 +1,68 @@
-#include "RawInput.h"
+#include <atomic>
-// include the basic windows header file
+#include <vector>
-#include <windows.h>
+#include <iostream>
-#include <windowsx.h>
+#include <chrono>
-#include <cassert>
+#include <ctime>
+#include <map>
+#include <thread>
+#include <chrono>
+#include <iomanip>
+#include <mutex>
+#include <bitset>
+#include <Windows.h>
 
+#include "Include\Input.h"
+#include "WindowShell.h"
 
-HWND hWnd;
+using namespace std;
-// this is the main message handler for the program
+using namespace Input;
-LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+using namespace Input::Enum;
+
+Input::Keyboard* keyboard = 0;	
+Input::Mouse* mouse = 0;		
+
+void KeyPress(Input::Enum::SAKI key, Input::Keyboard* sender)
 {
-    // sort through and find what code to run for the message given
+	if(key == SAKI_A)
-    switch(message)
+	{
-    {
+		if(mouse->IsActive())	mouse->Deactivate();
-        // this message is read when the window is closed
+		else					mouse->Activate();
-        case WM_DESTROY:
-        {
-            // close the application entirely
-            PostQuitMessage(0);
-            return 0;
-        } break;
-		case WM_KEYUP:
-			MessageBox(0, L"WM_KEYUP", L"", 0);
-		break;
-		case WM_KEYDOWN:
-			MessageBox(0, L"WM_KEYDOWN", L"", 0);
-		break;
-		//case WM_INPUT:
-		//	MessageBox(0, L"WM_INPUT_MAIN", L"", 0);
-		//break;
-    }
 		
-    // Handle any messages the switch statement didn't
+	}
-    return DefWindowProc (hWnd, message, wParam, lParam);
 }
-void initWindow(HINSTANCE h, int i)
+
+void MouseVelocity(Input::Struct::SAIPointInt2D vel, Input::Mouse* sender)
 {
-	// this struct holds information for the window class
+	int i = vel.Length();
-    WNDCLASSEX wc;
+	if(abs(i) > 2)
-
+		i = 0;
-    // clear out the window class for use
-    ZeroMemory(&wc, sizeof(WNDCLASSEX));
-
-    // fill in the struct with the needed information
-    wc.cbSize = sizeof(WNDCLASSEX);
-    wc.style = CS_HREDRAW | CS_VREDRAW;
-    wc.lpfnWndProc = WindowProc;
-    wc.hInstance = h;
-    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-    wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
-    wc.lpszClassName = L"WindowClass1";
-
-    // register the window class
-    RegisterClassEx(&wc);
-
-    // create the window and use the result as the handle
-    hWnd = CreateWindowEx(NULL,
-                          L"WindowClass1",					// name of the window class
-                          L"Our First Windowed Program",	// title of the window
-                          WS_OVERLAPPEDWINDOW,				// window style
-                          300,								// x-position of the window
-                          300,								// y-position of the window
-                          500,								// width of the window
-                          400,								// height of the window
-                          NULL,								// we have no parent window, NULL
-                          NULL,								// we aren't using menus, NULL
-                          h,						// application handle
-                          NULL);							// used with multiple windows, NULL
-
-    // display the window on the screen
-    ShowWindow(hWnd, i);
 }
-void initRaw()
+
+int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdShow)
 {
-	//RawInput::Self()->Input_AddDevice(hWnd);
+	std::wstring text;
-}
+
-// the entry point for any Windows program
+	WindowShell::CreateWin(WindowShell::WINDOW_INIT_DESC());
-int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
+	WindowShell::CreateConsoleWindow();
-{
+	keyboard = Input::InputManager::Instance()->CreateKeyboardDevice(WindowShell::GetHWND());
-	initWindow(hInstance, nCmdShow);
+	mouse = Input::InputManager::Instance()->CreateMouseDevice(WindowShell::GetHWND());
-	initRaw();
+
-
+	mouse->AddOnMouseMoveVelocityCallback(MouseVelocity);
-
+	keyboard->BindTextTarget( &text );
-    // this struct holds Windows event messages
+	keyboard->AddOnKeyPressCallback(KeyPress);
-    MSG msg;
+
-
+	int oldLen = 0;
-    // wait for the next message in the queue, store the result in 'msg'
+
-    while(GetMessage(&msg, NULL, 0, 0))
+	while (WindowShell::Frame())
-    {
+	{
-        // translate keystroke messages into the right format
+		if(text.length() != oldLen)
-        TranslateMessage(&msg);
+		{
-        // send the message to the WindowProc function
+			wprintf(text.c_str());
-        DispatchMessage(&msg);
+			oldLen =text.length();
-
+		}
-		//RawInput::Self()->Input_Read();
+	}
-    }
+
-
+	system("pause");
-	RawInput::Destroy();
+
-
+	return cmdShow;
-    return msg.wParam;
 }

Code/Misc/Input/Source/InputManager.cpp

@@ -57,6 +57,14 @@ InputManager* InputManager::CreateInputManager()
 {
 	return CreateManager();
 }
+void InputManager::DestroyInputManager()
+{
+	if(!defaultInstance) return;
+
+	defaultInstance->Destroy();
+	delete defaultInstance;
+	defaultInstance = 0;
+}
 void InputManager::DestroyInputManager(InputManager* inputSystem)
 {
 	if(!inputSystem) return;
@@ -77,3 +85,4 @@ InputManager::~InputManager()
 
 
 
+

Code/Misc/Input/Source/Keyboard.cpp

@@ -8,11 +8,37 @@ using namespace Input::Enum;
 using namespace Input::Typedefs;
 using namespace Input::Struct;
 
-
+struct Keyboard::KeyboardCallbackList
-void Keyboard::ClearList(Keyboard::KeyboardCallbackList* first)
 {
-	KeyboardCallbackList* w = first;
+	enum CallbackDataType
-	KeyboardCallbackList* removee = 0;
+	{
+		CallbackDataType_OnEvent,
+		CallbackDataType_OnPress,
+		CallbackDataType_OnDown,
+		CallbackDataType_OnRelease
+	} type;
+	union CallbackData
+	{
+		Typedefs::OnKeyEventCallback	keyEventCallback;
+		Typedefs::OnKeyPressCallback	keyPressCallback;
+		Typedefs::OnKeyDownCallback		keyDownCallback;
+		Typedefs::OnKeyReleaseCallback	keyReleaseCallback;
+
+		CallbackData (){ memset(this, 0, sizeof(CallbackData)); }
+		CallbackData (Typedefs::OnKeyPressCallback o){ keyPressCallback = o; }
+		bool operator ==(CallbackData o){ return o.keyDownCallback == keyDownCallback; }
+		bool operator ==(Typedefs::OnKeyPressCallback o ){ return o == keyPressCallback; }
+		operator bool(){ return this->keyDownCallback != 0; }
+	} function;
+	KeyboardCallbackList *next;
+	void* tag;
+	KeyboardCallbackList(CallbackData func, CallbackDataType t, void* ct) :function(func), next(0), type(t), tag(ct) { }
+};
+
+void ClearList(Keyboard::KeyboardCallbackList* first)
+{
+	Keyboard::KeyboardCallbackList* w = first;
+	Keyboard::KeyboardCallbackList* removee = 0;
 
 	while (w)
 	{
@@ -21,27 +47,27 @@ void Keyboard::ClearList(Keyboard::KeyboardCallbackList* first)
 		delete removee;
 	}
 }
-void Keyboard::AddToList(Keyboard::KeyboardCallbackList* first, KeyboardCallbackList::CallbackData data, KeyboardCallbackList::CallbackDataType type)
+void AddToList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallbackList::CallbackData data, Keyboard::KeyboardCallbackList::CallbackDataType type, void* tag)
 {
-	KeyboardCallbackList *w = first;
+	Keyboard::KeyboardCallbackList *w = first;
-	KeyboardCallbackList *prev = first;
+	Keyboard::KeyboardCallbackList *prev = first;
 	while (w)
 	{ prev = w; w = w->next; }
 
-	KeyboardCallbackList::CallbackData f;
+	Keyboard::KeyboardCallbackList::CallbackData f;
 	f = data;
 
-	prev->next = new KeyboardCallbackList(f, type);
+	prev->next = new Keyboard::KeyboardCallbackList(f, type, tag);
 }
-void Keyboard::RemoveFromList(KeyboardCallbackList* first, KeyboardCallbackList::CallbackData data)
+void RemoveFromList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallbackList::CallbackData data)
 {
-	KeyboardCallbackList *w = first;
+	Keyboard::KeyboardCallbackList *w = first;
-	KeyboardCallbackList *prev = first;
+	Keyboard::KeyboardCallbackList *prev = first;
 	while (w)
 	{
 		if(data == w->function)
 		{
-			KeyboardCallbackList *removee = w;
+			Keyboard::KeyboardCallbackList *removee = w;
 			w = w->next;
 			prev->next = w;
 			delete removee;
@@ -51,9 +77,9 @@ void Keyboard::RemoveFromList(KeyboardCallbackList* first, KeyboardCallbackList:
 		w = w->next; 
 	}
 }
-bool Keyboard::ExistsInList(KeyboardCallbackList* first, KeyboardCallbackList::CallbackData data)
+bool ExistsInList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallbackList::CallbackData data)
 {
-	KeyboardCallbackList *w = first;
+	Keyboard::KeyboardCallbackList *w = first;
 	while (w)
 	{
 		if(data == w->function)
@@ -64,7 +90,7 @@ bool Keyboard::ExistsInList(KeyboardCallbackList* first, KeyboardCallbackList::C
 	}
 	return true;
 }
-bool Keyboard::ExistsInList(std::vector<KeyboardEvent*>& list, KeyboardEvent* data)
+bool ExistsInList(std::vector<Keyboard::KeyboardEvent*>& list, Keyboard::KeyboardEvent* data)
 {
 	for (unsigned int i = 0; i < list.size(); i++)
 	{
@@ -74,50 +100,114 @@ bool Keyboard::ExistsInList(std::vector<KeyboardEvent*>& list, KeyboardEvent* da
 	return false;
 }
 
+
+
+
 Keyboard::Keyboard()
 	:	InputObject(SAIType_Keyboard)
 	,	callbackList(0)
+	,	active(1)
+	,	textTarget(0)
+	,	writePos(0)
 {}
 Keyboard::~Keyboard()
 {
 
 }
 
-void Keyboard::AddOnKeyPressCallback (OnKeyPressCallback func)
+void Keyboard::InternalOnEvent(Struct::KeyboardEventData& data)
 {
-	KeyboardCallbackList::CallbackData d;
+	for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
-	d.keyPressCallback = func;
+	{
-	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnPress);
+		if(this->keyEventSubscrivers[i])
-	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnPress);
+		{
+			this->keyEventSubscrivers[i]->OnKeyEvent(data);
+		}
+	}
+	KeyboardCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == KeyboardCallbackList::CallbackDataType_OnEvent)
+			{
+				data.tag = w->tag;
+				w->function.keyEventCallback(data);
+			}
+		w = w->next;
+	}
 }
-void Keyboard::AddOnKeyDownCallback (OnKeyDownCallback func)
+void Keyboard::InternalOnKeyPress(Enum::SAKI key)
 {
-	KeyboardCallbackList::CallbackData d;
+	for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
-	d.keyDownCallback = func;
+	{
-	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnDown);
+		if(this->keyEventSubscrivers[i])
-	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnDown);
+		{
+			this->keyEventSubscrivers[i]->OnKeyPress(key, this);
+		}
+	}
+	KeyboardCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == KeyboardCallbackList::CallbackDataType_OnPress)
+			{
+				w->function.keyPressCallback(key, this, w->tag);
+			}
+		w = w->next;
+	}
 }
-void Keyboard::AddOnKeyReleaseCallback (OnKeyReleaseCallback func)
+void Keyboard::InternalOnKeyDown(Enum::SAKI key)
 {
-	KeyboardCallbackList::CallbackData d;
+	for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
-	d.keyReleaseCallback = func;
+	{
-	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnRelease);
+		if(this->keyEventSubscrivers[i])
-	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnRelease);
+		{
+			this->keyEventSubscrivers[i]->OnKeyDown(key, this);
+		}
+	}
+	KeyboardCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == KeyboardCallbackList::CallbackDataType_OnDown)
+				w->function.keyDownCallback(key, this, w->tag);
+		w = w->next;
+	}
+}
+void Keyboard::InternalOnKeyRelease(Enum::SAKI key)
+{
+	for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
+	{
+		if(this->keyEventSubscrivers[i])
+		{
+			this->keyEventSubscrivers[i]->OnKeyRelease(key, this);
+		}
+	}
+	KeyboardCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == KeyboardCallbackList::CallbackDataType_OnRelease)
+				w->function.keyReleaseCallback(key, this, w->tag);
+		w = w->next;
+	}
 }
 
-void Keyboard::RemoveOnKeyPressCallback (OnKeyPressCallback func)
+void Keyboard::AddKeyboardEvent(KeyboardEvent* object)
 {
-	RemoveFromList(this->callbackList, func);
+	if(ExistsInList(this->keyEventSubscrivers, object)) return;
-}
-void Keyboard::RemoveOnKeyDownCallback (OnKeyDownCallback func)
-{
-	RemoveFromList(this->callbackList, func);
-}
-void Keyboard::RemoveOnKeyReleaseCallback (OnKeyReleaseCallback func)
-{
-	RemoveFromList(this->callbackList, func);
-}
 
+	this->keyEventSubscrivers.push_back(object);
+}
+void Keyboard::RemoveKeyboardEvent(KeyboardEvent* object)
+{
+	int i = -1;
+	if((i = ExistsInList(this->keyEventSubscrivers, object)))
+	{
+		std::swap(this->keyEventSubscrivers[i], this->keyEventSubscrivers[this->keyEventSubscrivers.size() - 1]);
+		this->keyEventSubscrivers.resize(this->keyEventSubscrivers.size() - 1);
+	}
+}
 void Keyboard::operator+= (KeyboardEvent* object)
 {
 	if(ExistsInList(this->keyEventSubscrivers, object)) return;
@@ -134,3 +224,71 @@ void Keyboard::operator-= (KeyboardEvent* object)
 	}
 }
 
+void Keyboard::AddOnKeyEventCallback (OnKeyEventCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyEventCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnEvent, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnEvent, tag);
+}
+void Keyboard::AddOnKeyPressCallback (OnKeyPressCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyPressCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnPress, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnPress, tag);
+}
+void Keyboard::AddOnKeyDownCallback (OnKeyDownCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyDownCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnDown, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnDown, tag);
+}
+void Keyboard::AddOnKeyReleaseCallback (OnKeyReleaseCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyReleaseCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnRelease, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnRelease, tag);
+}
+
+void Keyboard::RemoveOnKeyEventCallback (OnKeyEventCallback func)
+{
+	Keyboard::KeyboardCallbackList::CallbackData temp;
+	temp.keyEventCallback = func;
+	RemoveFromList(this->callbackList, temp);
+}
+void Keyboard::RemoveOnKeyPressCallback (OnKeyPressCallback func)
+{
+	RemoveFromList(this->callbackList, func);
+}
+void Keyboard::RemoveOnKeyDownCallback (OnKeyDownCallback func)
+{
+	RemoveFromList(this->callbackList, func);
+}
+void Keyboard::RemoveOnKeyReleaseCallback (OnKeyReleaseCallback func)
+{
+	RemoveFromList(this->callbackList, func);
+}
+
+
+
+void Keyboard::BindTextTarget( ::std::wstring *field )
+{
+	this->textTarget = field;
+	
+	if( field )
+	{
+		this->writePos = field->size();
+	}
+	else
+	{
+		this->writePos = 0;
+	}
+}
+void Keyboard::ReleaseTextTarget( )
+{
+	this->BindTextTarget( nullptr );
+}
+

Code/Misc/Input/Source/Mouse.cpp

@@ -9,11 +9,44 @@ using namespace Input::Enum;
 using namespace Input::Struct;
 using namespace Input::Typedefs;
 
-
+struct Mouse::MouseCallbackList
-void Mouse::ClearList(Mouse::MouseCallbackList* first)
 {
-	MouseCallbackList* w = first;
+	enum CallbackDataType
-	MouseCallbackList* removee = 0;
+	{
+		CallbackDataType_OnEvent,
+		CallbackDataType_OnPress,
+		CallbackDataType_OnDown,
+		CallbackDataType_OnRelease,
+		CallbackDataType_OnMovePixelPos,
+		CallbackDataType_OnMoveVelocity,
+		CallbackDataType_OnScroll,
+	} type;
+	union CallbackData
+	{
+		Typedefs::OnMouseCallback mouseCallback;
+		Typedefs::OnMousePressCallback mousePressCallback;
+		Typedefs::OnMouseDownCallback mouseDownCallback;
+		Typedefs::OnMouseReleaseCallback mouseReleaseCallback;
+		Typedefs::OnMouseMovePixelPosCallback mouseMovePixelPosCallback;
+		Typedefs::OnMouseMoveVelocityCallback mouseMoveVelocityCallback;
+		Typedefs::OnMouseScrollCallback mouseScrollCallback;
+		void* dummy;
+
+		CallbackData (){ memset(this, 0, sizeof(CallbackData)); }
+		CallbackData (void* d){ dummy = d; }
+		bool operator ==(CallbackData o){ return o.dummy == dummy; }
+		bool operator ==(void* o ){ return o == dummy; }
+		operator bool(){ return this->dummy != 0; }
+	} function;
+	MouseCallbackList *next;
+	void* tag;
+	MouseCallbackList(CallbackData func, CallbackDataType t, void* ct) :function(func), next(0), type(t), tag(ct) { }
+};
+
+void ClearList(Mouse::MouseCallbackList* first)
+{
+	Mouse::MouseCallbackList* w = first;
+	Mouse::MouseCallbackList* removee = 0;
 
 	while (w)
 	{
@@ -22,27 +55,27 @@ void Mouse::ClearList(Mouse::MouseCallbackList* first)
 		delete removee;
 	}
 }
-void Mouse::AddToList(Mouse::MouseCallbackList* first, MouseCallbackList::CallbackData data, MouseCallbackList::CallbackDataType type)
+void AddToList(Mouse::MouseCallbackList* first, Mouse::MouseCallbackList::CallbackData data, Mouse::MouseCallbackList::CallbackDataType type, void* tag)
 {
-	MouseCallbackList *w = first;
+	Mouse::MouseCallbackList *w = first;
-	MouseCallbackList *prev = first;
+	Mouse::MouseCallbackList *prev = first;
 	while (w)
 	{ prev = w; w = w->next; }
 
-	MouseCallbackList::CallbackData f;
+	Mouse::MouseCallbackList::CallbackData f;
 	f = data;
 
-	prev->next = new MouseCallbackList(f, type);
+	prev->next = new Mouse::MouseCallbackList(f, type, tag);
 }
-void Mouse::RemoveFromList(MouseCallbackList* first, MouseCallbackList::CallbackData data)
+void RemoveFromList(Mouse::MouseCallbackList* first, Mouse::MouseCallbackList::CallbackData data)
 {
-	MouseCallbackList *w = first;
+	Mouse::MouseCallbackList *w = first;
-	MouseCallbackList *prev = first;
+	Mouse::MouseCallbackList *prev = first;
 	while (w)
 	{
 		if(data == w->function)
 		{
-			MouseCallbackList *removee = w;
+			Mouse::MouseCallbackList *removee = w;
 			w = w->next;
 			prev->next = w;
 			delete removee;
@@ -52,9 +85,9 @@ void Mouse::RemoveFromList(MouseCallbackList* first, MouseCallbackList::Callback
 		w = w->next; 
 	}
 }
-bool Mouse::ExistsInList(MouseCallbackList* first, MouseCallbackList::CallbackData data)
+bool ExistsInList(Mouse::MouseCallbackList* first, Mouse::MouseCallbackList::CallbackData data)
 {
-	MouseCallbackList *w = first;
+	Mouse::MouseCallbackList *w = first;
 	while (w)
 	{
 		if(data == w->function)
@@ -65,7 +98,7 @@ bool Mouse::ExistsInList(MouseCallbackList* first, MouseCallbackList::CallbackDa
 	}
 	return true;
 }
-bool Mouse::ExistsInList(std::vector<MouseEvent*>& list, MouseEvent* data)
+bool ExistsInList(std::vector<Mouse::MouseEvent*>& list, Mouse::MouseEvent* data)
 {
 	for (unsigned int i = 0; i < list.size(); i++)
 	{
@@ -81,6 +114,7 @@ Mouse::Mouse()
 	,	wheelDelta(0)
 	,	isCurorLocked(0)
 	,	pixelPos()
+	,	deltaPos()
 {
 }
 Mouse::~Mouse()
@@ -88,40 +122,190 @@ Mouse::~Mouse()
 
 }
 
-void Mouse::AddOnMousePressCallback( Typedefs::OnMousePressCallback func)
+void Mouse::InternalOnEvent(MouseEventData & data)
+{
+	for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+	{
+		if(this->mouseSubscribers[i])
+			this->mouseSubscribers[i]->OnMouse(data);
+	}
+	MouseCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == MouseCallbackList::CallbackDataType_OnEvent)
+			{
+				data.tag = w->tag;
+				w->function.mouseCallback(data);
+			}
+		w = w->next;
+	}
+}
+void Mouse::InternalOnBtnPress(Enum::SAMI btn)
+{
+	for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+	{
+		if(this->mouseSubscribers[i])
+			this->mouseSubscribers[i]->OnMousePress(btn, this);
+	}
+	MouseCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == MouseCallbackList::CallbackDataType_OnPress)
+				w->function.mousePressCallback(btn, this);
+		w = w->next;
+	}
+}
+void Mouse::InternalOnBtnDown(Enum::SAMI btn)
+{
+	for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+	{
+		if(this->mouseSubscribers[i])
+			this->mouseSubscribers[i]->OnMouseDown(btn, this);
+	}
+	MouseCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == MouseCallbackList::CallbackDataType_OnDown)
+				w->function.mouseDownCallback(btn, this);
+		w = w->next;
+	}
+}
+void Mouse::InternalOnBtnRelease(Enum::SAMI btn)
+{
+	for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+	{
+		if(this->mouseSubscribers[i])
+			this->mouseSubscribers[i]->OnMouseRelease(btn, this);
+	}
+	MouseCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == MouseCallbackList::CallbackDataType_OnRelease)
+				w->function.mouseReleaseCallback(btn, this);
+		w = w->next;
+	}
+}
+void Mouse::InternalOnMove(Struct::SAIPointInt2D pixelPos, Struct::SAIPointInt2D velocity)
+{
+	for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+	{
+		if(this->mouseSubscribers[i])
+		{
+			this->mouseSubscribers[i]->OnMouseMovePixelPos(pixelPos, this);
+			this->mouseSubscribers[i]->OnMouseMoveVelocity(velocity, this);
+		}
+	}
+	MouseCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == MouseCallbackList::CallbackDataType_OnMovePixelPos)
+				w->function.mouseMovePixelPosCallback(pixelPos, this);
+			else if (w->type == MouseCallbackList::CallbackDataType_OnMoveVelocity)
+				w->function.mouseMoveVelocityCallback(velocity, this);
+		w = w->next;
+	}
+}
+void Mouse::InternalOnScroll(int delta)
+{
+	for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+	{
+		if(this->mouseSubscribers[i])
+			this->mouseSubscribers[i]->OnMouseScroll(delta, this);
+	}
+	MouseCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == MouseCallbackList::CallbackDataType_OnScroll)
+				w->function.mouseScrollCallback(delta, this);
+		w = w->next;
+	}
+}
+
+void Mouse::AddMouseEvent(MouseEvent* object)
+{
+	if(ExistsInList(this->mouseSubscribers, object)) return;
+
+	this->mouseSubscribers.push_back(object);
+}
+void Mouse::RemoveMouseEvent(MouseEvent* object)
+{
+	int i = -1;
+	if((i = ExistsInList(this->mouseSubscribers, object)))
+	{
+		std::swap(this->mouseSubscribers[i], this->mouseSubscribers[this->mouseSubscribers.size() - 1]);
+		this->mouseSubscribers.resize(this->mouseSubscribers.size() - 1);
+	}
+}
+void Mouse::operator+= (MouseEvent* object)
+{
+	if(ExistsInList(this->mouseSubscribers, object)) return;
+
+	this->mouseSubscribers.push_back(object);
+}
+void Mouse::operator-= (MouseEvent* object)
+{
+	int i = -1;
+	if((i = ExistsInList(this->mouseSubscribers, object)))
+	{
+		std::swap(this->mouseSubscribers[i], this->mouseSubscribers[this->mouseSubscribers.size() - 1]);
+		this->mouseSubscribers.resize(this->mouseSubscribers.size() - 1);
+	}
+}
+
+void Mouse::AddOnMouseCallback( Typedefs::OnMouseCallback func, void* tag)
+{
+	MouseCallbackList::CallbackData d;
+	d.mouseCallback = func;
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnEvent, tag);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnEvent, tag);
+}
+void Mouse::AddOnMousePressCallback( Typedefs::OnMousePressCallback func, void* tag)
 {
 	MouseCallbackList::CallbackData d;
 	d.mousePressCallback = func;
-	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnRelease);
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnPress, tag);
-	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnRelease);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnPress, tag);
 }
-void Mouse::AddOnMouseDownCallback( Typedefs::OnMouseDownCallback func )
+void Mouse::AddOnMouseDownCallback( Typedefs::OnMouseDownCallback func, void* tag )
 {
 	MouseCallbackList::CallbackData d;
 	d.mouseDownCallback = func;
-	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnRelease);
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnDown, tag);
-	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnRelease);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnDown, tag);
 }
-void Mouse::AddOnMouseReleaseCallback( Typedefs::OnMouseReleaseCallback func )
+void Mouse::AddOnMouseReleaseCallback( Typedefs::OnMouseReleaseCallback func, void* tag )
 {
 	MouseCallbackList::CallbackData d;
 	d.mouseReleaseCallback = func;
-	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnRelease);
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnRelease, tag);
-	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnRelease);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnRelease, tag);
 }
-void Mouse::AddOnMouseMoveCallback( Typedefs::OnMouseMoveCallback func )
+void Mouse::AddOnMouseMovePixelPosCallback( Typedefs::OnMouseMovePixelPosCallback func, void* tag )
 {
 	MouseCallbackList::CallbackData d;
-	d.mouseMoveCallback = func;
+	d.mouseMovePixelPosCallback = func;
-	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnRelease);
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnMovePixelPos, tag);
-	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnRelease);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnMovePixelPos, tag);
 }
-void Mouse::AddOnMouseScrollCallback( Typedefs::OnMouseScrollCallback func )
+void Mouse::AddOnMouseMoveVelocityCallback( Typedefs::OnMouseMoveVelocityCallback func, void* tag )
+{
+	MouseCallbackList::CallbackData d;
+	d.mouseMoveVelocityCallback = func;
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnMoveVelocity, tag);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnMoveVelocity, tag);
+}
+void Mouse::AddOnMouseScrollCallback( Typedefs::OnMouseScrollCallback func, void* tag )
 {
 	MouseCallbackList::CallbackData d;
 	d.mouseScrollCallback = func;
-	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnRelease);
+	if(!this->callbackList) this->callbackList = new MouseCallbackList(d, MouseCallbackList::CallbackDataType_OnScroll, tag);
-	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnRelease);
+	else					AddToList(this->callbackList, d, MouseCallbackList::CallbackDataType_OnScroll, tag);
 }
 
 void Mouse::RemoveOnMousePressCallback( Typedefs::OnMousePressCallback func)
@@ -136,7 +320,11 @@ void Mouse::RemoveOnMouseReleaseCallback( Typedefs::OnMouseReleaseCallback func
 {
 	RemoveFromList(this->callbackList, func);
 }
-void Mouse::RemoveOnMouseMoveCallback( Typedefs::OnMouseMoveCallback func )
+void Mouse::RemoveOnMouseMovePixelPosCallback( Typedefs::OnMouseMovePixelPosCallback func )
+{
+	RemoveFromList(this->callbackList, func);
+}
+void Mouse::RemoveOnMouseMoveVelocityCallback( Typedefs::OnMouseMoveVelocityCallback func )
 {
 	RemoveFromList(this->callbackList, func);
 }
@@ -155,21 +343,6 @@ void Mouse::ToggleCursor(bool toggler)
 	this->isCurorLocked = toggler;
 }
 
-void Mouse::operator+= (MouseEvent* object)
-{
-	if(ExistsInList(this->mouseSubscribers, object)) return;
-
-	this->mouseSubscribers.push_back(object);
-}
-void Mouse::operator-= (MouseEvent* object)
-{
-	int i = -1;
-	if((i = ExistsInList(this->mouseSubscribers, object)))
-	{
-		std::swap(this->mouseSubscribers[i], this->mouseSubscribers[this->mouseSubscribers.size() - 1]);
-		this->mouseSubscribers.resize(this->mouseSubscribers.size() - 1);
-	}
-}
 
 
 

Code/Misc/Input/Source/Win32/Win32Input.cpp

@@ -16,608 +16,17 @@ using namespace Input::Enum;
 using namespace Input::Struct;
 using namespace Input::Typedefs;
 
-/*
-bool Win32Input::Input_AddDevice(IN const HWND& targetApplication)
-{
-	assert(targetApplication != 0);
-	static const UINT c = 2;
-	RAWINPUTDEVICE devices[c] = 
-	{ 
-		{ 0x01, RawInput_Usage_keyboard, RIDEV_NOLEGACY, targetApplication },
-		{ 0x01, RawInput_Usage_mouse, RIDEV_NOLEGACY | RIDEV_CAPTUREMOUSE, targetApplication }
-	};
-
-	if(! _addDevice( devices , c ) )	return false;
-
-	ShowCursor(FALSE);
-	//RECT r;
-	//GetWindow
-	//GetWindowRect(
-	 
-	return true;
-}
-bool Win32Input::Input_AddDevice(IN const RAWINPUTDEVICE* d, const int& count)
-{
-	for (int i = 0; i < count; i++)
-		if(!d[i].hwndTarget)
-		{
-			this->_errorMsg = L"Must specify target application";
-			return false;
-		}
-	if(! _addDevice( d, count ) )	return false;
-
-	return true;
-}
-
-//Win32InputDEVICE d = { 0x01, type, RIDEV_REMOVE, NULL };
-//this->_errorMsg = L"Failed to unregister device";
-
-
-void Win32Input::Input_Disable()	   
-{
-	this->_enabled = false;
-}
-void Win32Input::Input_Enable()	   
-{
-	this->_enabled = true;
-}
-
-void Win32Input::Input_Read()
-{
-	//for (int i = 0; i < this->_idleKeyData.size(); i++)
-	//	this->_proccessRawKeyboardData(this->_idleKeyData.pop());
-	//for (int i = 0; i < this->_idleMouseData.size(); i++)
-	//	this->_proccessRawMouseData(this->_idleMouseData.pop());
-	//
-	//this->_idleKeyData.clear();
-	//this->_idleMouseData.clear();
-}
-
-
-bool Win32Input::_addDevice						(const RAWINPUTDEVICE* k, const int& count)
-{
-	if(RegisterRawInputDevices(k, count, sizeof(RAWINPUTDEVICE)) == FALSE)
-	{
-		DWORD h = GetLastError();
-		INPUT_EXCEPT( L"Failed to register device" );
-		return false;
-	}
-
-	for (int q = 0; q < count; q++)
-	{
-		RawInputDeviceInstance i;
-		memcpy(&i.description, &k[q], sizeof(RAWINPUTDEVICE));
-		this->_deviceList.push(i);
-	}
-
-	return true;
-}
-*/
-
 Win32Input *Win32Input::instance = 0;
-void MapKey(RAWKEYBOARD& rawKB, bool& out_isUp, SAKI& out_key, unsigned int& sCode, bool& isE0)
+TRACKMOUSEEVENT tme;
-{
+
-	//------------------------------------------------------------------------------------//
+LRESULT Win32Input::RawInputParser(HWND h, LPARAM l)
-	// http://molecularmusings.wordpress.com/2011/09/05/properly-handling-keyboard-input/ //
-	//------------------------------------------------------------------------------------//
-
-	UINT virtualKey = rawKB.VKey;
-	UINT scanCode = rawKB.MakeCode;
-	UINT flags = rawKB.Flags;
-
-	if (virtualKey == 255)
-	{
-		// discard "fake keys" which are part of an escaped sequence
-		return;
-	}
-	else if (virtualKey == VK_SHIFT)
-	{
-		// correct left-hand / right-hand SHIFT
-		virtualKey = MapVirtualKey(scanCode, MAPVK_VSC_TO_VK_EX);
-	}
-	else if (virtualKey == VK_NUMLOCK)
-	{
-		// correct PAUSE/BREAK and NUM LOCK silliness, and set the extended bit
-		scanCode = (MapVirtualKey(virtualKey, MAPVK_VK_TO_VSC) | 0x100);
-	}
-
-	// e0 and e1 are escape sequences used for certain special keys, such as PRINT and PAUSE/BREAK.
-	// see http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
-	isE0 = ((flags & RI_KEY_E0) != 0);
-	const bool isE1 = ((flags & RI_KEY_E1) != 0);
- 
-	if (isE1)
-	{
-		// for escaped sequences, turn the virtual key into the correct scan code using MapVirtualKey.
-		// however, MapVirtualKey is unable to map VK_PAUSE (this is a known bug), hence we map that by hand.
-		if (virtualKey == VK_PAUSE) scanCode = 0x45;
-		else						scanCode = MapVirtualKey(virtualKey, MAPVK_VK_TO_VSC);
-	}
-
-	switch (virtualKey)
-	{
-		// right-hand CONTROL and ALT have their e0 bit set
-		case VK_CONTROL:
-			if (isE0)	out_key = SAKI_RightCtrl;
-			else		out_key = SAKI_LeftCtrl;
-		break;
- 
-		case VK_MENU:
-			if (isE0)	out_key = SAKI_RightAlt;
-			else		out_key = SAKI_LeftAlt;
-		break;
- 
-		// NUMPAD ENTER has its e0 bit set
-		case VK_RETURN:
-			if (isE0)	out_key = SAKI_NumpadEnter;
-		break;
- 
-		// the standard INSERT, DELETE, HOME, END, PRIOR and NEXT keys will always have their e0 bit set, but the
-		// corresponding keys on the NUMPAD will not.
-		case VK_INSERT:
-			if (!isE0)	out_key = SAKI_Numpad0;
-		break;
- 
-		case VK_DELETE:
-			if (!isE0)	out_key = SAKI_NumpadDecimal;
-		break;
- 
-		case VK_HOME:
-			if (!isE0)	out_key = SAKI_Numpad7;
-		break;
- 
-		case VK_END:
-			if (!isE0)	out_key = SAKI_Numpad1;
-		break;
- 
-		case VK_PRIOR:
-			if (!isE0)	out_key = SAKI_Numpad9;
-		break;
- 
-		case VK_NEXT:
-			if (!isE0)	out_key = SAKI_Numpad3;
-		break;
- 
-		// the standard arrow keys will always have their e0 bit set, but the
-		// corresponding keys on the NUMPAD will not.
-		case VK_LEFT:
-			if (!isE0)	out_key = SAKI_Numpad4;
-		break;
- 
-		case VK_RIGHT:
-			if (!isE0)	out_key = SAKI_Numpad6;
-		break;
- 
-		case VK_UP:
-			if (!isE0)	out_key = SAKI_Numpad8;
-		break;
- 
-		case VK_DOWN:
-			if (!isE0)	out_key = SAKI_Numpad2;
-		break;
- 
-		// NUMPAD 5 doesn't have its e0 bit set
-		case VK_CLEAR:
-			if (!isE0)	out_key = SAKI_Numpad5;
-		break;
-		case 0x03	:	//VK_CANCEL				
-		break;
-		case 0x08	:	//VK_BACK	
-			out_key = SAKI_Backspace;
-		break;	
-		case 0x09	:	//VK_TAB	
-			out_key = SAKI_Tab;
-		break;	
-		case 0x10	:	//VK_SHIFT	
-			out_key = SAKI_LeftShift;
-			out_key = SAKI_RightShift;
-		break;	
-		case 0x13	:	//VK_PAUSE	
-			out_key = SAKI_Pause;
-		break;
-		case 0x14	:	//VK_CAPITAL
-			out_key = SAKI_CapsLock;
-		break;	
-		case 0x15	:	//VK_KANA				
-		break;	
-		case 0x1B	:	//VK_ESCAPE	
-			out_key = SAKI_Escape;
-		break;
-		case 0x1C	:	//VK_CONVERT			
-		break;	
-		case 0x1D	:	//VK_NONCONVERT			
-		break;
-		case 0x1E	:	//VK_ACCEPT				
-		break;
-		case 0x1F	:	//VK_MODECHANGE			
-		break;
-		case 0x20	:	//VK_SPACE	
-			out_key = SAKI_Space;
-		break;	
-		case 0x29	:	//VK_SELECT				
-		break;
-		case 0x2A	:	//VK_PRINT	
-			out_key = SAKI_PrintScreen;
-		break;
-		case 0x2B	:	//VK_EXECUTE			
-		break;	
-		case 0x2C	:	//VK_SNAPSHOT			
-		break;	
-		case 0x2F	:	//VK_HELP				
-		break;	
-		case 0x30	:	//0 key	
-			out_key = SAKI_0;
-		break;
-		case 0x31	:	//1 key	
-			out_key = SAKI_1;
-		break;
-		case 0x32	:	//2 key	
-			out_key = SAKI_2;
-		break;
-		case 0x33	:	//3 key	
-			out_key = SAKI_3;
-		break;
-		case 0x34	:	//4 key	
-			out_key = SAKI_4;
-		break;
-		case 0x35	:	//5 key	
-			out_key = SAKI_5;
-		break;
-		case 0x36	:	//6 key		
-			out_key = SAKI_6;
-		break;
-		case 0x37	:	//7 key	
-			out_key = SAKI_7;
-		break;
-		case 0x38	:	//8 key		
-			out_key = SAKI_8;
-		break;
-		case 0x39	:	//9 key		
-			out_key = SAKI_9;
-		break;
-		case 0x41	:	//A key		
-			out_key = SAKI_A;
-		break;
-		case 0x42	:	//B key	
-			out_key = SAKI_B;
-		break;
-		case 0x43	:	//C key		
-			out_key = SAKI_C;
-		break;
-		case 0x44	:	//D key	
-			out_key = SAKI_D;
-		break;
-		case 0x45	:	//E key	
-			out_key = SAKI_E;
-		break;
-		case 0x46	:	//F key		
-			out_key = SAKI_F;
-		break;
-		case 0x47	:	//G key		
-			out_key = SAKI_G;
-		break;
-		case 0x48	:	//H key	
-			out_key = SAKI_H;
-		break;
-		case 0x49	:	//I key		
-			out_key = SAKI_I;
-		break;
-		case 0x4A	:	//J key	
-			out_key = SAKI_J;
-		break;
-		case 0x4B	:	//K key	
-			out_key = SAKI_K;
-		break;
-		case 0x4C	:	//L key	
-			out_key = SAKI_L;
-		break;
-		case 0x4D	:	//M key	
-			out_key = SAKI_M;
-		break;
-		case 0x4E	:	//N key	
-			out_key = SAKI_N;
-		break;
-		case 0x4F	:	//O key	
-			out_key = SAKI_O;
-		break;
-		case 0x50	:	//P key	
-			out_key = SAKI_P;				
-		break;
-		case 0x51	:	//Q key	
-			out_key = SAKI_Q;				
-		break;
-		case 0x52	:	//R key	
-			out_key = SAKI_R;				
-		break;
-		case 0x53	:	//S key	
-			out_key = SAKI_S;				
-		break;
-		case 0x54	:	//T key	
-			out_key = SAKI_T;				
-		break;
-		case 0x55	:	//U key	
-			out_key = SAKI_U;				
-		break;
-		case 0x56	:	//V key	
-			out_key = SAKI_V;				
-		break;
-		case 0x57	:	//W key	
-			out_key = SAKI_W;				
-		break;
-		case 0x58	:	//X key	
-			out_key = SAKI_X;				
-		break;
-		case 0x59	:	//Y key	
-			out_key = SAKI_Y;				
-		break;
-		case 0x5A	:	//Z key	
-			out_key = SAKI_Z;				
-		break;
-		case 0x5B	:	//VK_LWIN				
-		break;	
-		case 0x5C	:	//VK_RWIN				
-		break;	
-		case 0x5D	:	//VK_APPS				
-		break;	
-		case 0x5F	:	//VK_SLEEP				
-		break;
-		case 0x60	:	//VK_NUMPAD0
-			out_key = SAKI_Numpad0;
-		break;	
-		case 0x61	:	//VK_NUMPAD1	
-			out_key = SAKI_Numpad1;
-		break;	
-		case 0x62	:	//VK_NUMPAD2	
-			out_key = SAKI_Numpad2;
-		break;	
-		case 0x63	:	//VK_NUMPAD3	
-			out_key = SAKI_Numpad3;
-		break;	
-		case 0x64	:	//VK_NUMPAD4	
-			out_key = SAKI_Numpad4;
-		break;	
-		case 0x65	:	//VK_NUMPAD5	
-			out_key = SAKI_Numpad5;
-		break;	
-		case 0x66	:	//VK_NUMPAD6	
-			out_key = SAKI_Numpad6;
-		break;	
-		case 0x67	:	//VK_NUMPAD7	
-			out_key = SAKI_Numpad7;
-		break;	
-		case 0x68	:	//VK_NUMPAD8	
-			out_key = SAKI_Numpad8;
-		break;	
-		case 0x69	:	//VK_NUMPAD9	
-			out_key = SAKI_Numpad9;
-		break;	
-		case 0x6A	:	//VK_MULTIPLY	
-			out_key = SAKI_NumpadMultiply;		
-		break;	
-		case 0x6B	:	//VK_ADD	
-			out_key = SAKI_NumpadPlus;			
-		break;	
-		case 0x6C	:	//VK_SEPARATOR			
-		break;
-		case 0x6D	:	//VK_SUBTRACT
-			out_key = SAKI_NumpadSubtract;			
-		break;	
-		case 0x6E	:	//VK_DECIMAL	
-			out_key = SAKI_NumpadDecimal;		
-		break;	
-		case 0x6F	:	//VK_DIVIDE	
-			out_key = SAKI_NumpadDivide;			
-		break;
-		case 0x70	:	//VK_F1	
-			out_key = SAKI_F1;				
-		break;
-		case 0x71	:	//VK_F2	
-			out_key = SAKI_F2;				
-		break;
-		case 0x72	:	//VK_F3	
-			out_key = SAKI_F3;				
-		break;
-		case 0x73	:	//VK_F4	
-			out_key = SAKI_F4;				
-		break;
-		case 0x74	:	//VK_F5	
-			out_key = SAKI_F5;				
-		break;
-		case 0x75	:	//VK_F6	
-			out_key = SAKI_F6;				
-		break;
-		case 0x76	:	//VK_F7	
-			out_key = SAKI_F7;				
-		break;
-		case 0x77	:	//VK_F8	
-			out_key = SAKI_F8;				
-		break;
-		case 0x78	:	//VK_F9	
-			out_key = SAKI_F9;				
-		break;
-		case 0x79	:	//VK_F10
-			out_key = SAKI_F10;				
-		break;	
-		case 0x7A	:	//VK_F11
-			out_key = SAKI_F11;				
-		break;	
-		case 0x7B	:	//VK_F12
-			out_key = SAKI_F12;				
-		break;	
-		case 0x7C	:	//VK_F13
-			out_key = SAKI_F13;				
-		break;	
-		case 0x7D	:	//VK_F14
-			out_key = SAKI_F14;				
-		break;	
-		case 0x7E	:	//VK_F15
-			out_key = SAKI_F15;				
-		break;	
-		case 0x7F	:	//VK_F16
-			out_key = SAKI_F16;				
-		break;	
-		case 0x80	:	//VK_F17	
-			out_key = SAKI_F17;			
-		break;	
-		case 0x81	:	//VK_F18
-			out_key = SAKI_F18;				
-		break;	
-		case 0x82	:	//VK_F19
-			out_key = SAKI_F19;				
-		break;	
-		case 0x83	:	//VK_F20	
-			out_key = SAKI_F20;			
-		break;	
-		case 0x84	:	//VK_F21	
-			out_key = SAKI_F21;			
-		break;	
-		case 0x85	:	//VK_F22	
-			out_key = SAKI_F22;			
-		break;	
-		case 0x86	:	//VK_F23	
-			out_key = SAKI_F23;			
-		break;	
-		case 0x87	:	//VK_F24	
-			out_key = SAKI_F24;			
-		break;	
-		case 0x90	:	//VK_NUMLOCK
-			out_key = SAKI_Numlock;			
-		break;	
-		case 0x91	:	//VK_SCROLL
-			out_key = SAKI_ScrlLock;				
-		break;
-		case 0xA0	:	//VK_LSHIFT	
-			out_key = SAKI_LeftShift;			
-		break;
-		case 0xA1	:	//VK_RSHIFT		
-			out_key = SAKI_RightShift;		
-		break;
-		case 0xA2	:	//VK_LCONTROL	
-			out_key = SAKI_LeftCtrl;
-		break;	
-		case 0xA3	:	//VK_RCONTROL	
-			out_key = SAKI_RightCtrl;
-		break;	
-		case 0xA4	:	//VK_LMENU	
-			out_key = SAKI_LeftAlt;
-		break;
-		case 0xA5	:	//VK_RMENU
-			out_key = SAKI_RightCtrl;
-		break;
-		case 0xAD	:	//VK_VOLUME_MUTE	
-			out_key = SAKI_VolumeMute;
-		break;	
-		case 0xAE	:	//VK_VOLUME_DOWN	
-			out_key = SAKI_VolumeDown;
-		break;	
-		case 0xAF	:	//VK_VOLUME_UP	
-			out_key = SAKI_VolumeUp;
-		break;
-		case 0xB0	:	//VK_MEDIA_NEXT_TRACK	
-			out_key = SAKI_MediaNext;
-		break;	
-		case 0xB1	:	//VK_MEDIA_PREV_TRACK	
-			out_key = SAKI_MediaPrev;
-		break;	
-		case 0xB2	:	//VK_MEDIA_STOP		
-			out_key = SAKI_MediaStop;
-		break;	
-		case 0xB3	:	//VK_MEDIA_PLAY_PAUSE	
-			out_key = SAKI_MediaPlayPause;
-		break;
-
-		case 0xBB://VK_OEM_PLUS		
-		break;
-		case 0xBC://VK_OEM_COMMA	
-		break;
-		case 0xBD://VK_OEM_MINUS	
-		break;
-		case 0xBE://VK_OEM_PERIOD	
-		break;
-		case 0xBA://VK_OEM_1		
-		break;
-		case 0xBF://VK_OEM_2	
-		break;	
-		case 0xC0://VK_OEM_3	
-		break;	
-		case 0xDB://VK_OEM_4	
-		break;	
-		case 0xDC://VK_OEM_5	
-		break;	
-		case 0xDD://VK_OEM_6
-		break;	
-		case 0xDE://VK_OEM_7	
-		break;	
-		case 0xDF://VK_OEM_8	
-		break;
-	}
-
-	out_isUp = ((flags & RI_KEY_BREAK) != 0);
-	rawKB.MakeCode = scanCode;
-	sCode = scanCode;
-}
-void MapButton(RAWMOUSE& rawMouse, bool &isUp, Enum::SAMI& btn, int& delta, Struct::SAIPoint2D& vel, unsigned int& mcode)
-{
-	if(rawMouse.lLastX != 0 || rawMouse.lLastY != 0)
-	{
-		vel.x = rawMouse.lLastX;
-		vel.y = rawMouse.lLastY;
-	}
-	if( rawMouse.usButtonFlags > 0 )
-	{
-//--------------------------------------------------------------------------------------
-		//Mouse button pressed
-		if(rawMouse.usButtonFlags == RI_MOUSE_LEFT_BUTTON_DOWN)	
-		{
-			btn = SAMI_MouseLeftBtn;
-			isUp = false;
-		}
-		else if(rawMouse.usButtonFlags == RI_MOUSE_MIDDLE_BUTTON_DOWN)	
-		{	
-			btn = SAMI_MouseMiddleBtn;
-			isUp = false;
-		}
-		else if(rawMouse.usButtonFlags == RI_MOUSE_RIGHT_BUTTON_DOWN)	
-		{	
-			btn = SAMI_MouseRightBtn;
-			isUp = false;
-		}
-//--------------------------------------------------------------------------------------
-		//Mouse button Released
-		else if(rawMouse.usButtonFlags == RI_MOUSE_LEFT_BUTTON_UP)	
-		{
-			btn = SAMI_MouseLeftBtn;
-			isUp = true;
-		}
-		else if(rawMouse.usButtonFlags == RI_MOUSE_MIDDLE_BUTTON_UP)	
-		{
-			btn = SAMI_MouseMiddleBtn;
-			isUp = true;
-		}
-		else if(rawMouse.usButtonFlags == RI_MOUSE_RIGHT_BUTTON_UP)	
-		{
-			btn = SAMI_MouseRightBtn;
-			isUp = true;
-		}
-//--------------------------------------------------------------------------------------
-		else if (rawMouse.usButtonFlags == RI_MOUSE_WHEEL)
-		{
-			delta = ((int)rawMouse.usButtonData);
-	
-			if(delta > 120)	delta = -1;
-			else			delta = 1;
-		}
-	}
-}
-void Win32Input::RawInputParser(HWND h, LPARAM l)
 {
+	LRESULT val = 0;
 	//Get The size of the raw data buffer
 	UINT bufferSize;
 	GetRawInputData((HRAWINPUT)l, RID_INPUT, NULL, &bufferSize, sizeof(RAWINPUTHEADER));
 	if (bufferSize < 1) 
-	{
+	{ return 0; } 
-		return;
-	} 
 
 	//Create and read the raw input data
 	LPBYTE rawBufferIn = new BYTE[bufferSize];
@@ -625,63 +34,78 @@ void Win32Input::RawInputParser(HWND h, LPARAM l)
 	if ( readBytes != bufferSize )
 	{
 		delete [] rawBufferIn;
-		return;
+		return 0;
 	}
 
 	RAWINPUT* raw = (RAWINPUT*)rawBufferIn;
 
-
 	if(!Win32Input::instance->enabled)
 	{
-		if(FAILED ( DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER)) ) )	
+		val = DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER));	
-		{
-			
-		}
 	}
 	else
 	{
 		if(raw->header.dwType == RIM_TYPEMOUSE)	
 		{
+			bool once = false;
 			for (unsigned int i = 0; i < Win32Input::instance->mouse.size(); i++)
 			{
-				bool isUp = true;
+				if(Win32Input::instance->mouse[i]->IsActive())
-				Enum::SAMI btn = Enum::SAMI_Unknown;
+				{
-				int delta = 0;
+					Win32Input::instance->mouse[i]->ProccessMouseData(raw->data.mouse);
-				Struct::SAIPoint2D vel;
+				}
-				unsigned int mcode = 0;
+				else
-				MapButton(raw->data.mouse, isUp, btn, delta, vel, mcode);
+				{
-
+					if(!once) val = DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER));
-				Win32Input::instance->mouse[i]->ProccessMouseData(isUp, btn, delta, vel, mcode);
+				}
 			}
 		}
 		else if(raw->header.dwType == RIM_TYPEKEYBOARD)	
 		{	
+			bool once = false;
 			for (unsigned int i = 0; i < Win32Input::instance->keyboard.size(); i++)
 			{
-				bool isUp;
+				if(Win32Input::instance->keyboard[i]->IsActive())
-				SAKI key = SAKI_Unknown;
+				{
-				unsigned int makeCode;
+					Win32Input::instance->keyboard[i]->ProccessKeyboardData(raw->data.keyboard);
-				bool isE0;
+				}
-				MapKey(raw->data.keyboard, isUp, key, makeCode, isE0);
+				else
-				Win32Input::instance->keyboard[i]->ProccessKeyboardData(isUp, key, makeCode, isE0);
+				{
+					if(!once) val = DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER));
+				}
 			}
 		}
 	}
 
 	delete raw;
+	return val;
 }
 LRESULT CALLBACK Win32Input::RawWindowCallback(HWND h, UINT m, WPARAM w, LPARAM l)
 {
+	LRESULT val = 0;
 	switch (m)
 	{
 		case WM_INPUT:
-			Win32Input::instance->RawInputParser(h, l);
+			return Win32Input::instance->RawInputParser(h, l);
 		break;
+		
 		case WM_ACTIVATE:
 			Win32Input::instance->WindowActivate((w == TRUE));
 		break;
 		case WM_CREATE:
 			Win32Input::instance->WindowActivate(true);
+			//tme.cbSize=sizeof(tme);
+			//tme.dwFlags=TME_HOVER;
+			//tme.hwndTrack=h;//hanlde of window you want the mouse over message for.
+			//tme.dwHoverTime=HOVER_DEFAULT;
+			//if(TrackMouseEvent(&tme) == FALSE)
+			//{ }
+		break;
+		case WM_MOUSEHOVER:
+			//val = 0;
+		break;
+		case WM_MOUSELEAVE:
+			//val = 0;
 		break;
 	}
 
@@ -689,19 +113,20 @@ LRESULT CALLBACK Win32Input::RawWindowCallback(HWND h, UINT m, WPARAM w, LPARAM
 }
 void Win32Input::WindowActivate(bool activate)
 {
-	if(activate)
+	//if(activate)
-	{
+	//{
-		ShowCursor(0);
+	//	ShowCursor(0);
-	}
+	//}
-	else
+	//else
-	{
+	//{
-		ShowCursor(0);
+	//	ShowCursor(1);
-	}
+	//}
 }
 
 
 Win32Input::Win32Input()
 {
+	this->targetHwin = 0;
 	if(!this->instance) 
 	{
 		this->instance = this;
@@ -725,70 +150,82 @@ Win32Input::Win32Input()
 	{ /*wrong*/ }
 }
 Win32Input::~Win32Input()
-{}
+{ Destroy(); }
 InputObject* Win32Input::CreateDevice(const SAIType inputType, Typedefs::WindowHandle targetApplication)
 {
 	if(!this->instance->targetHwin)
 	{
-		this->targetHwin = CreateWindowExW(  0, L"RawInputCallbackFunc" ,  NULL, NULL, NULL, NULL, NULL, 
+		RECT rc;
-												NULL, (HWND)targetApplication, NULL, (HINSTANCE)GetModuleHandle(0), NULL ); 
+		GetClientRect((HWND)targetApplication, &rc);
+		
+		AdjustWindowRect(&rc, GetWindowStyle((HWND)targetApplication), FALSE);
+		
+		rc.right  = rc.right - rc.left;
+		rc.bottom = rc.bottom - rc.top;
+
+		this->targetHwin = CreateWindowExW(  0, L"RawInputCallbackFunc" ,  NULL, NULL, rc.left, rc.top, rc.right, rc.bottom, 
+											(HWND)targetApplication, NULL, (HINSTANCE)GetModuleHandle(0), NULL ); 
 	}
+
 	InputObject* val = 0;
-	RAWINPUTDEVICE rid;
-	rid.usUsagePage = 0x01;
-	rid.hwndTarget = this->instance->targetHwin;
 
 	switch (inputType)
 	{
 		case SAIType_Keyboard:
 		{
-			rid.usUsage = RawInput_Usage_keyboard;
+			Win32Keyboard* obj = new Win32Keyboard(this->targetHwin);
-			rid.dwFlags = RIDEV_NOLEGACY;
+			if(!obj->Create())
-			if(RegisterRawInputDevices(&rid, 1, sizeof(RAWINPUTDEVICE)) == TRUE)
-			{
-				Win32Keyboard* obj = new Win32Keyboard();
-				this->keyboard.push_back(obj);
-				val = obj;
-			}
-			else
 			{
+				delete obj;
 				return 0;
 			}
+
+			this->keyboard.push_back(obj);
+			val = obj;
 		}
 		break;
 
 		case SAIType_Mouse:
 		{
-			rid.usUsage = RawInput_Usage_mouse;
+			Win32Mouse* obj = new Win32Mouse(this->targetHwin);
-			rid.dwFlags = RIDEV_NOLEGACY | RIDEV_CAPTUREMOUSE;
+			if(!obj->Create())
-			if(RegisterRawInputDevices(&rid, 1, sizeof(RAWINPUTDEVICE)) == TRUE)
-			{
-				int i = 0;
-				val = (InputObject*)1;
-				Win32Mouse* obj = new Win32Mouse();
-				this->mouse.push_back(obj);
-				val = obj;
-			}
-			else
 			{
+				delete obj;
 				return 0;
 			}
+
+			this->mouse.push_back(obj);
+			val = obj;
 		}
 		break;
 	}
 
 	return val;
 }
+
 void Win32Input::ToggleInputSystem(bool enable)
 {
 	this->enabled = enable;
+
+	if(this->enabled)
+	{
+		for (unsigned int i = 0; i < this->mouse.size(); i++)
+		{ this->mouse[i]->Deactivate(); }
+		for (unsigned int i = 0; i < this->keyboard.size(); i++)
+		{ this->keyboard[i]->Deactivate(); }
+	}
+	else
+	{
+		for (unsigned int i = 0; i < this->mouse.size(); i++)
+		{ this->mouse[i]->Activate(); }
+		for (unsigned int i = 0; i < this->keyboard.size(); i++)
+		{ this->keyboard[i]->Activate(); }
+	}
 }
 void Win32Input::Destroy ()
 {
 	ShowCursor(true);
-	RECT r;
+	ClipCursor(0);
-	GetWindowRect(GetDesktopWindow(), &r);
-	ClipCursor(&r);
 
 	for (unsigned int i = 0; i < this->keyboard.size(); i++)
 	{
@@ -802,52 +239,3 @@ void Win32Input::Destroy ()
 	this->keyboard.resize(0);
 }
 
-
-/* This method is used with hooks!
-
-LRESULT CALLBACK RawInput::WM_INPUT_TRANSLATE	(int nCode, WPARAM wParam, LPARAM lparam)
-{
-	if (nCode < 0)		return CallNextHookEx(RawInput::Self()->_msgHook, nCode, wParam, lparam); 
-
-
-	MSG *m = (MSG*)lparam;
-	
-	if(m->message == WM_INPUT)
-	{
-		RAWINPUT* raw = RawInput::Self()->_TranslateRawInput(m->lParam);
-
-		if(!raw) goto nextHook;
-		if(!RawInput::Self()->Self()->_enabled)
-		{
-			if(FAILED ( DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER)) ) )	
-				RawInput::Self()->_errorMsg = L"Failed to proccess default raw input";
-			goto _final;
-		}
-		//	 if(raw->header.dwType == RIM_TYPEMOUSE)	RawInput::Self()->_idleMouseData.insert(raw->data.mouse);
-		//else if(raw->header.dwType == RIM_TYPEKEYBOARD)	RawInput::Self()->_proccessRawKeyboardData(raw->data.keyboard);
-		
-
-		_final:
-
-		//if(FAILED ( DefRawInputProc(&raw, 1, sizeof(RAWINPUTHEADER)) ) )
-		//		RawInput::Self()->_errorMsg = L"Failed to proccess default raw input";
-
-		delete raw;
-	}
-	else if (m->message == WM_QUIT)
-	{
-		if(UnhookWindowsHookEx(RawInput::Self()->_msgHook) == FALSE)
-		{
-			RawInput::Self()->_errorMsg = L"Failed to unhook message hook!";
-		}
-	}
-
-
-	nextHook:
-	return CallNextHookEx(RawInput::Self()->_msgHook, nCode, wParam, lparam); 
-}
-*/
-
-
-
-

Code/Misc/Input/Source/Win32/Win32Keyboard.cpp

@@ -1,14 +1,23 @@
 /////////////////////////////////////////////////////////////////////
 // Created by [Dennis Andersen] [2013]
 /////////////////////////////////////////////////////////////////////
-#include "..\..\Include\Win32\Win32Keyboard.h"
+#include "..\..\Include\Win32\Win32Input.h"
+#include <algorithm>
 
 #pragma warning ( disable : 4172 )
 using namespace Input;
 using namespace Input::Enum;
+using namespace std;
 
-Win32Keyboard::Win32Keyboard()
+
+Win32Keyboard::Win32Keyboard(HWND target)
 {
+	this->isActive = false;
+	this->device.usUsagePage = 0x01;
+	this->device.hwndTarget = target;
+	this->device.usUsage = RawInput_Usage_keyboard;
+	this->device.dwFlags = RIDEV_NOLEGACY;
+	this->writePos = 0;
 	memset(&this->keys[0], 0, sizeof(Win32Keyboard::Keys) * MAXKEYS);
 }
 Win32Keyboard::~Win32Keyboard()
@@ -24,115 +33,705 @@ bool Win32Keyboard::IsKeyDown (SAKI key)
 {
 	return this->keys[key].isDown;
 }
-const wchar_t* Win32Keyboard::GetAsText(Enum::SAKI key)
+wchar_t* Win32Keyboard::GetAsText(Enum::SAKI key)
 {
 	if(Enum::SAKI_Unknown == key) return 0;
 
 	// getting a human-readable string
 	UINT temp = (this->keys[key].makecode << 16) | (this->keys[key].isE0 << 24);
-	wchar_t buff[56] = {0};
+	wchar_t buff[16] = {0};
-	GetKeyNameTextW((LONG)temp, buff, 64);
+	GetKeyNameTextW((LONG)temp, buff, 16);
 	return buff;
 }
-void Win32Keyboard::ProccessKeyboardData (bool isUp, SAKI key, unsigned int makeCode, bool isE0)
+
+void Win32Keyboard::Activate ()
 {
-	if(key == SAKI_Unknown) return;
+	if(this->isActive) return;
-	//The key is released.
+
-	if(isUp)/*(k.Flags == RI_KEY_BREAK || k.Flags == (RI_KEY_BREAK | RI_KEY_E0) || k.Flags == (RI_KEY_BREAK | RI_KEY_E1))*/
+	this->Create();
+}
+void Win32Keyboard::Deactivate ()
+{
+	if(!this->isActive) return;
+
+	RAWINPUTDEVICE d;
+	d.dwFlags = RIDEV_REMOVE;
+	d.hwndTarget = 0;
+	d.usUsage = RawInput_Usage_keyboard;
+	d.usUsagePage = 0x01;
+	if(RegisterRawInputDevices(&d, 1, sizeof(RAWINPUTDEVICE)))
 	{
-		if(key == SAKI_LeftAlt)
+		this->isActive = true;
-		{  }
+	}
-		else if(key == SAKI_LeftCtrl)
+}
-		{}
+
-		else if(key == SAKI_LeftShift)
+void Win32Keyboard::ProccessKeyboardData (RAWKEYBOARD keyboard)
-		{}
+{
-		else if(key == SAKI_RightAlt)
+	if(!this->active)	return;
-		{}
+
-		else if(key == SAKI_RightCtrl)
+	static Struct::KeyboardEventData keyboardEventData;
-		{}
+	memset(&keyboardEventData, 0, sizeof(Struct::KeyboardEventData));
-		else if(key == SAKI_RightShift)
+
-		{}
+	bool isUp = (( keyboard.Flags & RI_KEY_BREAK) != 0);
-		else
+	SAKI key = SAKI_Unknown;
+	bool isE0;
+	
+	MapKey(keyboard, key, isE0);
+
+	if(key != SAKI_Unknown)
+	{
+		//The key is released.
+		if(isUp)/*(k.Flags == RI_KEY_BREAK || k.Flags == (RI_KEY_BREAK | RI_KEY_E0) || k.Flags == (RI_KEY_BREAK | RI_KEY_E1))*/
 		{
+			InternalOnKeyRelease(key);
 			this->keys[key].isDown = false;
 			this->keys[key].isE0 = isE0;
-			this->keys[key].makecode = makeCode;
+			this->keys[key].makecode = keyboard.MakeCode;
-			for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
-			{
-				if(this->keyEventSubscrivers[i])
-				{
-					this->keyEventSubscrivers[i]->OnKeyRelease(key, GetAsText(key), this);
-				}
-			}
-			KeyboardCallbackList *w = this->callbackList;
-			while (w)
-			{
-				if(w->function)
-					if (w->type == KeyboardCallbackList::CallbackDataType_OnRelease)
-						w->function.keyReleaseCallback(key, GetAsText(key), this);
-				w = w->next;
-			}
-		}
 
-		//this->_procCollection.kd.key = (RIK)k.VKey;
+			keyboardEventData.key = key;
-		//this->_procCollection.kd.released = true;
+			keyboardEventData.sender = this;
-	}
+			keyboardEventData.state = Enum::ButtonState_Release;
-	//The key is pressed.
+			InternalOnEvent(keyboardEventData);
-	else /*if (k.Flags == RI_KEY_MAKE || k.Flags == (RI_KEY_MAKE | RI_KEY_E0) || k.Flags == (RI_KEY_MAKE | RI_KEY_E1))*/
+		}
-	{
+		//The key is pressed.
-		if(key == SAKI_LeftAlt)
+		else /*if (k.Flags == RI_KEY_MAKE || k.Flags == (RI_KEY_MAKE | RI_KEY_E0) || k.Flags == (RI_KEY_MAKE | RI_KEY_E1))*/
-		{}
-		else if(key == SAKI_LeftCtrl)
-		{}
-		else if(key == SAKI_LeftShift)
-		{}
-		else if(key == SAKI_RightAlt)
-		{}
-		else if(key == SAKI_RightCtrl)
-		{}
-		else if(key == SAKI_RightShift)
-		{}
-		else
 		{
 			if(this->keys[key].isDown)
 			{
-				for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
+				this->InternalOnKeyDown(key);
-				{
+
-					if(this->keyEventSubscrivers[i])
+				keyboardEventData.key = key;
-					{
+				keyboardEventData.sender = this;
-						this->keyEventSubscrivers[i]->OnKeyDown(key, GetAsText(key), this);
+				keyboardEventData.state = Enum::ButtonState_Down;
-					}
+				InternalOnEvent(keyboardEventData);
-				}
-				KeyboardCallbackList *w = this->callbackList;
-				while (w)
-				{
-					if(w->function)
-						if (w->type == KeyboardCallbackList::CallbackDataType_OnDown)
-							w->function.keyDownCallback(key, GetAsText(key), this);
-					w = w->next;
-				}
 			}
 			else
 			{
+				this->InternalOnKeyPress(key);
 				this->keys[key].isDown = true;
 				this->keys[key].isE0 = isE0;
-				this->keys[key].makecode = makeCode;
+				this->keys[key].makecode = keyboard.MakeCode;
-				for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
+
-				{
+				keyboardEventData.key = key;
-					if(this->keyEventSubscrivers[i])
+				keyboardEventData.sender = this;
-					{
+				keyboardEventData.state = Enum::ButtonState_Press;
-						this->keyEventSubscrivers[i]->OnKeyPress(key, GetAsText(key), this);
+				InternalOnEvent(keyboardEventData);
-					}
-				}
-				KeyboardCallbackList *w = this->callbackList;
-				while (w)
-				{
-					if(w->function)
-						if (w->type == KeyboardCallbackList::CallbackDataType_OnPress)
-							w->function.keyPressCallback(key, GetAsText(key), this);
-					w = w->next;
-				}
 			}
 		}
 	}
+
+	if(this->textTarget)
+	{ //Parse text
+		UINT virtualKey = MapVirtualKey(keyboard.VKey, MAPVK_VK_TO_CHAR);
+		
+		if(this->keys[SAKI_Backspace].isDown)
+		{
+			if( this->writePos > 0 )
+			{
+				--this->writePos;
+				this->textTarget->erase( this->writePos, 1 );
+			}
+		}
+		else if (this->keys[SAKI_Delete].isDown)
+		{
+			if( this->writePos < this->textTarget->size() )
+			{
+				this->textTarget->erase( this->writePos, 1 );
+			}
+		}
+		else if (this->keys[SAKI_Left].isDown)
+		{
+			this->writePos = std::max( ((int)this->writePos) - 1, (int)(wstring::size_type)0 );
+		}
+		else if (this->keys[SAKI_Right].isDown)
+		{
+			this->writePos = std::min( this->writePos + 1, this->textTarget->size() );
+		}
+		else if (this->keys[SAKI_Enter].isDown || this->keys[SAKI_NumpadEnter].isDown)
+		{
+			this->textTarget->insert( this->writePos, 1, '\n');
+		}
+		else if ( this->keys[SAKI_Tab].isDown )
+		{
+			this->textTarget->insert( this->writePos, 1, '\t');
+		}
+		else if (virtualKey && !isUp)
+		{
+			wchar_t test = towlower((wchar_t)virtualKey);
+			if( this->keys[SAKI_LeftShift].isDown || this->keys[SAKI_RightShift].isDown )
+			{
+					 if(key == SAKI_0)		test = L'=';
+				else if(key == SAKI_1)		test = L'!';
+				else if(key == SAKI_2)		test = L'"';
+				else if(key == SAKI_3)		test = L'#';
+				else if(key == SAKI_4)		test = L'¤';
+				else if(key == SAKI_5)		test = L'%';
+				else if(key == SAKI_6)		test = L'&';
+				else if(key == SAKI_7)		test = L'/';
+				else if(key == SAKI_8)		test = L'(';
+				else if(key == SAKI_9)		test = L')';
+				else if(key == SAKI_Add)	test = L'?';
+				test = towupper(test);
+			}
+			else if( this->keys[SAKI_LeftAlt].isDown || this->keys[SAKI_RightAlt].isDown )
+			{
+					 if(key == SAKI_2)		test = L'@';
+				else if(key == SAKI_3)		test = L'£';
+				else if(key == SAKI_4)		test = L'$';
+				else if(key == SAKI_5)		test = L'€';
+				else if(key == SAKI_7)		test = L'{';
+				else if(key == SAKI_8)		test = L'[';
+				else if(key == SAKI_9)		test = L']';
+				else if(key == SAKI_0)		test = L'}';
+				else if(key == SAKI_Add)	test = L'\\';
+			}
+
+			this->textTarget->insert( this->writePos, 1, test);
+			++this->writePos;
+		}
+		
+	}
 }
+
+
+void Win32Keyboard::MapKey(RAWKEYBOARD& rawKB, SAKI& out_key, bool& isE0)
+{
+	//------------------------------------------------------------------------------------//
+	// http://molecularmusings.wordpress.com/2011/09/05/properly-handling-keyboard-input/ //
+	//------------------------------------------------------------------------------------//
+
+	UINT virtualKey = rawKB.VKey;
+	UINT scanCode = rawKB.MakeCode;
+	UINT flags = rawKB.Flags;
+
+	if (virtualKey == 255)
+	{
+		// discard "fake keys" which are part of an escaped sequence
+		return;
+	}
+	else if (virtualKey == VK_SHIFT)
+	{
+		// correct left-hand / right-hand SHIFT
+		virtualKey = MapVirtualKey(scanCode, MAPVK_VSC_TO_VK_EX);
+	}
+	else if (virtualKey == VK_NUMLOCK)
+	{
+		// correct PAUSE/BREAK and NUM LOCK silliness, and set the extended bit
+		scanCode = (MapVirtualKey(virtualKey, MAPVK_VK_TO_VSC) | 0x100);
+	}
+
+	// e0 and e1 are escape sequences used for certain special keys, such as PRINT and PAUSE/BREAK.
+	// see http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
+	isE0 = ((flags & RI_KEY_E0) != 0);
+	const bool isE1 = ((flags & RI_KEY_E1) != 0);
+ 
+	if (isE1)
+	{
+		// for escaped sequences, turn the virtual key into the correct scan code using MapVirtualKey.
+		// however, MapVirtualKey is unable to map VK_PAUSE (this is a known bug), hence we map that by hand.
+		if (virtualKey == VK_PAUSE) scanCode = 0x45;
+		else						scanCode = MapVirtualKey(virtualKey, MAPVK_VK_TO_VSC);
+	}
+
+	
+
+	switch (virtualKey)
+	{
+		// right-hand CONTROL and ALT have their e0 bit set
+		case VK_CONTROL:
+			if (isE0)	out_key = SAKI_RightCtrl;
+			else		out_key = SAKI_LeftCtrl;
+		break;
+ 
+		case VK_MENU:
+			if (isE0)	out_key = SAKI_RightAlt;
+			else		out_key = SAKI_LeftAlt;
+		break;
+ 
+		// NUMPAD ENTER has its e0 bit set
+		case VK_RETURN:
+			if (isE0)	out_key = SAKI_NumpadEnter;
+		break;
+ 
+		// the standard INSERT, DELETE, HOME, END, PRIOR and NEXT keys will always have their e0 bit set, but the
+		// corresponding keys on the NUMPAD will not.
+		case VK_INSERT:
+			if (!isE0)	out_key = SAKI_Numpad0;
+			 
+		break;
+ 
+		case VK_DELETE:
+			if (!isE0)	out_key = SAKI_NumpadDecimal;
+			else		out_key = SAKI_Delete;
+		break;
+ 
+		case VK_HOME:
+			if (!isE0)	out_key = SAKI_Numpad7;
+			 
+		break;
+ 
+		case VK_END:
+			if (!isE0)	out_key = SAKI_Numpad1;
+			 
+		break;
+ 
+		case VK_PRIOR:
+			if (!isE0)	out_key = SAKI_Numpad9;
+			 
+		break;
+ 
+		case VK_NEXT:
+			if (!isE0)	out_key = SAKI_Numpad3;
+			
+		break;
+ 
+		// the standard arrow keys will always have their e0 bit set, but the
+		// corresponding keys on the NUMPAD will not.
+		case VK_LEFT:
+			if (!isE0)	out_key = SAKI_Numpad4;
+			else		out_key = SAKI_Left;
+		break;
+ 
+		case VK_RIGHT:
+			if (!isE0)	out_key = SAKI_Numpad6;
+			else		out_key = SAKI_Right;
+		break;
+ 
+		case VK_UP:
+			if (!isE0)	out_key = SAKI_Numpad8;
+			 else		out_key = SAKI_Up;
+		break;
+ 
+		case VK_DOWN:
+			if (!isE0)	out_key = SAKI_Numpad2;
+			 
+		break;
+ 
+		// NUMPAD 5 doesn't have its e0 bit set
+		case VK_CLEAR:
+			if (!isE0)	out_key = SAKI_Numpad5;
+			 
+		break;
+		case 0x03	:	//VK_CANCEL				
+		break;
+		case 0x08	:	//VK_BACK	
+			out_key = SAKI_Backspace;
+		break;	
+		case 0x09	:	//VK_TAB	
+			out_key = SAKI_Tab;
+		break;	
+		case 0x10	:	//VK_SHIFT	
+			out_key = SAKI_LeftShift;
+			out_key = SAKI_RightShift;
+		break;	
+		case 0x13	:	//VK_PAUSE
+			out_key = SAKI_Pause;
+		break;
+		case 0x14	:	//VK_CAPITAL
+			out_key = SAKI_CapsLock;
+		break;	
+		case 0x15	:	//VK_KANA				
+		break;	
+		case 0x1B	:	//VK_ESCAPE	
+			out_key = SAKI_Escape;
+		break;
+		case 0x1C	:	//VK_CONVERT			
+		break;	
+		case 0x1D	:	//VK_NONCONVERT			
+		break;
+		case 0x1E	:	//VK_ACCEPT				
+		break;
+		case 0x1F	:	//VK_MODECHANGE			
+		break;
+		case 0x20	:	//VK_SPACE	
+			out_key = SAKI_Space;
+			 
+		break;	
+		case 0x29	:	//VK_SELECT				
+		break;
+		case 0x2A	:	//VK_PRINT	
+			out_key = SAKI_PrintScreen;
+		break;
+		case 0x2B	:	//VK_EXECUTE			
+		break;	
+		case 0x2C	:	//VK_SNAPSHOT			
+		break;	
+		case 0x2F	:	//VK_HELP				
+		break;	
+		case 0x30	:	//0 key	
+			out_key = SAKI_0;
+			 
+		break;
+		case 0x31	:	//1 key	
+			out_key = SAKI_1;
+			 
+		break;
+		case 0x32	:	//2 key	
+			out_key = SAKI_2;
+			 
+		break;
+		case 0x33	:	//3 key	
+			out_key = SAKI_3;
+			 
+		break;
+		case 0x34	:	//4 key	
+			out_key = SAKI_4;
+			 
+		break;
+		case 0x35	:	//5 key	
+			out_key = SAKI_5;
+			 
+		break;
+		case 0x36	:	//6 key		
+			out_key = SAKI_6;
+			 
+		break;
+		case 0x37	:	//7 key	
+			out_key = SAKI_7;
+			 
+		break;
+		case 0x38	:	//8 key		
+			out_key = SAKI_8;
+			 
+		break;
+		case 0x39	:	//9 key		
+			out_key = SAKI_9;
+			 
+		break;
+		case 0x41	:	//A key		
+			out_key = SAKI_A;
+			 
+		break;
+		case 0x42	:	//B key	
+			out_key = SAKI_B;
+			 
+		break;
+		case 0x43	:	//C key		
+			out_key = SAKI_C;
+			 
+		break;
+		case 0x44	:	//D key	
+			out_key = SAKI_D;
+			 
+		break;
+		case 0x45	:	//E key	
+			out_key = SAKI_E;
+			 
+		break;
+		case 0x46	:	//F key		
+			out_key = SAKI_F;
+			 
+		break;
+		case 0x47	:	//G key		
+			out_key = SAKI_G;
+			 
+		break;
+		case 0x48	:	//H key	
+			out_key = SAKI_H;
+			 
+		break;
+		case 0x49	:	//I key		
+			out_key = SAKI_I;
+			 
+		break;
+		case 0x4A	:	//J key	
+			out_key = SAKI_J;
+			 
+		break;
+		case 0x4B	:	//K key	
+			out_key = SAKI_K;
+			 
+		break;
+		case 0x4C	:	//L key	
+			out_key = SAKI_L;
+			 
+		break;
+		case 0x4D	:	//M key	
+			out_key = SAKI_M;
+			 
+		break;
+		case 0x4E	:	//N key	
+			out_key = SAKI_N;
+			 
+		break;
+		case 0x4F	:	//O key	
+			out_key = SAKI_O;
+			 
+		break;
+		case 0x50	:	//P key	
+			out_key = SAKI_P;	
+			 			
+		break;
+		case 0x51	:	//Q key	
+			out_key = SAKI_Q;	
+			 			
+		break;
+		case 0x52	:	//R key	
+			out_key = SAKI_R;	
+			 			
+		break;
+		case 0x53	:	//S key	
+			out_key = SAKI_S;	
+			 			
+		break;
+		case 0x54	:	//T key	
+			out_key = SAKI_T;	
+			 			
+		break;
+		case 0x55	:	//U key	
+			out_key = SAKI_U;	
+			 			
+		break;
+		case 0x56	:	//V key	
+			out_key = SAKI_V;	
+			 			
+		break;
+		case 0x57	:	//W key	
+			out_key = SAKI_W;	
+			 			
+		break;
+		case 0x58	:	//X key	
+			out_key = SAKI_X;	
+			 			
+		break;
+		case 0x59	:	//Y key	
+			out_key = SAKI_Y;	
+			 			
+		break;
+		case 0x5A	:	//Z key	
+			out_key = SAKI_Z;	
+			 			
+		break;
+		case 0x5B	:	//VK_LWIN				
+		break;	
+		case 0x5C	:	//VK_RWIN				
+		break;	
+		case 0x5D	:	//VK_APPS				
+		break;	
+		case 0x5F	:	//VK_SLEEP				
+		break;
+		case 0x60	:	//VK_NUMPAD0
+			out_key = SAKI_Numpad0;
+			 
+		break;	
+		case 0x61	:	//VK_NUMPAD1	
+			out_key = SAKI_Numpad1;
+			 
+		break;	
+		case 0x62	:	//VK_NUMPAD2	
+			out_key = SAKI_Numpad2;
+			 
+		break;	
+		case 0x63	:	//VK_NUMPAD3	
+			out_key = SAKI_Numpad3;
+			 
+		break;	
+		case 0x64	:	//VK_NUMPAD4	
+			out_key = SAKI_Numpad4;
+			 
+		break;	
+		case 0x65	:	//VK_NUMPAD5	
+			out_key = SAKI_Numpad5;
+			 
+		break;	
+		case 0x66	:	//VK_NUMPAD6	
+			out_key = SAKI_Numpad6;
+			 
+		break;	
+		case 0x67	:	//VK_NUMPAD7	
+			out_key = SAKI_Numpad7;
+			 
+		break;	
+		case 0x68	:	//VK_NUMPAD8	
+			out_key = SAKI_Numpad8;
+			 
+		break;	
+		case 0x69	:	//VK_NUMPAD9	
+			out_key = SAKI_Numpad9;
+			 
+		break;	
+		case 0x6A	:	//VK_MULTIPLY	
+			out_key = SAKI_NumpadMultiply;	
+			 	
+		break;	
+		case 0x6B	:	//VK_ADD	
+			out_key = SAKI_NumpadPlus;		
+			 	
+		break;	
+		case 0x6C	:	//VK_SEPARATOR			
+		break;
+		case 0x6D	:	//VK_SUBTRACT
+			out_key = SAKI_NumpadSubtract;	
+			 		
+		break;	
+		case 0x6E	:	//VK_DECIMAL	
+			out_key = SAKI_NumpadDecimal;	
+			 	
+		break;	
+		case 0x6F	:	//VK_DIVIDE	
+			out_key = SAKI_NumpadDivide;	
+			 		
+		break;
+		case 0x70	:	//VK_F1	
+			out_key = SAKI_F1;				
+		break;
+		case 0x71	:	//VK_F2	
+			out_key = SAKI_F2;				
+		break;
+		case 0x72	:	//VK_F3	
+			out_key = SAKI_F3;				
+		break;
+		case 0x73	:	//VK_F4	
+			out_key = SAKI_F4;				
+		break;
+		case 0x74	:	//VK_F5	
+			out_key = SAKI_F5;				
+		break;
+		case 0x75	:	//VK_F6	
+			out_key = SAKI_F6;				
+		break;
+		case 0x76	:	//VK_F7	
+			out_key = SAKI_F7;				
+		break;
+		case 0x77	:	//VK_F8	
+			out_key = SAKI_F8;				
+		break;
+		case 0x78	:	//VK_F9	
+			out_key = SAKI_F9;				
+		break;
+		case 0x79	:	//VK_F10
+			out_key = SAKI_F10;				
+		break;	
+		case 0x7A	:	//VK_F11
+			out_key = SAKI_F11;				
+		break;	
+		case 0x7B	:	//VK_F12
+			out_key = SAKI_F12;				
+		break;	
+		case 0x7C	:	//VK_F13
+			out_key = SAKI_F13;				
+		break;	
+		case 0x7D	:	//VK_F14
+			out_key = SAKI_F14;				
+		break;	
+		case 0x7E	:	//VK_F15
+			out_key = SAKI_F15;				
+		break;	
+		case 0x7F	:	//VK_F16
+			out_key = SAKI_F16;				
+		break;	
+		case 0x80	:	//VK_F17	
+			out_key = SAKI_F17;			
+		break;	
+		case 0x81	:	//VK_F18
+			out_key = SAKI_F18;				
+		break;	
+		case 0x82	:	//VK_F19
+			out_key = SAKI_F19;				
+		break;	
+		case 0x83	:	//VK_F20	
+			out_key = SAKI_F20;			
+		break;	
+		case 0x84	:	//VK_F21	
+			out_key = SAKI_F21;			
+		break;	
+		case 0x85	:	//VK_F22	
+			out_key = SAKI_F22;			
+		break;	
+		case 0x86	:	//VK_F23	
+			out_key = SAKI_F23;			
+		break;	
+		case 0x87	:	//VK_F24	
+			out_key = SAKI_F24;			
+		break;	
+		case 0x90	:	//VK_NUMLOCK
+			out_key = SAKI_Numlock;			
+		break;	
+		case 0x91	:	//VK_SCROLL
+			out_key = SAKI_ScrlLock;				
+		break;
+		case 0xA0	:	//VK_LSHIFT	
+			out_key = SAKI_LeftShift;			
+		break;
+		case 0xA1	:	//VK_RSHIFT		
+			out_key = SAKI_RightShift;		
+		break;
+		case 0xA2	:	//VK_LCONTROL	
+			out_key = SAKI_LeftCtrl;
+		break;	
+		case 0xA3	:	//VK_RCONTROL	
+			out_key = SAKI_RightCtrl;
+		break;	
+		case 0xA4	:	//VK_LMENU	
+			out_key = SAKI_LeftAlt;
+		break;
+		case 0xA5	:	//VK_RMENU
+			out_key = SAKI_RightCtrl;
+		break;
+		case 0xAD	:	//VK_VOLUME_MUTE	
+			out_key = SAKI_VolumeMute;
+		break;	
+		case 0xAE	:	//VK_VOLUME_DOWN	
+			out_key = SAKI_VolumeDown;
+		break;	
+		case 0xAF	:	//VK_VOLUME_UP	
+			out_key = SAKI_VolumeUp;
+		break;
+		case 0xB0	:	//VK_MEDIA_NEXT_TRACK	
+			out_key = SAKI_MediaNext;
+		break;	
+		case 0xB1	:	//VK_MEDIA_PREV_TRACK	
+			out_key = SAKI_MediaPrev;
+		break;	
+		case 0xB2	:	//VK_MEDIA_STOP		
+			out_key = SAKI_MediaStop;
+		break;	
+		case 0xB3	:	//VK_MEDIA_PLAY_PAUSE	
+			out_key = SAKI_MediaPlayPause;
+		break;
+
+		case 0xBB://VK_OEM_PLUS		
+			out_key = SAKI_Add;
+		break;
+		case 0xBC://VK_OEM_COMMA	
+			out_key = SAKI_Comma;
+		break;
+		case 0xBD://VK_OEM_MINUS	
+			out_key = SAKI_Minus;
+		break;
+		case 0xBE://VK_OEM_PERIOD	
+			out_key = SAKI_Period;
+		break;
+		case 0xBA://VK_OEM_1		
+		break;
+		case 0xBF://VK_OEM_2	
+		break;	
+		case 0xC0://VK_OEM_3	
+		break;	
+		case 0xDB://VK_OEM_4	
+		break;	
+		case 0xDC://VK_OEM_5	
+		break;	
+		case 0xDD://VK_OEM_6
+		break;	
+		case 0xDE://VK_OEM_7	
+		break;	
+		case 0xDF://VK_OEM_8	
+		break;
+	}
+}
+bool Win32Keyboard::Create()
+{
+	if(RegisterRawInputDevices(&this->device, 1, sizeof(RAWINPUTDEVICE)) == TRUE)
+	{
+		this->isActive = true;
+		return true;
+	}
+
+	return false;
+}
+
+
+
+
+

Code/Misc/Input/Source/Win32/Win32Mouse.cpp

@@ -1,82 +1,200 @@
 /////////////////////////////////////////////////////////////////////
 // Created by [Dennis Andersen] [2013]
 /////////////////////////////////////////////////////////////////////
-#include "..\..\Include\Win32\Win32Mouse.h"
+#include "..\..\Include\Win32\Win32Input.h"
 
 using namespace Input;
 using namespace Input::Enum;
 using namespace Input::Struct;
 using namespace Input::Typedefs;
 
-
+void MapButton(RAWMOUSE& rawMouse, bool &isUp, Enum::SAMI& btn, int& delta, Struct::SAIPointInt2D& vel, unsigned int& mcode)
-Win32Mouse::Win32Mouse()
 {
+	if(rawMouse.lLastX != 0 || rawMouse.lLastY != 0)
+	{
+		vel.x = rawMouse.lLastX;
+		vel.y = rawMouse.lLastY;
+	}
+	if( rawMouse.usButtonFlags > 0 )
+	{
+//--------------------------------------------------------------------------------------
+		//Mouse button pressed
+		if(rawMouse.usButtonFlags == RI_MOUSE_LEFT_BUTTON_DOWN)	
+		{
+			btn = SAMI_MouseLeftBtn;
+			isUp = false;
+		}
+		else if(rawMouse.usButtonFlags == RI_MOUSE_MIDDLE_BUTTON_DOWN)	
+		{	
+			btn = SAMI_MouseMiddleBtn;
+			isUp = false;
+		}
+		else if(rawMouse.usButtonFlags == RI_MOUSE_RIGHT_BUTTON_DOWN)	
+		{	
+			btn = SAMI_MouseRightBtn;
+			isUp = false;
+		}
+//--------------------------------------------------------------------------------------
+		//Mouse button Released
+		else if(rawMouse.usButtonFlags == RI_MOUSE_LEFT_BUTTON_UP)	
+		{
+			btn = SAMI_MouseLeftBtn;
+			isUp = true;
+		}
+		else if(rawMouse.usButtonFlags == RI_MOUSE_MIDDLE_BUTTON_UP)	
+		{
+			btn = SAMI_MouseMiddleBtn;
+			isUp = true;
+		}
+		else if(rawMouse.usButtonFlags == RI_MOUSE_RIGHT_BUTTON_UP)	
+		{
+			btn = SAMI_MouseRightBtn;
+			isUp = true;
+		}
+//--------------------------------------------------------------------------------------
+		else if (rawMouse.usButtonFlags == RI_MOUSE_WHEEL)
+		{
+			delta = ((int)rawMouse.usButtonData);
+	
+			if(delta > 120)	delta = -1;
+			else			delta = 1;
+		}
+	}
+}
+
+void ContainPoint(Struct::SAIPointInt2D& pixelPos, Struct::SAIPointInt2D& windowSize)
+{
+		 if(pixelPos.x < 0)				{ pixelPos.x = 0;				}
+	else if(pixelPos.x > windowSize.x)	{ pixelPos.x = windowSize.x;	}
+		 if(pixelPos.y < 0)				{ pixelPos.y = 0;				}
+	else if(pixelPos.y > windowSize.y)	{ pixelPos.y = windowSize.y;	}
+}
+
+Win32Mouse::Win32Mouse(HWND target)
+{
+	this->isActive = false;
+	this->device.usUsagePage = 0x01;
+	this->device.hwndTarget = target;
+	this->device.usUsage = RawInput_Usage_mouse;
+	this->device.dwFlags = RIDEV_NOLEGACY | RIDEV_CAPTUREMOUSE;
 	memset(&this->buttons[0], 0, sizeof(Buttons) * MAXBUTTONS);
 }
 Win32Mouse::~Win32Mouse()
-{
+{  }
-}
 
 
-bool Win32Mouse::IsBtnUp(Enum::SAMI btn)
+bool Win32Mouse::IsBtnUp(Enum::SAMI btn) const
 {
 	if(btn == SAMI_Unknown) return false;
 
 	return !this->buttons[btn].isDown;
 }
-bool Win32Mouse::IsBtnDown(Enum::SAMI btn)
+bool Win32Mouse::IsBtnDown(Enum::SAMI btn) const
 {
 	if(btn == SAMI_Unknown) return false;
 
 	return this->buttons[btn].isDown;
 }
-int Win32Mouse::GetWheelDelta()
+int Win32Mouse::GetWheelDelta() const
 {
 	return this->wheelDelta;
 }
-Struct::SAIPoint2D Win32Mouse::GetPixelPosition(Struct::SAIPoint2D targetMem)
+SAIPointInt2D& Win32Mouse::GetPixelPosition( Struct::SAIPointInt2D &targetMem ) const
 {
-	targetMem = this->pixelPos;
+	memcpy(&targetMem, &this->pixelPos, sizeof(SAIPointFloat2D));
+
+	return targetMem;
+}
+SAIPointFloat2D& Win32Mouse::GetNormalizedPosition(Struct::SAIPointFloat2D& targetMem)
+{
+	RECT windowVertex;
+	GetWindowRect( this->device.hwndTarget, &windowVertex );
+
+	this->normalPos.x = (float)(pixelPos.x - windowVertex.left);
+	this->normalPos.x /= (float)(windowVertex.right - windowVertex.left);
+
+	this->normalPos.y = (float)(pixelPos.y - windowVertex.top);
+	this->normalPos.y /= (float)(windowVertex.bottom - windowVertex.top);
+
+	memcpy(&targetMem, &this->normalPos, sizeof(SAIPointFloat2D));
+
+	return targetMem;
+}
+SAIPointFloat2D& Win32Mouse::GetDeltaPosition(Struct::SAIPointFloat2D& targetMem) const
+{
+	memcpy(&targetMem, &this->deltaPos, sizeof(SAIPointFloat2D));
+
 	return targetMem;
 }
 
-void Win32Mouse::ProccessMouseData (bool isUp, Enum::SAMI btn, int delta, Struct::SAIPoint2D velocity, unsigned int makeCode)
+void Win32Mouse::Activate ()
 {
+	if(this->isActive) return;
+
+	this->Create();
+}
+void Win32Mouse::Deactivate ()
+{
+	if(!this->isActive) return;
+
+	RAWINPUTDEVICE d;
+	d.dwFlags = RIDEV_REMOVE;
+	d.hwndTarget = 0;
+	d.usUsage = RawInput_Usage_mouse;
+	d.usUsagePage = 0x01;
+	if(RegisterRawInputDevices(&d, 1, sizeof(RAWINPUTDEVICE)))
+	{
+		this->isActive = false;
+		SetCursorPos(this->winCursPos.x, this->winCursPos.y);
+		ShowCursor(TRUE);
+	}
+}
+
+void Win32Mouse::ProccessMouseData (RAWMOUSE mouse)
+{
+	static MouseEventData mouseEventData;
+	memset(&mouseEventData, 0, sizeof(MouseEventData));
+
+
+	bool isUp = true;
+	Enum::SAMI btn = Enum::SAMI_Unknown;
+	int delta = 0;
+	Struct::SAIPointInt2D velocity;
+	unsigned int makeCode = 0;
+	MapButton(mouse, isUp, btn, delta, velocity, makeCode);
+
 	if(velocity.Length() != 0)
 	{
 		this->pixelPos.x += velocity.x;
 		this->pixelPos.y += velocity.y;
 
-		for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+		ContainPoint(this->pixelPos, this->windowSize);
-		{
+
-			if(this->mouseSubscribers[i])
+		InternalOnMove(this->pixelPos, velocity);
-				this->mouseSubscribers[i]->OnMouseMove(this->pixelPos, this);
+
-		}
+		GetNormalizedPosition( mouseEventData.normalizedPos );
-		MouseCallbackList *w = this->callbackList;
+		mouseEventData.pixelPos			= this->pixelPos;
-		while (w)
+		mouseEventData.velocity			= velocity;
-		{
+		mouseEventData.buttonState		= Enum::ButtonState_Unknown;
-			if(w->function)
+		mouseEventData.scrollDelta		= 0;
-				if (w->type == MouseCallbackList::CallbackDataType_OnMove)
+		mouseEventData.sender			= this;
-					w->function.mouseMoveCallback(this->pixelPos, this);
+		mouseEventData.type				= SAMI::SAMI_MouseMove;
-			w = w->next;
+		
-		}
+		InternalOnEvent(mouseEventData);
 	}
 
 	if(delta != 0)
 	{
-		for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+		InternalOnScroll(delta);
-		{
+
-			if(this->mouseSubscribers[i])
+		GetNormalizedPosition( mouseEventData.normalizedPos );
-				this->mouseSubscribers[i]->OnMouseScroll(delta, this);
+		mouseEventData.pixelPos			= this->pixelPos;
-		}
+		mouseEventData.buttonState		= Enum::ButtonState_Unknown;
-		MouseCallbackList *w = this->callbackList;
+		mouseEventData.scrollDelta		= delta;
-		while (w)
+		mouseEventData.sender			= this;
-		{
+		mouseEventData.type				= SAMI::SAMI_MouseScroll;
-			if(w->function)
+		
-				if (w->type == MouseCallbackList::CallbackDataType_OnMove)
+		InternalOnEvent(mouseEventData);
-					w->function.mouseScrollCallback(delta, this);
-			w = w->next;
-		}
 	}
 
 
@@ -88,54 +206,78 @@ void Win32Mouse::ProccessMouseData (bool isUp, Enum::SAMI btn, int delta, Struct
 	//The btn is released.
 	if(isUp)
 	{
-		for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+		InternalOnBtnRelease(btn);
-		{
+
-			if(this->mouseSubscribers[i])
+		GetNormalizedPosition( mouseEventData.normalizedPos );
-				this->mouseSubscribers[i]->OnMouseRelease(btn, this);
+		mouseEventData.pixelPos			= this->pixelPos;
-		}
+		mouseEventData.buttonState		= Enum::ButtonState_Release;
-		MouseCallbackList *w = this->callbackList;
+		mouseEventData.type				= btn;
-		while (w)
+		mouseEventData.sender			= this;
-		{
+		
-			if(w->function)
+		InternalOnEvent(mouseEventData);
-				if (w->type == MouseCallbackList::CallbackDataType_OnRelease)
-					w->function.mouseReleaseCallback(btn, this);
-			w = w->next;
-		}
 	}
 	//The btn is pressed.
 	else
 	{
+		//The btn is down since last frame
 		if(this->buttons[btn].isDown)
 		{
-			for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+			InternalOnBtnDown(btn);
-			{
+
-				if(this->mouseSubscribers[i])
+			GetNormalizedPosition( mouseEventData.normalizedPos );
-					this->mouseSubscribers[i]->OnMouseDown(btn, this);
+			mouseEventData.pixelPos			= this->pixelPos;
-			}
+			mouseEventData.buttonState		= Enum::ButtonState_Down;
-			MouseCallbackList *w = this->callbackList;
+			mouseEventData.type				= btn;
-			while (w)
+			mouseEventData.sender			= this;
-			{
+		
-				if(w->function)
+			InternalOnEvent(mouseEventData);
-					if (w->type == MouseCallbackList::CallbackDataType_OnDown)
-						w->function.mouseDownCallback(btn, this);
-				w = w->next;
-			}
 		}
 		else
 		{
-			for (unsigned int i = 0; i < this->mouseSubscribers.size(); i++)
+			InternalOnBtnPress(btn);
-			{
+
-				if(this->mouseSubscribers[i])
+			GetNormalizedPosition( mouseEventData.normalizedPos );
-					this->mouseSubscribers[i]->OnMousePress(btn, this);
+			mouseEventData.pixelPos			= this->pixelPos;
-			}
+			mouseEventData.buttonState		= Enum::ButtonState_Press;
-			MouseCallbackList *w = this->callbackList;
+			mouseEventData.type				= btn;
-			while (w)
+			mouseEventData.sender			= this;
-			{
+		
-				if(w->function)
+			InternalOnEvent(mouseEventData);
-					if (w->type == MouseCallbackList::CallbackDataType_OnPress)
-						w->function.mousePressCallback(btn, this);
-				w = w->next;
-			}
 		}
 	}
 }
+bool Win32Mouse::Create()
+{
+	if(!this->device.hwndTarget)
+	{
+		RECT desktop;
+		const HWND hDesktop = GetDesktopWindow();
+		GetClientRect(hDesktop, &desktop);
+		windowSize.x = desktop.right;
+		windowSize.y = desktop.bottom;
+		this->device.dwFlags = 0;
+	}
+	else
+	{
+		RECT re;
+		GetClientRect(this->device.hwndTarget, &re);
+		windowSize.x = re.right - re.left;
+		windowSize.y = re.bottom - re.top;
+	}
+
+	if(RegisterRawInputDevices(&this->device, 1, sizeof(RAWINPUTDEVICE)) == TRUE)
+	{
+		this->isActive = true;
+		POINT p;
+		GetCursorPos(&p);
+		this->winCursPos.x = p.x;
+		this->winCursPos.y = p.y;
+		ShowCursor(FALSE);
+
+		return true;
+	}
+
+	return false;
+}
+
+

Code/Misc/Utilities/Thread/OysterThread_Impl.cpp

@@ -194,7 +194,10 @@ using namespace Utility::DynamicMemory;
 				std::this_thread::sleep_for(std::chrono::milliseconds(w->msec));
 	
 			while (w->state == OYSTER_THREAD_STATE_IDLE)
+			{
+				CheckPriority(w);
 				std::this_thread::yield();
+			}
 		}
 		static void ThreadingFunction(ThreadData* w)
 		{

Code/Misc/WindowManager/WindowShell.cpp

@@ -78,7 +78,6 @@ bool WindowShell::CreateWin(WINDOW_INIT_DESC &desc)
 	if(desc.windowSize.x <= 0)		desc.windowSize.x = 50;
 	if(desc.windowSize.y <= 0)		desc.windowSize.y = 50;
 	
-	
 	__windowShellData.parent			= desc.parent;
 	__windowShellData.hIns				= desc.hInstance;
 	__windowShellData.windowClassName	= WINDOW_SHELL_CLASS_NAME;
@@ -111,19 +110,13 @@ bool WindowShell::CreateWin(WINDOW_INIT_DESC &desc)
 
 
 	RECT rectW;
-	int width;
-	int height;
 	DWORD style = desc.windowStyle;
 	bool windowed = false;
 
-	width = desc.windowSize.x + GetSystemMetrics(SM_CXFIXEDFRAME)*2;
+	rectW.left = 0;
-	height = desc.windowSize.y + GetSystemMetrics(SM_CYFIXEDFRAME)*2 + GetSystemMetrics(SM_CYCAPTION);
+	rectW.top = 0;
-
+	rectW.right = desc.windowSize.x;
-	rectW.left=(GetSystemMetrics(SM_CXSCREEN)-width)/2;
+	rectW.bottom = desc.windowSize.y;
-	rectW.top=(GetSystemMetrics(SM_CYSCREEN)-height)/2;
-	rectW.right=rectW.left+width;
-	rectW.bottom=rectW.top+height;
-	
 
 	if(__windowShellData.parent)
 	{
@@ -135,6 +128,8 @@ bool WindowShell::CreateWin(WINDOW_INIT_DESC &desc)
 		windowed		= true;
 	}
 
+	AdjustWindowRect(& rectW, style, FALSE);
+
 	if(windowed)
 	{
 		__windowShellData.hWnd = CreateWindowExW(
@@ -161,8 +156,8 @@ bool WindowShell::CreateWin(WINDOW_INIT_DESC &desc)
 									style, 
 									desc.windowPosition.x, 
 									desc.windowPosition.y, 
-									desc.windowSize.x, 
+									rectW.right - rectW.left, 
-									desc.windowSize.y, 
+									rectW.bottom - rectW.top, 
 									0, 
 									0, 
 									__windowShellData.hIns, 
@@ -173,7 +168,6 @@ bool WindowShell::CreateWin(WINDOW_INIT_DESC &desc)
 	if( !__windowShellData.hWnd )
 	{
 		printf("Failed to create window handle : Code ( %ul )", GetLastError());
-		//MessageBox(0, L"Failed to create window", L"Error!", 0);
 		return false;
 	}
 
@@ -258,3 +252,4 @@ bool WindowShell::Frame()
 
 	return true;
 }
+

Code/Misc/WindowManager/WindowShell.h

@@ -40,7 +40,7 @@ public:
 							POINT				_windowSize = cPOINT(800, 600),
 							POINT				_windowPosition = cPOINT(0,0),
 							UINT				_windowClassStyle = (CS_HREDRAW | CS_VREDRAW | CS_OWNDC),
-							UINT				_windowStyle = (WS_POPUPWINDOW|WS_SYSMENU|WS_CAPTION),
+							UINT				_windowStyle = (WS_POPUPWINDOW|WS_CAPTION),
 							HICON				_icon = LoadIcon(0, IDI_APPLICATION),
 							HCURSOR				_cursor = LoadCursor(NULL, IDC_ARROW),
 							HBRUSH				_background = (HBRUSH)GetStockObject(BLACK_BRUSH)

Code/Network/NetworkAPI/NetworkClient.cpp

@@ -13,6 +13,7 @@
 #include "CustomNetProtocol.h"
 #include "NetworkSession.h"
 
+#include "../NetworkDependencies/ConnectionUDP.h"
 #include "../NetworkDependencies/Connection.h"
 #include "../NetworkDependencies/PostBox.h"
 #include "../NetworkDependencies/WinsockFunctions.h"
@@ -25,6 +26,8 @@
 #include <queue>
 #include <WinSock2.h>
 
+#include <thread>
+
 //For conversion from wstring to string
 #include <codecvt>
 
@@ -60,6 +63,15 @@ struct NetworkClient::PrivateData : public IThreadObject
 	HANDLE socketEvents[2];
 	HANDLE shutdownEvent;
 
+	//Broadcasting
+	bool broadcastingStarted;
+	HANDLE broadcastEvent;
+	HANDLE broadcastShutdownEvent;
+	std::thread broadcastThread; 
+	ConnectionUDP broadcastConnection;
+	OysterByte broadcastTempMessage;
+	Translator broadcastTranslator;
+
 	//The OysterByte each message is packed in.
 	OysterByte tempMessage;
 
@@ -77,6 +89,7 @@ struct NetworkClient::PrivateData : public IThreadObject
 		,	owner(0)
 		,	outputEvent(0)
 	{
+		broadcastingStarted = false;
 		numPackages = 0;
 		bufferedSend.Resize(MAX_NETWORK_MESSAGE_SIZE);
 		tempMessage.Resize(MAX_NETWORK_MESSAGE_SIZE);
@@ -120,6 +133,26 @@ struct NetworkClient::PrivateData : public IThreadObject
 		CloseHandle(shutdownEvent);
 	}
 
+	//Thread for receiving broadcast messages
+	void BroadcastThread()
+	{
+		WSANETWORKEVENTS wsaEvents;
+
+		while(WaitForSingleObject(broadcastShutdownEvent, 0) != WAIT_OBJECT_0)
+		{
+			int result = WSAWaitForMultipleEvents(1, &broadcastEvent, FALSE, 100, FALSE) - WSA_WAIT_EVENT_0;
+			if(result == 0)
+			{
+				WSAEnumNetworkEvents(this->broadcastConnection.GetSocket(), broadcastEvent, &wsaEvents);
+				if((wsaEvents.lNetworkEvents & FD_READ) && (wsaEvents.iErrorCode[FD_READ_BIT] == 0))
+				{
+					//Recieve a message
+					RecvUDP();
+				}
+			}
+		}
+	}
+
 	bool DoWork() override
 	{
 		WSANETWORKEVENTS wsaEvents;
@@ -128,7 +161,7 @@ struct NetworkClient::PrivateData : public IThreadObject
 		{
 			if(!this->connection.IsConnected())	return false;
 
-			int result = WSAWaitForMultipleEvents(2, socketEvents, FALSE, 100, FALSE) - WSA_WAIT_EVENT_0;
+			int result = WSAWaitForMultipleEvents(3, socketEvents, FALSE, 100, FALSE) - WSA_WAIT_EVENT_0;
 			if(result == 0)
 			{
 				WSAEnumNetworkEvents(this->connection.GetSocket(), socketEvents[0], &wsaEvents);
@@ -161,6 +194,47 @@ struct NetworkClient::PrivateData : public IThreadObject
 		return false;
 	}
 
+	void RecvUDP()
+	{
+		int errorCode = -1;
+
+		errorCode = this->broadcastConnection.Recieve(broadcastTempMessage);
+		
+		if(errorCode == 0 && broadcastTempMessage.GetSize())
+		{
+			CustomNetProtocol protocol;
+			bool ok = this->broadcastTranslator.Unpack(protocol, broadcastTempMessage);
+
+			//Check if the protocol was unpacked correctly
+			if(ok)
+			{
+				CEA parg;
+				parg.type = CEA::EventType_ProtocolRecieved;
+				parg.data.protocol = protocol;
+				NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e;
+				e.sender = this->parent;
+				e.args.data.protocol = parg.data.protocol;
+				e.args.type = parg.type;
+			
+				this->recieveQueue.Push(e);
+
+				if(this->outputEvent)
+				{
+					printf("\t(ID: %i | IP: %s | Protocol: %i) Message recieved!\n", this->ID, this->connection.GetIpAddress().c_str(), protocol[0].value.netShort);	
+				}
+			}
+			else
+			{
+				if(this->outputEvent)
+				{
+					printf("\t(ID: %i | IP: %s) Failed to unpack CustomNetProtocol!\n", this->ID, this->connection.GetIpAddress().c_str());	
+				}
+			}
+
+			broadcastTempMessage.Clear();
+		}
+	}
+
 	void SendBuffer()
 	{
 		if(bufferedSend.GetSize() > 0)
@@ -599,3 +673,85 @@ void NetworkClient::OutputEventData(bool output)
 {
 	this->privateData->outputEvent;
 }
+
+bool NetworkClient::StartListeningForBroadcasting(unsigned short port)
+{
+	//Create privateData if it doesn't exists.
+	if(this->privateData == NULL)
+	{
+		privateData = new PrivateData;
+	}
+
+	//Initiate broadcasting only if it's not started.
+	if(!this->privateData->broadcastingStarted)
+	{
+		//Create UDP connection
+		int result = this->privateData->broadcastConnection.InitiateBroadcastClient(port);
+		if(result)
+		{
+			return false;
+		}
+
+		//Create event for closing the thread.
+		this->privateData->broadcastShutdownEvent = CreateEvent(NULL, true, false, NULL);
+		if(this->privateData->broadcastShutdownEvent == NULL)
+		{
+			this->privateData->broadcastConnection.Disconnect();
+			return false;
+		}
+
+		//Creating event for broadcast messages on the UDP connection.
+		this->privateData->broadcastEvent = WSACreateEvent();
+		if(this->privateData->broadcastEvent == WSA_INVALID_EVENT)
+		{
+			this->privateData->broadcastConnection.Disconnect();
+			CloseHandle(this->privateData->broadcastShutdownEvent);
+			return false;
+		}
+
+		//Set the event for only Receiving.
+		if(WSAEventSelect(this->privateData->broadcastConnection.GetSocket(), this->privateData->broadcastEvent, FD_READ) == SOCKET_ERROR)
+		{
+			this->privateData->broadcastConnection.Disconnect();
+			CloseHandle(this->privateData->broadcastShutdownEvent);
+			WSACloseEvent(this->privateData->broadcastEvent);
+			return false;
+		}
+
+		//Start thread receiving broadcast messages.
+		this->privateData->broadcastThread = thread(&PrivateData::BroadcastThread, this->privateData);
+		if(!this->privateData->broadcastThread.joinable())
+		{
+			this->privateData->broadcastConnection.Disconnect();
+			CloseHandle(this->privateData->broadcastShutdownEvent);
+			WSACloseEvent(this->privateData->broadcastEvent);
+			return false;
+		}
+
+		this->privateData->broadcastingStarted = true;
+	}
+
+	return true;
+}
+
+void NetworkClient::StopListeningForBroadcasting()
+{
+	if(this->privateData)
+	{
+		if(this->privateData->broadcastingStarted)
+		{
+			//Tell the thread to shutdown
+			WSASetEvent(this->privateData->broadcastShutdownEvent);
+
+			//Wait for thread
+			this->privateData->broadcastThread.join();
+
+			WSACloseEvent(this->privateData->broadcastEvent);
+			CloseHandle(this->privateData->broadcastShutdownEvent);
+
+			this->privateData->broadcastConnection.Disconnect();
+
+			this->privateData->broadcastingStarted = false;
+		}
+	}
+}

Code/Network/NetworkAPI/NetworkClient.h

@@ -153,6 +153,19 @@ namespace Oyster
 				*/
 				void SetOutputEventDataStream(FILE out);
 
+
+				/** Starts a seperate thread for listening to broadcast messages.
+				* @param port: The port to listen for messages on.
+				* @return Returns true if broadcasting is already started or if it started now.
+						Returns false if it failed to start broadcasting.
+				*/
+				bool StartListeningForBroadcasting(unsigned short port);
+
+				/** Stops the seperate thread for broadcast messages.
+				*
+				*/
+				void StopListeningForBroadcasting();
+
 			private:
 				NetworkClient(const NetworkClient& obj);
 				NetworkClient& operator =(const NetworkClient& obj);

Code/Network/NetworkAPI/NetworkServer.cpp

@@ -10,6 +10,8 @@
 
 #include "NetworkServer.h"
 
+#include "Translator.h"
+#include "../NetworkDependencies/ConnectionUDP.h"
 #include "../NetworkDependencies/Listener.h"
 #include "../NetworkDependencies/PostBox.h"
 #include "../NetworkDependencies/WinsockFunctions.h"
@@ -18,6 +20,7 @@
 #include "Thread/OysterThread.h"
 #include "WinTimer.h"
 
+#include <mutex>
 
 using namespace Oyster::Network;
 using namespace Utility::DynamicMemory;
@@ -81,7 +84,15 @@ public:
 		,	port(-1)
 		,	broadcast(0)
 		,	broadcastTime(1.0f, 0.0f)
-	{  }
+		,	broadcastMutex(new std::mutex)
+	{
+		InitWinSock();
+		serverOptions.broadcastOptions.broadcastInterval = 1.0f;
+		serverOptions.broadcastOptions.broadcast = true;
+		broadcastMessage.Resize(MAX_NETWORK_MESSAGE_SIZE);
+
+		broadcastConnection.InitiateBroadcastServer(15151, "255.255.255.255");
+	}
 	~PrivateData()
 	{
 		if(listener)
@@ -106,6 +117,12 @@ public:
 	int port;
 	bool broadcast;
 
+	ServerOptions serverOptions;
+
+	SmartPointer<std::mutex> broadcastMutex;
+	ConnectionUDP broadcastConnection;
+	OysterByte broadcastMessage;
+
 	TimeInstance broadcastTime;
 
 	Utility::WinTimer serverTimer;
@@ -113,11 +130,18 @@ public:
 
 bool NetworkServer::PrivateData::DoWork()
 {
-	if(broadcast)	
+	if(serverOptions.broadcastOptions.broadcast)	
 	{
-		if( (this->serverTimer.getElapsedSeconds() - this->broadcastTime.previous) >= this->broadcastTime.length )
+		if( (this->serverTimer.getElapsedSeconds() - this->broadcastTime.previous) >= this->serverOptions.broadcastOptions.broadcastInterval )
 		{
-			Broadcast();
+			//broadcastMessage.Clear();
+			//Translator t;
+			//t.Pack(broadcastMessage, serverOptions.broadcastOptions.broadcastMessage);
+			serverTimer.reset();
+			
+			broadcastMutex->lock();
+			broadcastConnection.Send(broadcastMessage);
+			broadcastMutex->unlock();
 		}
 	}
 
@@ -197,6 +221,8 @@ NetworkServer::ServerReturnCode NetworkServer::Init(ServerOptions& options)
 		return NetworkServer::ServerReturnCode_Error;
 	}
 
+	this->privateData->serverOptions.broadcastOptions = options.broadcastOptions;
+
 	this->privateData->isInitiated = true;
 	this->privateData->isReleased = false;
 	return NetworkServer::ServerReturnCode_Sucess;
@@ -319,6 +345,47 @@ int NetworkServer::GetPort()
 	return this->privateData->port;
 }
 
+/***************************************
+		Broadcast functions
+***************************************/
+//Set broadcast settings.
+void NetworkServer::SetBroadcast(CustomNetProtocol& broadcastMessage, float interval, bool enable)
+{
+	this->privateData->broadcastMutex->lock();
+	this->privateData->serverOptions.broadcastOptions.broadcast = enable;
+	this->privateData->serverOptions.broadcastOptions.broadcastMessage = broadcastMessage;
+	this->privateData->serverOptions.broadcastOptions.broadcastInterval = interval;
 
+	this->privateData->broadcastMessage.Clear();
+	Translator t;
+	t.Pack(this->privateData->broadcastMessage, broadcastMessage);
+	this->privateData->broadcastMutex->unlock();
+}
 
+//Set broadcast settings.
+void NetworkServer::SetBroadcastMessage(CustomNetProtocol& broadcastMessage)
+{
+	this->privateData->broadcastMutex->lock();
+	this->privateData->serverOptions.broadcastOptions.broadcastMessage = broadcastMessage;
 
+	this->privateData->broadcastMessage.Clear();
+	Translator t;
+	t.Pack(this->privateData->broadcastMessage, broadcastMessage);
+	this->privateData->broadcastMutex->unlock();
+}
+
+//Enable/disable broadcast.
+void NetworkServer::SetBroadcast(bool enable)
+{
+	this->privateData->broadcastMutex->lock();
+	this->privateData->serverOptions.broadcastOptions.broadcast = enable;
+	this->privateData->broadcastMutex->unlock();
+}
+
+//Set interval between each broadcast message in seconds.
+void NetworkServer::SetBroadcastInterval(float interval)
+{
+	this->privateData->broadcastMutex->lock();
+	this->privateData->serverOptions.broadcastOptions.broadcastInterval = interval;
+	this->privateData->broadcastMutex->unlock();
+}

Code/Network/NetworkDependencies/ConnectionUDP.cpp

@@ -41,8 +41,24 @@ int ConnectionUDP::Connect(unsigned short port, const char serverName[])
 	}
 
 	
+	//this->Address = htonl(0xffffffff);
 	this->Address = *(unsigned long*)hostEnt->h_addr;
 	this->port = htons(this->port);
+
+	if(this->Address == 0)
+	{
+		sockaddr_in addr;
+		addr.sin_addr.s_addr = INADDR_ANY;
+		addr.sin_family = AF_INET;
+		addr.sin_port = this->port;
+
+		int result = bind(socket, (const sockaddr*)&addr, sizeof(addr));
+		if(result)
+		{
+			int a = 0;
+		}
+	}
+
 	return 0;
 }
 
@@ -89,19 +105,46 @@ int ConnectionUDP::InitiateClient()
 	return InitiateSocket();
 }
 
-int ConnectionUDP::InitiateBroadcast(unsigned short port)
+int ConnectionUDP::InitiateBroadcastServer(unsigned short port, const char serverName[])
 {
 	int result = InitiateSocket();
 
-
 	int flag = 1;
-	result = setsockopt(this->socket,			/* socket affected */
+	result = setsockopt(this->socket, SOL_SOCKET, SO_BROADCAST, (char *) &flag, sizeof(flag));	
-							SOL_SOCKET,			/* set option at TCP level */
-							SO_BROADCAST,		/* name of option */
-							(char *) &flag,		/* the cast is historical cruft */
-							sizeof(flag));		/* length of option value */
 	if (result < 0)
 		return -1;
+	
+	closed = false;
+	stillSending = true;
+
+	struct hostent *hostEnt;
+	if((hostEnt = gethostbyname(serverName)) == NULL)
+	{
+		return SOCKET_ERROR;
+	}
+
+	this->Address = *(unsigned long*)hostEnt->h_addr;
+	this->port = htons(port);
+
+	return 0;
+}
+
+int ConnectionUDP::InitiateBroadcastClient(unsigned short port)
+{
+	int result = InitiateSocket();
+
+	struct sockaddr_in recvAddr;
+	recvAddr.sin_family = AF_INET;
+	recvAddr.sin_addr.s_addr = INADDR_ANY;
+	recvAddr.sin_port = htons(port);
+
+	if(bind(this->socket, (sockaddr*)&recvAddr, sizeof(recvAddr)) == SOCKET_ERROR)
+	{
+		closesocket(this->socket);
+		return SOCKET_ERROR;
+	}
+
+	return result;
 }
 
 int ConnectionUDP::Send(OysterByte &bytes)
@@ -201,6 +244,12 @@ int ConnectionUDP::SetBlockingMode( bool blocking )
 	//Success
 	return 0;
 }
+
+int ConnectionUDP::GetSocket()
+{
+	return socket;
+}
+
 //////////////////////////////////////
 // Private Methods
 //////////////////////////////////////

Code/Network/NetworkDependencies/ConnectionUDP.h

@@ -22,18 +22,23 @@ namespace Oyster
 			virtual int InitiateServer( unsigned short port );
 			virtual int InitiateClient();
 
-			virtual int InitiateBroadcast(unsigned short port);
+			virtual int InitiateBroadcastServer(unsigned short port, const char serverName[]);
+			virtual int InitiateBroadcastClient(unsigned short port);
 
 			virtual int Send ( OysterByte &byte );
 			virtual int Recieve( OysterByte &byte );
 
 			virtual int Connect( unsigned short port, const char serverName[] );
 
+			//Doesn't do anything now.
+			virtual int Reconnect() { return 0; }
+
 			virtual int Disconnect();
 
 			bool IsSending();
 			bool IsConnected();
 			int GetIpSize();
+			int GetSocket();
 
 			int SetBlockingMode( bool blocking );