GameServer - Painly merge with GameLogic

Code/DanBias.sln

@@ -45,6 +45,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GameClient", "Game\GameClie
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Utilities", "Misc\Utilities\Utilities.vcxproj", "{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LevelLoader", "Game\LevelLoader\LevelLoader.vcxproj", "{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -679,6 +681,40 @@ Global
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|x86.ActiveCfg = Release|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|x86.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|Win32.Build.0 = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|x64.ActiveCfg = Debug|x64
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|x64.Build.0 = Debug|x64
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|x86.ActiveCfg = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Debug|x86.Build.0 = Debug|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|Any CPU.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|x64.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|x86.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.MinSizeRel|x86.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|Any CPU.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|Win32.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|Win32.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|x64.ActiveCfg = Release|x64
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|x64.Build.0 = Release|x64
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|x86.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.Release|x86.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|Any CPU.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|x64.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|x86.ActiveCfg = Release|Win32
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}.RelWithDebInfo|x86.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -692,6 +728,7 @@ Global
 		{C83A6FAD-E71F-4B1E-9D63-E93E61DDC012} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 		{2A1BC987-AF42-4500-802D-89CD32FC1309} = {20720CA7-795C-45AD-A302-9383A6DD503A}
+		{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 		{C4C76A8D-44C5-4452-9F61-39C7E01CBDB4} = {F156EEBC-0195-4020-8700-4433208DE12B}
 		{3EA5F14D-2A71-4588-A69D-87C4571C580F} = {F156EEBC-0195-4020-8700-4433208DE12B}
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B} = {1322B12B-5E37-448A-AAAF-F637460DCB23}

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;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(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;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(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;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(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;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\OysterMath;$(SolutionDir)Misc\Input;$(SolutionDir)OysterGraphics;$(SolutionDir)Misc\Utilities;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -196,6 +196,9 @@
     <ProjectReference Include="..\GameServer\GameServer.vcxproj">
       <Project>{143bd516-20a1-4890-a3e4-f8bfd02220e7}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\LevelLoader\LevelLoader.vcxproj">
+      <Project>{6391e709-d9fa-4fef-a3b9-4343db5a0c63}</Project>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="DanBiasGame_Impl.cpp" />
@@ -204,6 +207,7 @@
     <ClCompile Include="GameClientState\Camera_BasicV2.cpp" />
     <ClCompile Include="GameClientState\Camera_FPS.cpp" />
     <ClCompile Include="GameClientState\Camera_FPSV2.cpp" />
+    <ClCompile Include="GameClientState\C_Light.cpp" />
     <ClCompile Include="GameClientState\C_obj\C_DynamicObj.cpp" />
     <ClCompile Include="GameClientState\C_obj\C_Player.cpp" />
     <ClCompile Include="GameClientState\C_obj\C_StaticObj.cpp" />
@@ -211,16 +215,15 @@
     <ClCompile Include="DLLMain.cpp" />
     <ClCompile Include="GameClientState\GameClientState.cpp" />
     <ClCompile Include="GameClientState\GameState.cpp" />
+    <ClCompile Include="GameClientState\GameStateUI.cpp" />
+    <ClCompile Include="GameClientState\GamingUI.cpp" />
     <ClCompile Include="GameClientState\LanMenuState.cpp" />
-    <ClCompile Include="GameClientState\LevelLoader\LevelLoader.cpp" />
-    <ClCompile Include="GameClientState\LevelLoader\LevelParser.cpp" />
-    <ClCompile Include="GameClientState\LevelLoader\Loader.cpp" />
-    <ClCompile Include="GameClientState\LevelLoader\ParseFunctions.cpp" />
     <ClCompile Include="GameClientState\LobbyAdminState.cpp" />
     <ClCompile Include="GameClientState\LobbyState.cpp" />
     <ClCompile Include="GameClientState\C_Object.cpp" />
     <ClCompile Include="GameClientState\MainState.cpp" />
     <ClCompile Include="GameClientState\NetLoadState.cpp" />
+    <ClCompile Include="GameClientState\RespawnUI.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="GameClientState\Camera_Basic.h" />
@@ -231,21 +234,20 @@
     <ClInclude Include="GameClientState\Camera_BasicV2.h" />
     <ClInclude Include="GameClientState\Camera_FPS.h" />
     <ClInclude Include="GameClientState\Camera_FPSV2.h" />
+    <ClInclude Include="GameClientState\C_Light.h" />
     <ClInclude Include="GameClientState\C_obj\C_DynamicObj.h" />
     <ClInclude Include="GameClientState\C_obj\C_Player.h" />
     <ClInclude Include="GameClientState\C_obj\C_StaticObj.h" />
     <ClInclude Include="GameClientState\C_obj\C_UIobject.h" />
     <ClInclude Include="GameClientState\GameClientState.h" />
     <ClInclude Include="GameClientState\GameState.h" />
+    <ClInclude Include="GameClientState\GameStateUI.h" />
+    <ClInclude Include="GameClientState\GamingUI.h" />
     <ClInclude Include="GameClientState\LanMenuState.h" />
-    <ClInclude Include="GameClientState\LevelLoader\LevelLoader.h" />
-    <ClInclude Include="GameClientState\LevelLoader\LevelParser.h" />
-    <ClInclude Include="GameClientState\LevelLoader\Loader.h" />
-    <ClInclude Include="GameClientState\LevelLoader\ObjectDefines.h" />
-    <ClInclude Include="GameClientState\LevelLoader\ParseFunctions.h" />
     <ClInclude Include="GameClientState\LobbyAdminState.h" />
     <ClInclude Include="GameClientState\MainState.h" />
     <ClInclude Include="GameClientState\NetLoadState.h" />
+    <ClInclude Include="GameClientState\RespawnUI.h" />
     <ClInclude Include="GameClientState\SharedStateContent.h" />
     <ClInclude Include="Include\GameClient.h" />
     <ClInclude Include="GameClientState\LobbyState.h" />

Code/Game/GameClient/GameClientRecieverFunc.h

@@ -1,192 +0,0 @@
-#ifndef DANBIAS_CLIENTRECIEVEROBJECT_H
-#define DANBIAS_CLIENTRECIEVEROBJECT_H
-
-//WTF!? No headers included???
-#include "../DanBiasGame/Include/DanBiasGame.h"
-#include "../GameProtocols/GeneralProtocols.h"
-#include "../GameProtocols/Protocols.h"
-#include "../Network/NetworkAPI/NetworkClient.h"
-#include "GameClientState\GameClientState.h"
-#include "GameClientState\GameState.h"
-
-#include <Utilities.h>
-
-namespace DanBias
-{
-	struct GameRecieverObject : public Oyster::Network::NetworkClient
-	{
-		Client::GameClientState* gameClientState;
-
-		// receiver function for server messages 
-		// parsing protocols and sending it to the gameState
-		//void NetworkCallback(Oyster::Network::CustomNetProtocol& p) override
-		void GameRecieverObject::DataRecieved( Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e ) override
-		{
-			Oyster::Network::CustomNetProtocol p = e.args.data.protocol;
-			int pType = p[0].value.netInt;
-
-			//printf("Message(%i) arrived at client(%i)\n", pType, this->GetID());
-
-
-			switch (pType)
-			{
-			case protocol_General_Status:
-				{
-					GameLogic::Protocol_General_Status::States state;
-					state =  (GameLogic::Protocol_General_Status::States)p[1].value.netShort;
-					if( state == GameLogic::Protocol_General_Status::States_disconected)
-					{
-						// server disconnected 
-						DanBiasGame::Release();
-					}
-				}
-				break;
-			case protocol_Gameplay_ObjectCreate:
-				{
-					Client::GameClientState::NewObj protocolData;// = new Client::GameClientState::NewObj;
-					protocolData.object_ID = p[1].value.netInt;
-					protocolData.path = p[2].value.netCharPtr;
-					for(int i = 0; i< 16; i++)
-					{
-						protocolData.worldPos[i] = p[i+3].value.netFloat;
-					}
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(&protocolData);
-
-					//delete p[2].value.netCharPtr; //delete char array
-					//delete protocolData;
-					//protocolData = NULL;
-				}
-				break;
-			case protocol_Gameplay_ObjectDisabled:
-				{
-					Client::GameClientState::RemoveObj* protocolData = new Client::GameClientState::RemoveObj;
-					protocolData->object_ID = p[1].value.netInt;
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(protocolData);
-
-					delete protocolData;
-					protocolData = NULL;
-				}
-				break;
-			case protocol_Gameplay_ObjectPosition:
-				{
-					// 0: reserved
-					// 1: objectID
-					// 2,3,4: position
-					// 5,6,7,8: rotation quaternion
-
-					GameLogic::Protocol_ObjectPosition data(p);
-
-					Client::GameClientState::ObjPos protocolData;
-					protocolData.object_ID = data.object_ID;
-					//protocolData.object_ID = p[1].value.netInt;
-
-					for( int i = 0; i < 3; ++i )
-					{
-						protocolData.position[i] = data.position[i];
-					}
-
-					//for(int i = 0; i< 16; i++)
-					//{
-					//	protocolData.worldPos[i] = p[i+2].value.netFloat;
-					//}
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(&protocolData);
-				}
-				break;
-			case protocol_Gameplay_ObjectPositionRotation:
-				{
-
-					Client::GameClientState::ObjPos protocolData;
-					protocolData.object_ID = p[1].value.netInt;
-					for(int i = 0; i< 16; i++)
-					{
-						protocolData.worldPos[i] = p[i+2].value.netFloat;
-					}
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(&protocolData);
-				}
-				break;
-			case protocol_Lobby_Create:
-				{
-					if(dynamic_cast<Client::LobbyState*>(gameClientState))
-					{
-						int id = p.Get(1).value.netInt;
-						std::string name = p.Get(19).value.netCharPtr;
-						Oyster::Math::Float4x4 w;
-						for(int i = 0; i< 16; i++)
-						{
-							w[i] = p[i+2].value.netFloat;
-						}
-
-						gameClientState->Release();
-						delete gameClientState;
-
-						gameClientState = new Client::GameState();
-						gameClientState->Init(this);
-						std::wstring temp;
-						Utility::String::StringToWstring(name, temp);
-						((Client::GameState*)gameClientState)->InitiatePlayer(id, temp, w);
-
-						//Do some wait state?
-					}
-				}
-				break;
-			case protocol_Lobby_Start:
-				{
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-					{
-						//Game state should start in n seconds
-						GameLogic::Protocol_LobbyStartGame p(p);
-						p.seconds;
-
-						//Sleep((int)(p.seconds * 1000));
-					}
-				}
-				break;
-
-			default:
-				break;
-			}	
-
-			if(ProtocolIsLobby(p[0].value.netInt))	ParseLobbyProtocol(p);
-		}
-
-		void ParseLobbyProtocol(Oyster::Network::CustomNetProtocol& p)
-		{
-			switch (p[0].value.netShort)
-			{
-				case protocol_General_Status:	//this->GeneralStatus		(Protocol_General_Status	(p), c);
-				break;
-				case protocol_General_Text:		//this->GeneralText		(Protocol_General_Text		(p), c);
-				break;
-				//case protocol_Lobby_Create:		this->LobbyCreateGame	(Protocol_LobbyCreateGame	(p), c);
-				//break;
-				case protocol_Lobby_Start:		//this->LobbyStartGame	(Protocol_LobbyStartGame	(p), c);
-				break;
-				//case protocol_Lobby_Join:		this->LobbyJoin			(Protocol_LobbyJoin			(p), c);
-				//break;
-				case protocol_Lobby_Login:		//this->LobbyLogin		(Protocol_LobbyLogin		(p), c);
-				break;
-				case protocol_Lobby_Refresh:	//this->LobbyRefresh		(Protocol_LobbyRefresh		(p), c);
-				break;
-				case protocol_Lobby_GameData:	//this->LobbyGameData		(Protocol_LobbyGameData		(p), c);
-				{
-					//GameLogic::Protocol_LobbyGameData temp(p);
-					//printf("%s, %i.%i\n", temp.mapName.c_str(), temp.majorVersion, temp.minorVersion);
-				}
-				break;
-				case protocol_Lobby_ClientData:	//this->LobbyMainData		(Protocol_LobbyClientData	(p), c);
-				break;
-				//case protocol_Lobby_GameData:	this->LobbyGameData		(Protocol_LobbyGameData		(p), c);
-				//break;
-			}
-		}
-	};
-} 
-#endif

Code/Game/GameClient/GameClientState/C_Light.cpp

@@ -0,0 +1,37 @@
+#include "C_Light.h"
+using namespace DanBias::Client;
+C_Light::C_Light( Oyster::Graphics::Definitions::Pointlight pointLightDesc, int id )
+{
+	this->pointLightDesc = pointLightDesc;
+	this->id = id;
+}
+C_Light::~C_Light()
+{
+
+}
+Oyster::Graphics::Definitions::Pointlight C_Light::getLightDesc() const
+{
+	return this->pointLightDesc;
+}
+void C_Light::setLightDesc( Oyster::Graphics::Definitions::Pointlight pointLightDesc )
+{
+	this->pointLightDesc = pointLightDesc;
+}
+Oyster::Math::Float3 C_Light::getPos() const
+{
+	return this->pointLightDesc.Pos;
+}
+void C_Light::setPos( Oyster::Math::Float3 newPos)
+{
+	this->pointLightDesc.Pos = newPos;
+}	
+
+int C_Light::GetId() const
+{
+	return this->id;
+}
+void C_Light::Render()
+{
+	// will be changed to new API 
+	Oyster::Graphics::API::AddLight(pointLightDesc);
+}

Code/Game/GameClient/GameClientState/C_Light.h

@@ -0,0 +1,29 @@
+#ifndef DANBIAS_CLIENT_CLIGHT_H
+#define DANBIAS_CLIENT_CLIGHT_H
+#include "DllInterfaces/GFXAPI.h"
+namespace DanBias
+{
+	namespace Client
+	{
+		class C_Light
+		{
+		private:	
+			Oyster::Graphics::Definitions::Pointlight pointLightDesc;
+			int id;
+
+		public:
+			C_Light( Oyster::Graphics::Definitions::Pointlight pointLightDesc, int id );
+			virtual ~C_Light();
+			
+			Oyster::Graphics::Definitions::Pointlight getLightDesc() const;
+			void setLightDesc( Oyster::Graphics::Definitions::Pointlight pointLightDesc );
+
+			Oyster::Math::Float3 getPos() const;
+			void setPos( Oyster::Math::Float3 newPos);
+			void Render();
+			int GetId() const;
+		};
+	}
+}
+
+#endif

Code/Game/GameClient/GameClientState/C_Object.cpp

@@ -9,6 +9,10 @@ C_Object::C_Object()
 
 	id = 0;
 	model = NULL;
+
+	// RB DEBUG 
+	type = RB_Type_None;
+	// !RB DEBUG 
 }
 C_Object::~C_Object()
 {
@@ -31,32 +35,27 @@ void C_Object::updateWorld()
 {
 	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(this->position); 
 	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(this->rotation);
-	//Oyster::Math3D::Float4x4 scale = Oyster::Math3D::;
+	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(this->scale);
-	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::Matrix::identity;
-	scale.v[0].x = this->scale[0];
-	scale.v[1].y = this->scale[1];
-	scale.v[2].z = this->scale[2];
 	world = translation * rot * scale;
 
 	model->WorldMatrix = world;
 }
-void C_Object::setWorld(Oyster::Math::Float4x4 world)
-{
-	model->WorldMatrix = world;
-}
 Oyster::Math::Float4x4 C_Object::getWorld() const
 {
+	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(this->position); 
+	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(this->rotation);
+	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(this->scale);
+	Oyster::Math3D::Float4x4 world = translation * rot * scale;
+
 	return world;
 }
 void C_Object::setPos(Oyster::Math::Float3 newPos)
 {
 	this->position = newPos;
-	updateWorld();
 }
 void C_Object::addPos(Oyster::Math::Float3 deltaPos)
 {
 	this->position += deltaPos;
-	updateWorld();
 }
 Oyster::Math::Float3 C_Object::getPos() const
 {
@@ -65,12 +64,6 @@ Oyster::Math::Float3 C_Object::getPos() const
 void C_Object::setRot(Oyster::Math::Quaternion newRot)
 {
 	this->rotation = newRot;
-	updateWorld();
-}
-void C_Object::addRot(Oyster::Math::Quaternion deltaRot)
-{
-	this->rotation += deltaRot;
-	updateWorld();
 }
 Oyster::Math::Quaternion C_Object::getRotation() const
 {
@@ -79,12 +72,10 @@ Oyster::Math::Quaternion C_Object::getRotation() const
 void C_Object::setScale(Oyster::Math::Float3 newScale)
 {
 	this->scale = newScale;
-	updateWorld();
 }
 void C_Object::addScale(Oyster::Math::Float3 deltaScale)
 {
 	this->scale += deltaScale;
-	updateWorld();
 }
 Oyster::Math::Float3 C_Object::getScale() const
 {
@@ -106,3 +97,55 @@ void C_Object::Release()
 		this->model = nullptr;
 	}
 }
+
+
+
+////////////////////////////////////////////////
+// RB DEBUG
+////////////////////////////////////////////////
+bool C_Object::InitRB(RBInitData RBInit)
+{
+	RBposition = RBInit.position;
+	RBrotation = RBInit.rotation;
+	RBscale = RBInit.scale;
+	type = RBInit.type;
+	return true;
+}
+Oyster::Math::Float4x4 C_Object::getRBWorld() const
+{
+	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(this->RBposition); 
+	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(this->RBrotation);
+	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(this->RBscale);
+	Oyster::Math3D::Float4x4 world = translation * rot * scale;
+
+	return world;
+}
+void C_Object::setRBPos(Oyster::Math::Float3 newPos)
+{
+	this->RBposition = newPos;
+}
+Oyster::Math::Float3 C_Object::getRBPos() const
+{
+	return this->RBposition;
+}
+void C_Object::setRBRot(Oyster::Math::Quaternion newRot)
+{
+	this->RBrotation = newRot;
+}
+Oyster::Math::Quaternion C_Object::getRBRotation() const
+{
+	return this->RBrotation;
+}
+void C_Object::setRBScale(Oyster::Math::Float3 newScale)
+{
+	this->RBscale = newScale;
+}
+Oyster::Math::Float3 C_Object::getRBScale() const
+{
+	return this->RBscale;
+}
+RB_Type C_Object::getBRtype()const
+{
+	return this->type;
+}
+// !RB DEBUG 

Code/Game/GameClient/GameClientState/C_Object.h

@@ -5,6 +5,21 @@ namespace DanBias
 {
 	namespace Client
 	{
+		// RB DEBUG 
+		enum RB_Type
+		{
+			RB_Type_Cube,
+			RB_Type_Sphere, 
+			RB_Type_None,
+		};
+		struct  RBInitData
+		{
+			Oyster::Math::Float3 position; 
+			Oyster::Math::Quaternion rotation; 
+			Oyster::Math::Float3 scale; 
+			RB_Type type;
+		};
+		// !RB DEBUG 
 
 		struct  ModelInitData
 		{
@@ -24,27 +39,45 @@ namespace DanBias
 			Oyster::Math::Quaternion rotation; 
 			Oyster::Math::Float3 scale; 
 
+			// RB DEBUG
+			Oyster::Math::Float3 RBposition; 
+			Oyster::Math::Quaternion RBrotation; 
+			Oyster::Math::Float3 RBscale; 
+			RB_Type type;
+			// !RB DEBUG 
+
 			int id;
-			void updateWorld();
+		
 		protected:
 			Oyster::Graphics::Model::Model *model;
 		public:
 			C_Object();
 			virtual ~C_Object();
 			virtual bool Init(ModelInitData modelInit);
-	
+			void updateWorld();
-			void setWorld(Oyster::Math::Float4x4 world);
+			//void setWorld(Oyster::Math::Float4x4 world);
 			Oyster::Math::Float4x4 getWorld() const;
 			void setPos(Oyster::Math::Float3 newPos);
 			Oyster::Math::Float3  getPos() const;
 			void addPos(Oyster::Math::Float3 deltaPos);
 			void setRot(Oyster::Math::Quaternion newRot);
 			Oyster::Math::Quaternion  getRotation() const;
-			void addRot(Oyster::Math::Quaternion deltaRot);
 			void setScale(Oyster::Math::Float3 newScale);
 			void addScale(Oyster::Math::Float3 deltaScale);
 			Oyster::Math::Float3  getScale() const;
 
+			// RB DEBUG
+			bool InitRB(RBInitData modelInit);
+			Oyster::Math::Float4x4 getRBWorld() const;
+			void setRBPos(Oyster::Math::Float3 newPos);
+			Oyster::Math::Float3  getRBPos() const;
+			void setRBRot(Oyster::Math::Quaternion newRot);
+			Oyster::Math::Quaternion  getRBRotation() const;
+			void setRBScale(Oyster::Math::Float3 newScale);
+			Oyster::Math::Float3  getRBScale() const;
+			RB_Type getBRtype()const;
+			// !RB DEBUG 
+
 			virtual void Render();
 			virtual void Release();
 			virtual int GetId() const;

Code/Game/GameClient/GameClientState/Camera_FPSV2.cpp

@@ -10,6 +10,7 @@ Camera_FPSV2::Camera_FPSV2()
 	this->headOffset =
 	this->body.translation = Float3::null;
 	this->body.rotation = Quaternion::identity;
+	this->pitchHaveChanged = false;
 }
 
 Camera_FPSV2::~Camera_FPSV2() {}
@@ -21,6 +22,7 @@ Camera_FPSV2 & Camera_FPSV2::operator = ( const Camera_FPSV2 &camera )
 	this->headOffset = camera.headOffset;
 	this->body.translation = camera.body.translation;
 	this->body.rotation = camera.body.rotation;
+	this->pitchHaveChanged = camera.pitchHaveChanged;
 	return *this;
 }
 
@@ -38,8 +40,14 @@ void Camera_FPSV2::SetPosition( const Float3 &translation )
 
 void Camera_FPSV2::SetRotation( const Quaternion &rotation )
 {
+	if( !Within(rotation.GetNorm(), .99f, 1.01f) )
+	{ // HACK: bug trap
+		const char *breakPoint = "Caught an invalid rotation!";
+	}
+
 	this->body.rotation = rotation;
-	this->head.SetRotation( rotation * Rotation(this->pitchUp, this->GetNormalOf(Float3::standard_unit_x) ) );
+	this->head.SetRotation( rotation * Rotation(this->pitchUp, WorldAxisOf(rotation, Float3::standard_unit_x) ) );
+	this->pitchHaveChanged = false;
 }
 
 void Camera_FPSV2::SetAngular( const Float3 &axis )
@@ -64,6 +72,12 @@ void Camera_FPSV2::SetPerspectiveProjection( Float verticalFoV, Float aspectRati
 
 void Camera_FPSV2::UpdateOrientation()
 {
+	if( this->pitchHaveChanged )
+	{
+		this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, WorldAxisOf(this->body.rotation, Float3::standard_unit_x) ) );
+		this->pitchHaveChanged = false;
+	}
+
 	Float4x4 orientation;
 	OrientationMatrix( this->body.rotation, this->body.translation, orientation );
 
@@ -73,7 +87,8 @@ void Camera_FPSV2::UpdateOrientation()
 void Camera_FPSV2::SnapUpToNormal( const Float3 &normal )
 {
 	this->body.rotation = Rotation( SnapAngularAxis(AngularAxis(this->body.rotation), WorldAxisOf(this->body.rotation, Float3::standard_unit_y), normal) );
-	this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp * Float3::standard_unit_x) );
+	this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, WorldAxisOf(this->body.rotation, Float3::standard_unit_x) ) );
+	this->pitchHaveChanged = false;
 }
 
 void Camera_FPSV2::Move( const Float3 &deltaPosition )
@@ -84,8 +99,8 @@ void Camera_FPSV2::Move( const Float3 &deltaPosition )
 
 void Camera_FPSV2::Rotate( const Quaternion &deltaRotation )
 {
-	this->head.Rotate( deltaRotation );
 	this->body.rotation *= deltaRotation;
+	this->pitchHaveChanged = true;
 }
 
 void Camera_FPSV2::Rotate( const Float3 &deltaAngularAxis )
@@ -116,7 +131,7 @@ void Camera_FPSV2::StrafeLeft( Float distance )
 void Camera_FPSV2::PitchUp( Float radian )
 {
 	this->pitchUp = Clamp( this->pitchUp + radian, -0.48f * pi, 0.48f * pi );
-	this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, Float3::standard_unit_x) );
+	this->pitchHaveChanged = true;
 }
 
 void Camera_FPSV2::PitchDown( Float radian )
@@ -147,6 +162,12 @@ const Float3 & Camera_FPSV2::GetPosition() const
 
 Float4x4 & Camera_FPSV2::GetViewMatrix( Float4x4 &targetMem ) const
 {
+	if( this->pitchHaveChanged )
+	{
+		this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, WorldAxisOf(this->body.rotation, Float3::standard_unit_x) ) );
+		this->pitchHaveChanged = false;
+	}
+
 	return this->head.GetViewMatrix( targetMem );
 }
 
@@ -157,11 +178,23 @@ const Float4x4 & Camera_FPSV2::GetProjectionMatrix() const
 
 Float4x4 & Camera_FPSV2::GetViewsProjMatrix( Float4x4 &targetMem ) const
 {
+	if( this->pitchHaveChanged )
+	{
+		this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, WorldAxisOf(this->body.rotation, Float3::standard_unit_x) ) );
+		this->pitchHaveChanged = false;
+	}
+
 	return this->head.GetViewsProjMatrix( targetMem );
 }
 
 Float3 Camera_FPSV2::GetNormalOf( const Float3 &axis ) const
 {
+	if( this->pitchHaveChanged )
+	{
+		this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, WorldAxisOf(this->body.rotation, Float3::standard_unit_x) ) );
+		this->pitchHaveChanged = false;
+	}
+
 	return this->head.GetNormalOf( axis );
 }
 
@@ -177,6 +210,12 @@ Float3 Camera_FPSV2::GetUp() const
 
 Float3 Camera_FPSV2::GetLook() const
 {
+	if( this->pitchHaveChanged )
+	{
+		this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, WorldAxisOf(this->body.rotation, Float3::standard_unit_x) ) );
+		this->pitchHaveChanged = false;
+	}
+
 	return this->head.GetNormalOf( -Float3::standard_unit_z );
 }
 

Code/Game/GameClient/GameClientState/Camera_FPSV2.h

@@ -50,7 +50,7 @@ public:
 		  ::Oyster::Math::Float3	   GetForward() const;
 
 private:
-	Camera_BasicV2 head;
+	mutable Camera_BasicV2 head;
 	::Oyster::Math::Float pitchUp;
 	::Oyster::Math::Float3 headOffset;
 	struct
@@ -58,6 +58,7 @@ private:
 		::Oyster::Math::Float3 translation;
 		::Oyster::Math::Quaternion rotation;
 	} body;
+	mutable bool pitchHaveChanged;
 };
 
 #endif

Code/Game/GameClient/GameClientState/GameClientState.h

@@ -35,7 +35,7 @@ namespace DanBias { namespace Client
 
 		/******************************************************************
 		 * @param message of the event
-		 * @return message or GameClientState::event_processed.
+		 * @return message or a reference to GameClientState::event_processed.
 		 ******************************************************************/
 		virtual const NetEvent & DataRecieved( const NetEvent &message );
 	};

Code/Game/GameClient/GameClientState/GameState.cpp

@@ -4,7 +4,7 @@
 #include "NetworkClient.h"
 #include "Camera_FPSV2.h"
 #include <GameServerAPI.h>
-
+#include "C_Light.h"
 #include "C_obj/C_Player.h"
 #include "C_obj/C_DynamicObj.h"
 #include "C_obj/C_StaticObj.h"
@@ -28,6 +28,7 @@ struct  GameState::MyData
 
 	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_StaticObj>> *staticObjects;
 	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_DynamicObj>> *dynamicObjects;
+	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_Light>> *lights;
 
 	bool key_forward;
 	bool key_backward;
@@ -36,7 +37,11 @@ struct  GameState::MyData
 	bool key_Shoot;
 	bool key_Jump;
 
+	// DEGUG KEYS
 	bool key_Reload_Shaders;
+	bool key_Wireframe_Toggle; 
+	bool renderWhireframe; 
+	// !DEGUG KEYS
 
 	C_Player player;
 	Camera_FPSV2 camera;
@@ -78,15 +83,28 @@ bool GameState::Init( SharedStateContent &shared )
 	this->privData->input = shared.input;
 	this->privData->staticObjects = &shared.staticObjects;
 	this->privData->dynamicObjects = &shared.dynamicObjects;
+	this->privData->lights = &shared.lights;
 
 	Graphics::API::Option gfxOp = Graphics::API::GetOption();
 	Float aspectRatio = gfxOp.Resolution.x / gfxOp.Resolution.y;
-	this->privData->camera.SetPerspectiveProjection( Radian(90.0f), aspectRatio, 0.1f, 1000.0f );
+	this->privData->camera.SetPerspectiveProjection( Utility::Value::Radian(90.0f), aspectRatio, 0.1f, 1000.0f );
 	Graphics::API::SetProjection( this->privData->camera.GetProjectionMatrix() );
 
 	//tell server ready
 	this->privData->nwClient->Send( Protocol_General_Status(Protocol_General_Status::States_ready) );
 			
+	// DEGUG KEYS
+	this->privData->key_Reload_Shaders = false;
+	this->privData->key_Wireframe_Toggle = false;
+	this->privData->renderWhireframe = false;
+	// !DEGUG KEYS
+
+	auto light = this->privData->lights->begin();
+	for( ; light != this->privData->lights->end(); ++light )
+	{
+		light->second->Render();
+	}
+
 	return true;
 }
 
@@ -100,10 +118,20 @@ void GameState::InitiatePlayer( int id, const std::string &modelName, const floa
 	StringToWstring( modelName, modelData.modelPath );
 	modelData.id		= id;
 
+	// RB DEBUG
+	RBInitData RBData;
+	RBData.position = position;
+	RBData.rotation = ArrayToQuaternion( rotation );
+	RBData.scale =  scale;
+	// !RB DEBUG 
 	if( isMyPlayer )
 	{
 		if( this->privData->player.Init(modelData) )
 		{
+			// RB DEBUG
+			this->privData->player.InitRB( RBData );
+			// !RB DEBUG 
+
 			this->privData->myId = id;
 			this->privData->camera.SetPosition( this->privData->player.getPos() );
 			Float3 offset = Float3( 0.0f );
@@ -117,6 +145,10 @@ void GameState::InitiatePlayer( int id, const std::string &modelName, const floa
 		C_DynamicObj *p = new C_DynamicObj();
 		if( p->Init(modelData) )
 		{
+			// RB DEBUG
+			this->privData->player.InitRB( RBData );
+			// !RB DEBUG 
+
 			(*this->privData->dynamicObjects)[id] = p;
 		}
 	}
@@ -150,6 +182,55 @@ bool GameState::Render()
 			dynamicObject->second->Render();
 	}
 
+
+	/*auto light = this->privData->lights->begin();
+	for( ; light != this->privData->lights->end(); ++light )
+	{
+	light->second->Render();
+	}*/
+
+	// RB DEBUG render wire frame 
+	//if(this->privData->renderWhireframe)
+	//{
+	//	Oyster::Graphics::API::StartRenderWireFrame();
+	//
+	//	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(Float3( 0,132, 20)); 
+	//	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(Float3( 0.5f, 0.5f, 0.5f));
+	//	Oyster::Math3D::Float4x4 world = translation  * scale;
+	//	Oyster::Graphics::API::RenderDebugCube( world );
+	//	Oyster::Graphics::API::RenderDebugCube(this->privData->player.getRBWorld()); 
+	//
+	//	staticObject = this->privData->staticObjects->begin();
+	//	for( ; staticObject != this->privData->staticObjects->end(); ++staticObject )
+	//	{
+	//		if( staticObject->second->getBRtype() == RB_Type_Cube)
+	//		{
+	//			Oyster::Graphics::API::RenderDebugCube( staticObject->second->getRBWorld());
+	//		}
+	//		if( staticObject->second->getBRtype() == RB_Type_Sphere)
+	//		{
+	//			Oyster::Graphics::API::RenderDebugSphere( staticObject->second->getRBWorld());
+	//		}
+	//	}
+	//
+	//	dynamicObject = this->privData->dynamicObjects->begin();
+	//	for( ; dynamicObject != this->privData->dynamicObjects->end(); ++dynamicObject )
+	//	{
+	//		if( dynamicObject->second )
+	//		{
+	//			if( dynamicObject->second->getBRtype() == RB_Type_Cube)
+	//			{
+	//				Oyster::Graphics::API::RenderDebugCube( dynamicObject->second->getRBWorld());
+	//			}
+	//			if( dynamicObject->second->getBRtype() == RB_Type_Sphere)
+	//			{
+	//				Oyster::Graphics::API::RenderDebugSphere( dynamicObject->second->getRBWorld());
+	//			}
+	//		}
+	//	}
+	//}
+	// !RB DEBUG 
+
 	Oyster::Graphics::API::EndFrame();
 	return true;
 }
@@ -170,8 +251,15 @@ bool GameState::Release()
 			dynamicObject->second = nullptr;
 		}
 
+		auto light = this->privData->lights->begin();
+		for( ; light != this->privData->lights->end(); ++light )
+		{
+			light->second->Render();
+		}
+
 		this->privData->staticObjects->clear();
 		this->privData->dynamicObjects->clear();
+		this->privData->lights->clear();
 
 		privData = NULL;
 	}
@@ -187,7 +275,7 @@ void GameState::ReadKeyInput()
 {
 	if( this->privData->input->IsKeyPressed(DIK_W) )
 	{
-		if(!this->privData->key_forward)
+		//if(!this->privData->key_forward)
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementForward() );
 			this->privData->key_forward = true;
@@ -198,7 +286,7 @@ void GameState::ReadKeyInput()
 
 	if( this->privData->input->IsKeyPressed(DIK_S) )
 	{
-		if( !this->privData->key_backward )
+		//if( !this->privData->key_backward )
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementBackward() );
 			this->privData->key_backward = true;
@@ -209,7 +297,7 @@ void GameState::ReadKeyInput()
 
 	if( this->privData->input->IsKeyPressed(DIK_A) )
 	{
-		if( !this->privData->key_strafeLeft )
+		//if( !this->privData->key_strafeLeft )
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementLeft() );
 			this->privData->key_strafeLeft = true;
@@ -220,7 +308,7 @@ void GameState::ReadKeyInput()
 
 	if( this->privData->input->IsKeyPressed(DIK_D) )
 	{
-		if( !this->privData->key_strafeRight )
+		//if( !this->privData->key_strafeRight )
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementRight() );
 			this->privData->key_strafeRight = true;
@@ -229,28 +317,11 @@ void GameState::ReadKeyInput()
 	else 
 		this->privData->key_strafeRight = false;
 
-	if( this->privData->input->IsKeyPressed(DIK_R) )
-	{
-		if( !this->privData->key_Reload_Shaders )
-		{
-			//this->privData->nwClient->Send( Protocol_PlayerMovementRight() );
-#ifdef _DEBUG
-			Graphics::API::ReloadShaders();
-#endif
-			this->privData->key_Reload_Shaders = true;
-		}
-	} 
-	else 
-		this->privData->key_Reload_Shaders = false;
-
-
 	//send delta mouse movement 
 	{
-		this->privData->camera.YawRight( this->privData->input->GetYaw() * 0.017f );
+		static const float mouseSensitivity = Radian( 1.0f );
-		this->privData->camera.PitchDown( this->privData->input->GetPitch() * 0.017f );
+		this->privData->camera.PitchDown( this->privData->input->GetPitch() * mouseSensitivity );
-		this->privData->camera.UpdateOrientation();
+		this->privData->nwClient->Send( Protocol_PlayerLeftTurn(this->privData->input->GetYaw() * mouseSensitivity) );
-
-		privData->nwClient->Send( Protocol_PlayerLook(this->privData->camera.GetLook(), this->privData->camera.GetRight()) );
 	}
 
 	// shoot
@@ -309,6 +380,35 @@ void GameState::ReadKeyInput()
 	else 
 		this->privData->key_Jump = false;
 
+
+	// DEGUG KEYS
+
+	// Reload shaders
+	if( this->privData->input->IsKeyPressed(DIK_R) )
+	{
+		if( !this->privData->key_Reload_Shaders )
+		{
+#ifdef _DEBUG
+			Graphics::API::ReloadShaders();
+#endif
+			this->privData->key_Reload_Shaders = true;
+		}
+	} 
+	else 
+		this->privData->key_Reload_Shaders = false;
+
+	// toggle wire frame render
+	if( this->privData->input->IsKeyPressed(DIK_T) )
+	{
+		if( !this->privData->key_Wireframe_Toggle )
+		{
+			this->privData->renderWhireframe = !this->privData->renderWhireframe;
+			this->privData->key_Wireframe_Toggle = true;
+		}
+	} 
+	else 
+		this->privData->key_Wireframe_Toggle = false;
+	// !DEGUG KEYS
 	// TODO: implement sub-menu
 }
 
@@ -342,12 +442,18 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 					this->privData->camera.SetPosition( decoded.position );
 
 				(*this->privData->dynamicObjects)[decoded.object_ID]->setPos( decoded.position );
+				// RB DEBUG 
+				(*this->privData->dynamicObjects)[decoded.object_ID]->setRBPos ( decoded.position );  
+				// !RB DEBUG 
 			}
 			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectScale:
 			{
 				Protocol_ObjectScale decoded(data);
 				(*this->privData->dynamicObjects)[decoded.object_ID]->setScale( decoded.scale );
+				// RB DEBUG 
+				(*this->privData->dynamicObjects)[decoded.object_ID]->setRBScale ( decoded.scale );  
+				// !RB DEBUG 
 			}
 			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectRotation:
@@ -360,6 +466,9 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 					this->privData->camera.SetRotation( rotation );
 
 				(*this->privData->dynamicObjects)[decoded.object_ID]->setRot( rotation );
+				// RB DEBUG 
+				(*this->privData->dynamicObjects)[decoded.object_ID]->setRBRot ( rotation );  
+				// !RB DEBUG 
 			}
 			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectPositionRotation:
@@ -373,13 +482,20 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 				{
 					this->privData->camera.SetPosition( position );
 					this->privData->camera.SetRotation( rotation );
+					this->privData->player.setPos( position );
+					this->privData->player.setRot( rotation );
 				}
 
 				C_DynamicObj *object = (*this->privData->dynamicObjects)[decoded.object_ID];
+
 				if( object )
 				{
 					object->setPos( position );
 					object->setRot( rotation );
+					// RB DEBUG 
+					object->setRBPos ( position );  
+					object->setRBRot ( rotation );  
+					// !RB DEBUG 
 				}
 			}
 			return GameClientState::event_processed;
@@ -404,7 +520,7 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 				ModelInitData modelData;
 				{
 					modelData.position = Float3( decoded.position );
-					modelData.rotation = Quaternion( Float3(decoded.rotationQ), decoded.rotationQ[3] );
+					modelData.rotation = Quaternion( Float3(decoded.position), decoded.rotationQ[3] );
 					modelData.scale = Float3( decoded.scale );
 					modelData.visible = true;
 					modelData.id = decoded.object_ID;
@@ -412,6 +528,15 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 					::Utility::String::StringToWstring( decoded.name, modelData.modelPath );
 				}
 				object->Init(modelData);
+				// RB DEBUG
+				// Is just using the model position since the rigid body data should never be sent to the client 
+				RBInitData RBData;
+				RBData.position = decoded.position;
+				RBData.rotation = ArrayToQuaternion( decoded.position );
+				RBData.scale =  Float3( decoded.scale );
+
+				this->privData->player.InitRB( RBData );
+				// !RB DEBUG 
 
 				(*this->privData->dynamicObjects)[decoded.object_ID] = object;
 

Code/Game/GameClient/GameClientState/GameStateUI.cpp

@@ -0,0 +1,17 @@
+#include "GameStateUI.h"
+
+using namespace ::DanBias::Client;
+using namespace ::Oyster::Network;
+
+GameStateUI::GameStateUI()
+{
+	this->nextState = GameStateUI::UIState_same;
+}
+
+GameStateUI::~GameStateUI() { /* Do nothing */ }
+
+const GameStateUI::NetEvent & GameStateUI::DataRecieved( const GameStateUI::NetEvent &message )
+{
+	/* Do nothing */
+	return message;
+}

Code/Game/GameClient/GameClientState/GameStateUI.h

@@ -0,0 +1,58 @@
+#ifndef DANBIAS_CLIENT_GAMECLIENTSTATE_H
+#define DANBIAS_CLIENT_GAMECLIENTSTATE_H
+
+#include "Utilities.h"
+#include "NetworkClient.h"
+
+namespace DanBias { namespace Client
+{
+	class GameStateUI
+	{
+	public:
+		enum UIState
+		{
+			UIState_same,
+			UIState_gaming,
+
+
+			UIState_main_menu,
+			UIState_shut_down
+		};
+
+		typedef ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> NetEvent;
+		static const NetEvent event_processed;
+
+		GameStateUI();
+		virtual ~GameStateUI();
+		virtual UIState Update( float deltaTime ) = 0;
+		virtual bool HaveGUIRender() const = 0;
+		virtual bool HaveTextRender() const = 0;
+		virtual void RenderGUI() const = 0;
+		virtual void RenderText() const = 0;
+		virtual bool Release() = 0;
+
+		/******************************************************************
+		 * @param message of the event
+		 * @return message or a reference to GameStateUI::event_processed.
+		 ******************************************************************/
+		virtual const NetEvent & DataRecieved( const NetEvent &message );
+
+	protected:
+		UIState nextState;
+	};
+} }
+
+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

@@ -0,0 +1,153 @@
+#include "GamingUI.h"
+#include <Protocols.h>
+#include "Utilities.h"
+
+using namespace ::DanBias::Client;
+using namespace ::Oyster::Network;
+using namespace ::GameLogic;
+using namespace ::Utility::Value;
+
+GamingUI::GamingUI() :
+	GameStateUI()
+{
+	/* Should never be called! */
+	this->input = nullptr;
+	this->netClient = nullptr;
+	this->camera = nullptr;
+}
+
+GamingUI::GamingUI( InputClass *input, NetworkClient *connection, Camera_FPSV2 *camera ) :
+	GameStateUI()
+{
+	this->input = input;
+	this->netClient = connection;
+	this->camera = camera;
+}
+
+GamingUI::~GamingUI() { /* Do nothing */ }
+
+GameStateUI::UIState GamingUI::Update( float deltaTime )
+{
+	return this->nextState;
+}
+
+bool GamingUI::HaveGUIRender() const
+{
+	return false; // TODO: change to true when we want UI elements like a crosshair
+}
+
+bool GamingUI::HaveTextRender() const
+{
+	return false; // TODO: change to true when we want UI elements like a chat window
+}
+
+void GamingUI::RenderGUI() const
+{
+	// TODO: Render crosshairs and such here. Don't forget to adjust GamingUI::HaveGUIRender
+}
+
+void GamingUI::RenderText() const
+{
+	// TODO: Render chattext and such here. Don't forget to adjust GamingUI::HaveGUIRender
+}
+
+bool GamingUI::Release()
+{
+	// TODO: Release UI components here.
+	return true;
+}
+
+void GamingUI::ReadKeyInput()
+{
+	if( this->input->IsKeyPressed(DIK_W) )
+	{
+		this->netClient->Send( Protocol_PlayerMovementForward() );
+	}
+
+	if( this->input->IsKeyPressed(DIK_S) )
+	{
+		this->netClient->Send( Protocol_PlayerMovementBackward() );
+	}
+
+	if( this->input->IsKeyPressed(DIK_A) )
+	{
+		this->netClient->Send( Protocol_PlayerMovementLeft() );
+	}
+
+	if( this->input->IsKeyPressed(DIK_D) )
+	{
+		this->netClient->Send( Protocol_PlayerMovementRight() );
+	}
+
+//	if( this->input->IsKeyPressed(DIK_R) )
+//	{
+//		if( !this->key_Reload_Shaders )
+//		{
+//#ifdef _DEBUG
+//			Graphics::API::ReloadShaders();
+//#endif
+//			this->key_Reload_Shaders = true;
+//		}
+//	} 
+//	else 
+//		this->key_Reload_Shaders = false;
+
+	//send delta mouse movement 
+	{
+		static const float mouseSensitivity = Radian( 1.0f );
+		this->camera->PitchDown( this->input->GetPitch() * mouseSensitivity );
+		this->netClient->Send( Protocol_PlayerLeftTurn(this->input->GetYaw() * mouseSensitivity) );
+	}
+
+	// shoot
+	//if( this->input->IsKeyPressed(DIK_Z) )
+	//{
+	//	if( !this->key_Shoot )
+	//	{
+	//		Protocol_PlayerShot playerShot;
+	//		playerShot.primaryPressed = true;
+	//		playerShot.secondaryPressed = false;
+	//		playerShot.utilityPressed = false;
+	//		this->netClient->Send( playerShot );
+	//		this->key_Shoot = true;
+	//	}
+	//} 
+	//else 
+	//	this->key_Shoot = false;
+
+	//if( this->input->IsKeyPressed(DIK_X) )
+	//{
+	//	if( !this->key_Shoot )
+	//	{
+	//		Protocol_PlayerShot playerShot;
+	//		playerShot.primaryPressed = false;
+	//		playerShot.secondaryPressed = true;
+	//		playerShot.utilityPressed = false;
+	//		this->netClient->Send( playerShot );
+	//		this->key_Shoot = true;
+	//	}
+	//} 
+	//else 
+	//	this->key_Shoot = false;
+
+	//if( this->input->IsKeyPressed(DIK_C) )
+	//{
+	//	if( !this->key_Shoot )
+	//	{
+	//		Protocol_PlayerShot playerShot;
+	//		playerShot.primaryPressed = false;
+	//		playerShot.secondaryPressed = false;
+	//		playerShot.utilityPressed = true;
+	//		this->netClient->Send( playerShot );
+	//		this->key_Shoot = true;
+	//	}
+	//} 
+	//else 
+	//	this->key_Shoot = false;
+
+	// jump
+	if( this->input->IsKeyPressed(DIK_SPACE) )
+	{
+		this->netClient->Send( Protocol_PlayerJump() );
+	}
+}

Code/Game/GameClient/GameClientState/GamingUI.h

@@ -0,0 +1,33 @@
+#ifndef DANBIAS_CLIENT_GAMING_UI_H
+#define DANBIAS_CLIENT_GAMING_UI_H
+
+#include "GameStateUI.h"
+#include "L_inputClass.h"
+#include "Camera_FPSV2.h"
+
+namespace DanBias { namespace Client
+{
+	class GamingUI : public GameStateUI
+	{
+	public:
+		GamingUI( InputClass *input, ::Oyster::Network::NetworkClient *connection, Camera_FPSV2 *camera );
+		virtual ~GamingUI();
+
+		UIState Update( float deltaTime );
+		bool HaveGUIRender() const;
+		bool HaveTextRender() const;
+		void RenderGUI() const;
+		void RenderText() const;
+		bool Release();
+
+	private:
+		InputClass *input;
+		::Oyster::Network::NetworkClient *netClient;
+		Camera_FPSV2 *camera;
+
+		GamingUI();
+		void ReadKeyInput();
+	};
+} }
+
+#endif

Code/Game/GameClient/GameClientState/LevelLoader/LevelParser.cpp

@@ -1,317 +0,0 @@
-/////////////////////////////////////
-// Created by Pontus Fransson 2013 //
-/////////////////////////////////////
-
-#include "LevelParser.h"
-
-#include "Loader.h"
-#include "ParseFunctions.h"
-
-using namespace GameLogic;
-using namespace ::LevelFileLoader;
-using namespace Utility::DynamicMemory;
-
-LevelParser::LevelParser()
-{
-	formatVersion.formatVersionMajor = 3;
-	formatVersion.formatVersionMinor = 0;
-}
-
-LevelParser::~LevelParser()
-{
-}
-
-std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filename)
-{
-	int bufferSize = 0;
-	int counter = 0;
-	bool loadCgf;
-
-	std::vector<SmartPointer<ObjectTypeHeader>> objects;
-
-	//Read entire level file.
-	Loader loader;
-	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
-
-	//Read format version
-	LevelLoaderInternal::FormatVersion levelFormatVersion;
-	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
-	counter += sizeof(levelFormatVersion);
-	if(this->formatVersion != levelFormatVersion)
-	{
-		//Returns an empty vector, because it will most likely fail to read the level format.
-		return objects;
-	}
-
-  	while(counter < bufferSize)
-	{
-		loadCgf = true;
-		//Get typeID
-		ObjectType typeID;
-		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
-		switch((int)typeID)
-		{
-			case ObjectType_LevelMetaData:
-			{
-				SmartPointer<ObjectTypeHeader> header = new LevelMetaData;
-				ParseLevelMetaData(&buffer[counter], *(LevelMetaData*)header.Get(), counter);
-				objects.push_back(header);
-				break;
-			}
-
-			case ObjectType_SpawnPoint:
-			{
-				loadCgf = false;
-				ObjectHeader* header = new ObjectHeader;
-				ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-				SpawnPointAttributes* spawn = new SpawnPointAttributes;
-
-				spawn->typeID = header->typeID;
-
-				for(int i = 0; i < 3; i++)
-				{
-					spawn->position[i] = header->position[i];
-				}
-
-				delete header;
-				//objects.push_back(header);
-				objects.push_back(spawn);
-				break;
-			}
-
-			//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them. 
-			//Unless they are changed to not be the same.
-			case ObjectType_Static: case ObjectType_Dynamic:
-			{
-				//Get specialType.
-				ObjectSpecialType specialType;
-				ParseObject(&buffer[counter+4], &specialType, sizeof(typeID));
-
-				switch(specialType)
-				{
-					//there is no difference when parsing these specialTypes.
-					case ObjectSpecialType_CrystalShard:
-					case ObjectSpecialType_CrystalFormation:
-					case ObjectSpecialType_Spike:
-					case ObjectSpecialType_SpikeBox:
-					case ObjectSpecialType_RedExplosiveBox:
-					case ObjectSpecialType_StandarsBox:
-					case ObjectSpecialType_Stone:
-					case ObjectSpecialType_Building:
-					{
-						ObjectHeader* header = new ObjectHeader;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-						objects.push_back(header);
-
-						break;
-					}
-
-					case ObjectSpecialType_JumpPad:
-					{
-						JumpPadAttributes* header = new JumpPadAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						//Read the spec
-						ParseObject(&buffer[counter], header->direction, 16);
-						counter += 16;
-						objects.push_back(header);
-
-						break;
-					}
-		
-					case ObjectSpecialType_Portal:
-					{
-						PortalAttributes* header = new PortalAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], header->destination, 12);
-						counter += 12;
-						objects.push_back(header);
-
-						break;
-					}
-					
-					case ObjectSpecialType_World:
-					{
-						WorldAttributes* header = new WorldAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], &header->worldSize, 8);
-						counter += 8;
-						objects.push_back(header);
-						break;
-					}
-
-					case ObjectSpecialType_Sky:
-					{
-						loadCgf = false; 
-						SkyAttributes* header = new SkyAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], &header->skySize, 4);
-						counter += 4;
-						objects.push_back(header);
-						break;
-					}
-					//this is a hotfix, fix so you only load the relevant data when the file is updated
-					
-
-					default:
-						//Couldn't find specialType
-						break;
-				}
-				break;
-			}
-			
-			case ObjectType_Light:
-			{
-				LightType lightType;
-
-				//Get Light type
-				ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
-
-				//We only support PointLight for now.
-				BasicLight* header = new BasicLight;
-				ParseObject(&buffer[counter], header, sizeof(*header));
-				counter += sizeof(*header);
-				objects.push_back(header);
-				/*switch(lightType)
-				{
-				case LightType_PointLight:
-				{
-					PointLight* header = new PointLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				case LightType_DirectionalLight:
-				{
-					DirectionalLight* header = new DirectionalLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				case LightType_SpotLight:
-				{
-					SpotLight* header = new SpotLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				default:
-					//Undefined LightType.
-					break;
-				}
-				break;*/
-			}
-			default:
-				//Couldn't find typeID. FAIL!!!!!!
-				break;
-		}
-	}
-
-	return objects;
-}
-
-//för meta information om leveln.
-LevelMetaData LevelParser::ParseHeader(std::string filename)
-{
-	int bufferSize = 0;
-	int counter = 0;
-
-	LevelMetaData levelHeader;
-	levelHeader.typeID = ObjectType::ObjectType_Unknown;
-
-	//Read entire level file.
-	Loader loader;
-	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
-
-	//Read format version
-	LevelLoaderInternal::FormatVersion levelFormatVersion;
-	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(formatVersion));
-	counter += sizeof(levelFormatVersion);
-	if(this->formatVersion != levelFormatVersion)
-	{
-		//Do something if it's not the same version
-
-		//Returns an empty levelHeader with ObjectType_Unknown.
-		//Because it will not be able to read another version of the level format.
-		return levelHeader;
-	}
-
-	//Find the header in the returned string.
-	while(counter < bufferSize)
-	{
-		ObjectType typeID;
-		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
-
-		switch(typeID)
-		{
-		case ObjectType_LevelMetaData:
-			ParseLevelMetaData(&buffer[counter], levelHeader, counter);
-			return levelHeader;
-			break;
-		
-			//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them.
-		case ObjectType_Static: case ObjectType_Dynamic:
-		{
-			ObjectHeader header;
-			ParseObject(&buffer[counter], &header, counter);
-
-			switch(header.specialTypeID)
-			{
-			case ObjectSpecialType_JumpPad:
-				counter += sizeof(16);
-				break;
-			case ObjectSpecialType_Portal:
-				counter += sizeof(12);
-				break;
-			default:
-				break;
-			}	
-			break;
-		}
-
-		case ObjectType_Light:
-		{
-			LightType lightType;
-			ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
-
-			//We only support pointlight for now.
-			counter += sizeof(BasicLight);
-			/*
-			switch(lightType)
-			{
-			case LightType_PointLight:
-			{
-				counter += sizeof(PointLight);
-				break;
-			}
-			case LightType_DirectionalLight:
-			{
-				counter += sizeof(DirectionalLight);
-				break;
-			}
-			case LightType_SpotLight:
-			{
-				counter += sizeof(SpotLight);
-				break;
-			}
-			default:
-				//Undefined LightType.
-				break;
-			}*/
-		}
-
-		default:
-			//Couldn't find typeID. FAIL!!!!!!
-			break;
-		}
-	}
-
-	return levelHeader;
-}

Code/Game/GameClient/GameClientState/NetLoadState.cpp

@@ -2,10 +2,11 @@
 #include "NetworkClient.h"
 #include "OysterMath.h"
 #include "Protocols.h"
-#include "LevelLoader\LevelLoader.h"
+#include "LevelLoader.h"
 #include "Utilities.h"
 #include "C_obj\C_StaticObj.h"
 #include "C_obj\C_DynamicObj.h"
+#include "C_Light.h"
 
 using namespace ::DanBias::Client;
 using namespace ::Oyster;
@@ -23,6 +24,7 @@ struct NetLoadState::MyData
 	Graphics::API::Texture background;
 	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_StaticObj>> *staticObjects;
 	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_DynamicObj>> *dynamicObjects;
+	::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_Light>> *lights;
 
 	bool loading;
 };
@@ -49,6 +51,7 @@ bool NetLoadState::Init( SharedStateContent &shared )
 	this->privData->background		= Graphics::API::CreateTexture( L"grass_md.png" );
 	this->privData->dynamicObjects	= &shared.dynamicObjects;
 	this->privData->staticObjects	= &shared.staticObjects;
+	this->privData->lights			= &shared.lights;
 
 	this->privData->loading = false;
 
@@ -144,6 +147,28 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 				C_StaticObj *staticObject = new C_StaticObj();
 				if( staticObject->Init( desc ) )
 				{
+
+					// RB DEBUG
+					RBInitData RBData;
+					if(oh->boundingVolume.geoType == CollisionGeometryType_Box)
+					{
+						RBData.position = (Float3)oh->position + (Float3)oh->boundingVolume.box.position;
+						RBData.rotation = ArrayToQuaternion( oh->rotation ); // Only model rotation 
+						RBData.scale =  (Float3)oh->scale * (Float3)oh->boundingVolume.box.size;
+						RBData.type = RB_Type_Cube;
+						staticObject->InitRB( RBData );
+					}
+
+					if(oh->boundingVolume.geoType == CollisionGeometryType_Sphere)
+					{
+						RBData.position = (Float3)oh->position + (Float3)oh->boundingVolume.sphere.position;
+						RBData.rotation = ArrayToQuaternion( oh->rotation ); // Only model rotation 
+						RBData.scale =  (Float3)oh->scale * oh->boundingVolume.sphere.radius;
+						RBData.type = RB_Type_Sphere;
+						staticObject->InitRB( RBData );
+					}
+					// !RB DEBUG 
+
 					(*this->privData->staticObjects)[objectID] = staticObject;	
 				}
 				else
@@ -167,6 +192,27 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 				C_DynamicObj *dynamicObject = new C_DynamicObj();
 				if( dynamicObject->Init( desc ) )
 				{
+					// RB DEBUG
+					RBInitData RBData;
+					if(oh->boundingVolume.geoType == CollisionGeometryType_Box)
+					{
+						RBData.position = (Float3)oh->position + (Float3)oh->boundingVolume.box.position;
+						RBData.rotation = ArrayToQuaternion( oh->rotation ); // Only model rotation 
+						RBData.scale =  (Float3)oh->scale * (Float3)oh->boundingVolume.box.size;
+						RBData.type = RB_Type_Cube;
+						dynamicObject->InitRB( RBData );
+					}
+
+					if(oh->boundingVolume.geoType == CollisionGeometryType_Sphere)
+					{
+						RBData.position = (Float3)oh->position + (Float3)oh->boundingVolume.sphere.position;
+						RBData.rotation = ArrayToQuaternion( oh->rotation ); // Only model rotation 
+						RBData.scale =  (Float3)oh->scale * oh->boundingVolume.sphere.radius;
+						RBData.type = RB_Type_Sphere;
+						dynamicObject->InitRB( RBData );
+					}
+					// !RB DEBUG 
+
 					(*this->privData->dynamicObjects)[objectID] = dynamicObject;
 				}
 				else
@@ -177,7 +223,17 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 			break;
 		case ObjectType::ObjectType_Light:
 			{
-				 /* TODO: implement light into the leveformat */
+				BasicLight *light = (BasicLight*)oth;
+				Graphics::Definitions::Pointlight pointLight; 
+
+				pointLight.Color	= light->color;
+				pointLight.Pos		= light->position;
+				pointLight.Bright	= light->intensity;
+				pointLight.Radius	= light->raduis; 
+
+				C_Light *newLight = new C_Light( pointLight, objectID );
+
+				(*this->privData->lights)[objectID] = newLight;
 			}
 			break;
 		default: break;

Code/Game/GameClient/GameClientState/RespawnUI.cpp

@@ -0,0 +1,58 @@
+#include "RespawnUI.h"
+
+using namespace ::DanBias::Client;
+using namespace ::Oyster::Network;
+using namespace ::Utility::Value;
+
+RespawnUI::RespawnUI() :
+	GameStateUI()
+{
+	/* Should never be called! */
+	this->netClient = nullptr;
+	this->countDown = 0.0f;
+}
+
+RespawnUI::RespawnUI( NetworkClient *connection, float delay ) :
+	GameStateUI()
+{
+	this->netClient = connection;
+	this->countDown = delay;
+}
+
+RespawnUI::~RespawnUI() { /* Do nothing */ }
+
+GameStateUI::UIState RespawnUI::Update( float deltaTime )
+{
+	this->countDown = Max( this->countDown - deltaTime, 0.0f );
+	return this->nextState;
+}
+
+bool RespawnUI::HaveGUIRender() const
+{
+	return false; // TODO: change to true when we want UI elements like a crosshair
+}
+
+bool RespawnUI::HaveTextRender() const
+{
+	return false; // TODO: change to true when we want UI elements like a chat window
+}
+
+void RespawnUI::RenderGUI() const
+{
+	// TODO: We need?
+}
+
+void RespawnUI::RenderText() const
+{
+	// TODO: Text countdown somewhere on screen would be nice
+}
+
+bool RespawnUI::Release()
+{
+	// TODO: Release UI components here.
+	return true;
+}
+
+
+
+

Code/Game/GameClient/GameClientState/RespawnUI.h

@@ -0,0 +1,29 @@
+#ifndef DANBIAS_CLIENT_RESPAWN_UI_H
+#define DANBIAS_CLIENT_RESPAWN_UI_H
+
+#include "GameStateUI.h"
+
+namespace DanBias { namespace Client
+{
+	class RespawnUI : public GameStateUI
+	{
+	public:
+		RespawnUI( ::Oyster::Network::NetworkClient *connection, float delay );
+		virtual ~RespawnUI();
+
+		UIState Update( float deltaTime );
+		bool HaveGUIRender() const;
+		bool HaveTextRender() const;
+		void RenderGUI() const;
+		void RenderText() const;
+		bool Release();
+
+	private:
+		::Oyster::Network::NetworkClient *netClient;
+		float countDown;
+
+		RespawnUI();
+	};
+} }
+
+#endif

Code/Game/GameClient/GameClientState/SharedStateContent.h

@@ -13,6 +13,7 @@
 #include "C_Object.h"
 #include "C_obj\C_StaticObj.h"
 #include "C_obj\C_DynamicObj.h"
+#include "C_Light.h"
 #include "NetworkClient.h"
 #include "L_inputClass.h"
 
@@ -23,6 +24,7 @@ namespace DanBias { namespace Client
 	public:
 		::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_StaticObj>> staticObjects;
 		::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;
 	};

Code/Game/GameLogic/CollisionManager.cpp

@@ -23,7 +23,7 @@ using namespace GameLogic;
 	void Player::PlayerCollision(Oyster::Physics::ICustomBody *rigidBodyPlayer, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
 	{
 		
-		Player *player = ((Game::PlayerData*)(rigidBodyPlayer->GetCustomTag()))->player;
+		Player *player = ((Player*)(rigidBodyPlayer->GetCustomTag()));
 		Object *realObj = (Object*)obj->GetCustomTag(); //needs to be changed?
 
 		switch (realObj->GetObjectType())
@@ -46,7 +46,7 @@ using namespace GameLogic;
 			break;
 
 		case ObjectSpecialType::ObjectSpecialType_CrystalFormation:
-			PlayerVLethalObject(*player,*realObj, kineticEnergyLoss,realObj->getExtraDamageOnCollision());
+			PlayerVLethalObject(*player,*realObj, kineticEnergyLoss,realObj->GetExtraDamageOnCollision());
 			//player->playerState = PLAYER_STATE::PLAYER_STATE_WALKING;
 			break;
 		}
@@ -181,7 +181,7 @@ using namespace GameLogic;
 		}
 	}
 
-	Oyster::Physics::ICustomBody::SubscriptMessage Object::DefaultCollisionAfter(Oyster::Physics::ICustomBody *rigidBodyLevel, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
+	Oyster::Physics::ICustomBody::SubscriptMessage Object::DefaultOnCollision(Oyster::Physics::ICustomBody *rigidBodyObject, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
 	{
 		return Physics::ICustomBody::SubscriptMessage_none;
 	}

Code/Game/GameLogic/Game.cpp

@@ -68,13 +68,33 @@ void Game::GetAllPlayerPositions() const
 Game::PlayerData* Game::CreatePlayer()
 {
 	// Find a free space in array or insert at end
+	int insert = InsertObject(this->players, (PlayerData*)0);
+	int freeID = 0;
+	bool found = false;
 
-	PlayerData *temp = new PlayerData();
+	for(int i = 0; i < 100; i++)
-	temp->player->GetRigidBody()->SetSubscription(Game::PhysicsOnMove);
+	{
+		found = true;
+		freeID = i;
 
-	int i = InsertObject(this->players, temp);
+		for(int j = 0; j < players.Size(); j++)
+		{
 			
-	return temp;
+			if(this->players[j] && this->players[j]->GetID() == freeID)
+			{
+				found = false;
+			}
+
+			if(!found) break;
+		}
+
+		if(found) break;
+	}
+
+	this->players[insert] = new PlayerData(freeID, 0); // user constructor with objectID and teamID
+	this->players[insert]->player->GetRigidBody()->SetSubscription(Game::PhysicsOnMove);
+
+	return this->players[insert];
 }
 
 Game::LevelData* Game::CreateLevel(const wchar_t mapName[255])

Code/Game/GameLogic/Game.h

@@ -31,17 +31,18 @@ namespace GameLogic
 			PlayerData(int playerID,int teamID);
 			~PlayerData();
 
-			void Move(const PLAYER_MOVEMENT &movement)				override;
+			void Move(const PLAYER_MOVEMENT &movement)													override;
-			void UseWeapon(const WEAPON_FIRE &usage)				override;
+			void UseWeapon(const WEAPON_FIRE &usage)													override;
-			int GetTeamID() const									override;
+			int GetTeamID() const																		override;
-			PLAYER_STATE GetState() const							override;
+			PLAYER_STATE GetState() const																override;
-			Oyster::Math::Float3 GetPosition()						override;
+			Oyster::Math::Float3 GetPosition()															override;
-			Oyster::Math::Quaternion GetRotation()					override;
+			Oyster::Math::Quaternion GetRotation()														override;
-			Oyster::Math::Float3 GetScale()							override;
+			Oyster::Math::Float3 GetScale()																override;
-			Oyster::Math::Float4x4 GetOrientation()					override; 
+			Oyster::Math::Float4x4 GetOrientation()														override; 
-			int GetID() const										override;
+			int GetID() const																			override;
-			void Rotate(const Oyster::Math3D::Float3 lookDir, const Oyster::Math3D::Float3 right)		override;
+			void Rotate(const Oyster::Math3D::Float3& lookDir, const Oyster::Math3D::Float3& right)		override;
-			ObjectSpecialType GetObjectType()	const						override;
+			void TurnLeft(Oyster::Math3D::Float deltaLeftRadians )										override;
+			ObjectSpecialType GetObjectType()	const													override;
 
 
 

Code/Game/GameLogic/GameAPI.h

@@ -12,7 +12,7 @@
 #include "GameLogicDef.h"
 #include "GameLogicStates.h"
 #include <OysterMath.h>
-#include "LevelLoader\ObjectDefines.h"
+#include "..\LevelLoader\ObjectDefines.h"
 #include "DynamicArray.h"
 
 
@@ -85,7 +85,12 @@ namespace GameLogic
 			*	@param x: The relative x axis	
 			*	@param y: The relative y axis	
 			**/
-			virtual void Rotate(const Oyster::Math3D::Float3 lookDir, const Oyster::Math3D::Float3 right) = 0;
+			virtual void Rotate(const Oyster::Math3D::Float3& lookDir, const Oyster::Math3D::Float3& right) = 0;
+
+			/** Relative rotation around given axis
+			*	@param leftRadians: The relative amount of radians to turn
+			**/
+			virtual void TurnLeft(Oyster::Math3D::Float deltaLeftRadians ) = 0;
 
 			/********************************************************
 			* Uses the chosen players weapon based on input

Code/Game/GameLogic/GameLogic.vcxproj

@@ -99,7 +99,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>DANBIAS_GAMELOGIC_DLL_EXPORT;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -113,7 +113,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>DANBIAS_GAMELOGIC_DLL_EXPORT;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -129,7 +129,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>DANBIAS_GAMELOGIC_DLL_EXPORT;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -147,7 +147,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;$(SolutionDir)Misc\OysterMath;$(SolutionDir)Physics\OysterPhysics3D;$(SolutionDir)Physics\GamePhysics;$(SolutionDir)Game\LevelLoader</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>DANBIAS_GAMELOGIC_DLL_EXPORT;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -172,12 +172,7 @@
     <ClInclude Include="IAttatchment.h" />
     <ClInclude Include="JumpPad.h" />
     <ClInclude Include="Level.h" />
-    <ClInclude Include="LevelLoader\LevelLoader.h" />
-    <ClInclude Include="LevelLoader\Loader.h" />
     <ClInclude Include="Object.h" />
-    <ClInclude Include="LevelLoader\ObjectDefines.h" />
-    <ClInclude Include="LevelLoader\LevelParser.h" />
-    <ClInclude Include="LevelLoader\ParseFunctions.h" />
     <ClInclude Include="Player.h" />
     <ClInclude Include="Portal.h" />
     <ClInclude Include="StaticObject.h" />
@@ -198,11 +193,7 @@
     <ClCompile Include="IAttatchment.cpp" />
     <ClCompile Include="JumpPad.cpp" />
     <ClCompile Include="Level.cpp" />
-    <ClCompile Include="LevelLoader\LevelLoader.cpp" />
-    <ClCompile Include="LevelLoader\Loader.cpp" />
-    <ClCompile Include="LevelLoader\LevelParser.cpp" />
     <ClCompile Include="Object.cpp" />
-    <ClCompile Include="LevelLoader\ParseFunctions.cpp" />
     <ClCompile Include="Player.cpp" />
     <ClCompile Include="Portal.cpp" />
     <ClCompile Include="StaticObject.cpp" />
@@ -223,6 +214,9 @@
     <ProjectReference Include="..\..\Physics\OysterPhysics3D\OysterPhysics3D.vcxproj">
       <Project>{3ea5f14d-2a71-4588-a69d-87c4571c580f}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\LevelLoader\LevelLoader.vcxproj">
+      <Project>{6391e709-d9fa-4fef-a3b9-4343db5a0c63}</Project>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Code/Game/GameLogic/GameLogic.vcxproj.user

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ShowAllFiles>false</ShowAllFiles>
+    <ShowAllFiles>true</ShowAllFiles>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory>

Code/Game/GameLogic/Game_PlayerData.cpp

@@ -85,7 +85,11 @@ ObjectSpecialType Game::PlayerData::GetObjectType()	const
 {
 	return this->player->GetObjectType();
 }
-void Game::PlayerData::Rotate(const Oyster::Math3D::Float3 lookDir, const Oyster::Math3D::Float3 right)
+void Game::PlayerData::Rotate(const Oyster::Math3D::Float3& lookDir, const Oyster::Math3D::Float3& right)
 {
 	this->player->Rotate(lookDir, right);
 }
+void Game::PlayerData::TurnLeft(Oyster::Math3D::Float deltaLeftRadians )
+{
+	this->player->TurnLeft(deltaLeftRadians);
+}

Code/Game/GameLogic/Level.cpp

@@ -4,6 +4,10 @@
 #include "JumpPad.h"
 #include "ExplosiveCrate.h"
 #include "Portal.h"
+
+//Conversion from wstring to string
+#include <codecvt>
+
 using namespace GameLogic;
 using namespace Utility::DynamicMemory;
 using namespace Oyster::Physics;
@@ -26,14 +30,14 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 	{
 	case ObjectSpecialType_None: 
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 
 		}
 		break;
 	case ObjectSpecialType_Sky: 
 		{
 			float skySize = ((SkyAttributes*)obj)->skySize; 
-			//gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			//gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	case ObjectSpecialType_World: 
@@ -44,21 +48,21 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 			float worldSize = ((WorldAttributes*)obj)->worldSize; 
 			float atmosphereSize = ((WorldAttributes*)obj)->atmoSphereSize; 
 
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	case ObjectSpecialType_Building: 
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 	case ObjectSpecialType_Stone: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_StandardBox: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_RedExplosiveBox: 
@@ -75,24 +79,24 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 	//	break;
 	case ObjectSpecialType_SpikeBox: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_Spike: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_CrystalFormation: 
 		{
 			int dmg = 50; 
 			//gameObj = new Crystal(rigidBody);
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	case ObjectSpecialType_CrystalShard: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_JumpPad: 
@@ -100,13 +104,13 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 			float power = 500; //((JumpPadAttributes*)obj)->power; 
 			Oyster::Math::Float3 dir = ((JumpPadAttributes*)obj)->direction; 
 			Oyster::Math::Float3 pushForce = dir * power; 
-			gameObj = new JumpPad(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID++ , pushForce);
+			gameObj = new JumpPad(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID , pushForce);
 		}
 		break;
 	case ObjectSpecialType_Portal: 
 		{
 			Oyster::Math::Float3 destination = ((PortalAttributes*)obj)->destination; 
-			gameObj = new Portal(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID++, destination);
+			gameObj = new Portal(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID, destination);
 		}
 		break;
 	//case ObjectSpecialType_SpawnPoint: 
@@ -122,12 +126,12 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 		break;
 	case ObjectSpecialType_Generic:
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	default:
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultOnCollision, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	}
@@ -200,9 +204,16 @@ ICustomBody* Level::InitRigidBodySphere( const ObjectHeader* obj)
 bool Level::InitiateLevel(std::wstring levelPath)
 {
 	LevelLoader ll; 
-	ll.SetFolderPath(L"..\\Content\\Worlds\\");
+	ll.SetFolderPath("..\\Content\\Worlds\\");
 	std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> objects; 
-	objects = ll.LoadLevel(levelPath);
+
+	//Convert from wstring to string
+	typedef std::codecvt_utf8<wchar_t> convert_typeX;
+    std::wstring_convert<convert_typeX, wchar_t> converterX;
+
+	std::string convertedLevelPath = converterX.to_bytes(levelPath);
+	objects = ll.LoadLevel(convertedLevelPath);
+
 
 	if(objects.size() == 0)
 		return false;
@@ -213,6 +224,7 @@ bool Level::InitiateLevel(std::wstring levelPath)
 
 	for (int i = 0; i < objCount; i++)
 	{
+		++this->objID;
 		ObjectTypeHeader* obj = objects.at(i);
 		switch (obj->typeID)
 		{
@@ -229,39 +241,9 @@ bool Level::InitiateLevel(std::wstring levelPath)
 				staticObjData->ModelFile;
 
 				ICustomBody* rigidBody_Static = NULL;	
-				if((ObjectSpecialType)staticObjData->specialTypeID == ObjectSpecialType_Sky)
-				{
 
-				}
-				if((ObjectSpecialType)staticObjData->specialTypeID == ObjectSpecialType_World)
-				{
-				
-					Oyster::Math::Float3 rigidWorldPos;
-					Oyster::Math::Float4 rigidWorldRotation;
-					float rigidBodyMass;
-					float rigidBodyRadius;
-
-					//offset the rigidPosition from modelspace to worldspace;
-					rigidWorldPos = Oyster::Math::Float3(0,0,0);
-					//scales the position so the collision geomentry is in the right place
-
-					//offset the rigidRotation from modelspace to worldspace;
-					
-					rigidWorldRotation = Oyster::Math::Float4(0,0,0,1); 
-
-
-					//mass scaled
-					rigidBodyMass = 100;
-
-					//Radius scaled
-					rigidBodyRadius = 150;
-
-					//create the rigid body
-					rigidBody_Static = API::Instance().AddCollisionSphere( rigidBodyRadius , rigidWorldRotation , rigidWorldPos , rigidBodyMass, 1,1,1);
-
-				}
 				// collision shape
-				else if(staticObjData->boundingVolume.geoType == CollisionGeometryType_Sphere)
+				if(staticObjData->boundingVolume.geoType == CollisionGeometryType_Sphere)
 				{
 					rigidBody_Static = InitRigidBodySphere(staticObjData);
 				}
@@ -360,14 +342,14 @@ bool Level::InitiateLevel(float radius)
 	{
 		rigidBody_TestBox = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(0.0f, 605.0f + i*5.0f, 10.0f), 5.0f, 0.5f, 0.8f, 0.6f);
 
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox, Object::DefaultCollisionAfter, ObjectSpecialType_StandardBox, idCount++));
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox, Object::DefaultOnCollision, ObjectSpecialType_StandardBox, idCount++));
 	}
 	/*offset += nrOfBoxex;
 	for(int i =0; i< nrOfBoxex; i ++)
 	{
 		rigidBody_TestBox = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(0,5, -605 -( i*5)), 5);
 
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultOnCollision, OBJECT_TYPE::OBJECT_TYPE_BOX));
 		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);
 		
 	}
@@ -376,7 +358,7 @@ bool Level::InitiateLevel(float radius)
 	{
 		rigidBody_TestBox = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(200, 620 + ( i*7), 0), 5);
 
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultOnCollision, OBJECT_TYPE::OBJECT_TYPE_BOX));
 		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);	
 	}
 	offset += nrOfBoxex;
@@ -384,18 +366,18 @@ bool Level::InitiateLevel(float radius)
 	{
 		rigidBody_TestBox = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(5, 605 + i*5, 0), 5);
 
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultOnCollision, OBJECT_TYPE::OBJECT_TYPE_BOX));
 		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i]);
 		
 	}*/
 	
 	// add crystal
 	ICustomBody* rigidBody_Crystal = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(10.0f, 605.0f, 0.0f), 5.0f, 0.5f, 0.8f, 0.6f);
-	this->dynamicObjects.Push(new DynamicObject(rigidBody_Crystal, Object::DefaultCollisionAfter, ObjectSpecialType_StandardBox, idCount++));
+	this->dynamicObjects.Push(new DynamicObject(rigidBody_Crystal, Object::DefaultOnCollision, ObjectSpecialType_StandardBox, idCount++));
 
 	// add house
 	ICustomBody* rigidBody_House =API::Instance().AddCollisionBox(Oyster::Math::Float3(20.0f, 20.0f, 20.0f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(-50.0f, 590.0f, 0.0f), 0.0f, 0.5f, 0.8f, 0.6f);
-	this->staticObjects.Push(new StaticObject(rigidBody_House, Object::DefaultCollisionAfter, ObjectSpecialType_Generic, idCount++));
+	this->staticObjects.Push(new StaticObject(rigidBody_House, Object::DefaultOnCollision, ObjectSpecialType_Generic, idCount++));
 
 	// add jumppad
 

Code/Game/GameLogic/Level.h

@@ -14,7 +14,7 @@
 #include "PhysicsAPI.h"
 #include "TeamManager.h"
 #include "DynamicArray.h"
-#include "LevelLoader/LevelLoader.h"
+#include "LevelLoader.h"
 
 namespace GameLogic
 {

Code/Game/GameLogic/LevelLoader/LevelLoader.cpp

@@ -1,52 +0,0 @@
-//////////////////////////////////
-// Created by Sam Svensson 2013 //
-//////////////////////////////////
-
-#include "LevelLoader.h"
-#include "LevelParser.h"
-
-using namespace GameLogic;
-using namespace GameLogic::LevelFileLoader;
-
-struct LevelLoader::PrivData
-{
-	LevelParser parser;
-	std::wstring folderPath;
-};
-
-LevelLoader::LevelLoader()
-	: pData(new PrivData)
-{
-	//standard path
-	pData->folderPath = L"";
-}
-
-LevelLoader::LevelLoader(std::wstring folderPath)
-	: pData(new PrivData)
-{
-	pData->folderPath = folderPath;
-}
-
-LevelLoader::~LevelLoader()
-{
-}
-
-std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LevelLoader::LoadLevel(std::wstring fileName)
-{
-	return pData->parser.Parse(pData->folderPath + fileName);
-}
-
-LevelMetaData LevelLoader::LoadLevelHeader(std::wstring fileName)
-{
-	return pData->parser.ParseHeader(pData->folderPath + fileName);
-}
-
-std::wstring LevelLoader::GetFolderPath()
-{
-	return this->pData->folderPath;
-}
-
-void LevelLoader::SetFolderPath(std::wstring folderPath)
-{
-	this->pData->folderPath = folderPath;
-}

Code/Game/GameLogic/LevelLoader/LevelLoader.h

@@ -1,56 +0,0 @@
-//////////////////////////////////
-// Created by Sam Svensson 2013 //
-//////////////////////////////////
-
-#ifndef LEVELLOADER_H
-#define LEVELLOADER_H
-
-#include <string>
-#include <vector>
-#include "Utilities.h"
-#include "ObjectDefines.h"
-
-namespace GameLogic
-{
-	class LevelLoader
-	{
-
-	public:
-		LevelLoader();
-		/***********************************************************
-			* Lets you set the standard folderpath for the levels
-			********************************************************/
-		LevelLoader(std::wstring folderPath);
-		~LevelLoader();
-
-		/********************************************************
-			* Loads the level and objects from file.
-			* @param fileName: Path/name to the level-file that you want to load.
-			* @return: Returns all structs with objects and information about the level.
-			********************************************************/
-		std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LoadLevel(std::wstring fileName);
-
-		/********************************************************
-			* Just for fast access for the meta information about the level.
-			* @param fileName: Path to the level-file that you want to load.
-			* @return: Returns the meta information about the level.
-			********************************************************/
-		LevelMetaData LoadLevelHeader(std::wstring fileName); //.
-
-		/***********************************************************
-			* @return: Returns the current standard folder path
-			********************************************************/
-		std::wstring GetFolderPath();
-
-		/***********************************************************
-			* Sets the standard folder path
-			********************************************************/
-		void SetFolderPath(std::wstring folderPath);
-
-	private:
-		struct PrivData;
-		Utility::DynamicMemory::SmartPointer<PrivData> pData;
-	}; 
-}
-
-#endif

Code/Game/GameLogic/LevelLoader/LevelParser.cpp

@@ -1,320 +0,0 @@
-/////////////////////////////////////
-// Created by Pontus Fransson 2013 //
-/////////////////////////////////////
-
-#include "LevelParser.h"
-#include "Loader.h"
-#include "ParseFunctions.h"
-
-using namespace GameLogic;
-using namespace ::LevelFileLoader;
-using namespace Utility::DynamicMemory;
-
-LevelParser::LevelParser()
-{
-	formatVersion.formatVersionMajor = 3;
-	formatVersion.formatVersionMinor = 0;
-}
-
-LevelParser::~LevelParser()
-{
-}
-
-std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::wstring filename)
-{
-	int bufferSize = 0;
-	int counter = 0;
-	bool loadCgf;
-
-	std::vector<SmartPointer<ObjectTypeHeader>> objects;
-
-	//Read entire level file.
-	Loader loader;
-	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
-
-	// Check if file was loaded, else return empty vector
-	if(!buffer)
-	{
-		return std::vector<SmartPointer<ObjectTypeHeader>>();
-	}
-
-	//Read format version
-	LevelLoaderInternal::FormatVersion levelFormatVersion;
-	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
-	counter += sizeof(levelFormatVersion);
-	if(this->formatVersion != levelFormatVersion)
-	{
-		//Returns an empty vector, because it will most likely fail to read the level format.
-		return objects;
-	}
-
-  	while(counter < bufferSize)
-	{
-		loadCgf = true;
-		//Get typeID
-		ObjectType typeID;
-		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
-		switch((int)typeID)
-		{
-			case ObjectType_LevelMetaData:
-			{
-				SmartPointer<ObjectTypeHeader> header = new LevelMetaData;
-				ParseLevelMetaData(&buffer[counter], *(LevelMetaData*)header.Get(), counter);
-				objects.push_back(header);
-				break;
-			}
-
-			case ObjectType_SpawnPoint:
-			{
-				loadCgf = false;
-				ObjectHeader* header = new ObjectHeader;
-				ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-				SpawnPointAttributes* spawn = new SpawnPointAttributes;
-
-				spawn->typeID = header->typeID;
-
-				for(int i = 0; i < 3; i++)
-				{
-					spawn->position[i] = header->position[i];
-				}
-
-				delete header;
-				//objects.push_back(header);
-				objects.push_back(spawn);
-				break;
-			}
-
-			//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them. 
-			//Unless they are changed to not be the same.
-			case ObjectType_Static: case ObjectType_Dynamic:
-			{
-				//Get specialType.
-				ObjectSpecialType specialType;
-				ParseObject(&buffer[counter+4], &specialType, sizeof(typeID));
-
-				switch(specialType)
-				{
-					//there is no difference when parsing these specialTypes.
-					case ObjectSpecialType_CrystalShard:
-					case ObjectSpecialType_CrystalFormation:
-					case ObjectSpecialType_Spike:
-					case ObjectSpecialType_SpikeBox:
-					case ObjectSpecialType_RedExplosiveBox:
-					case ObjectSpecialType_StandardBox:
-					case ObjectSpecialType_Stone:
-					case ObjectSpecialType_Building:
-					{
-						ObjectHeader* header = new ObjectHeader;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-						objects.push_back(header);
-
-						break;
-					}
-
-					case ObjectSpecialType_JumpPad:
-					{
-						JumpPadAttributes* header = new JumpPadAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						//Read the spec
-						ParseObject(&buffer[counter], header->direction, 16);
-						counter += 16;
-						objects.push_back(header);
-
-						break;
-					}
-		
-					case ObjectSpecialType_Portal:
-					{
-						PortalAttributes* header = new PortalAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], header->destination, 12);
-						counter += 12;
-						objects.push_back(header);
-
-						break;
-					}
-					
-					case ObjectSpecialType_World:
-					{
-						WorldAttributes* header = new WorldAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], &header->worldSize, 8);
-						counter += 8;
-						objects.push_back(header);
-						break;
-					}
-
-					case ObjectSpecialType_Sky:
-					{
-						loadCgf = false; 
-						SkyAttributes* header = new SkyAttributes;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], &header->skySize, 4);
-						counter += 4;
-						objects.push_back(header);
-						break;
-					}
-
-					default:
-						//Couldn't find specialType
-						break;
-				}
-				break;
-			}
-			
-			case ObjectType_Light:
-			{
-				LightType lightType;
-
-				//Get Light type
-				ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
-
-				//We only support PointLight for now.
-				BasicLight* header = new BasicLight;
-				ParseObject(&buffer[counter], header, sizeof(*header));
-				counter += sizeof(*header);
-				objects.push_back(header);
-				/*switch(lightType)
-				{
-				case LightType_PointLight:
-				{
-					PointLight* header = new PointLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				case LightType_DirectionalLight:
-				{
-					DirectionalLight* header = new DirectionalLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				case LightType_SpotLight:
-				{
-					SpotLight* header = new SpotLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				default:
-					//Undefined LightType.
-					break;
-				}
-				break;*/
-			}
-			default:
-				//Couldn't find typeID. FAIL!!!!!!
-				break;
-		}
-	}
-
-	return objects;
-}
-
-//för meta information om leveln.
-LevelMetaData LevelParser::ParseHeader(std::wstring filename)
-{
-	int bufferSize = 0;
-	int counter = 0;
-
-	LevelMetaData levelHeader;
-	levelHeader.typeID = ObjectType::ObjectType_Unknown;
-
-	//Read entire level file.
-	Loader loader;
-	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
-
-	//Read format version
-	LevelLoaderInternal::FormatVersion levelFormatVersion;
-	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(formatVersion));
-	counter += sizeof(levelFormatVersion);
-	if(this->formatVersion != levelFormatVersion)
-	{
-		//Do something if it's not the same version
-
-		//Returns an empty levelHeader with ObjectType_Unknown.
-		//Because it will not be able to read another version of the level format.
-		return levelHeader;
-	}
-
-	//Find the header in the returned string.
-	while(counter < bufferSize)
-	{
-		ObjectType typeID;
-		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
-
-		switch(typeID)
-		{
-		case ObjectType_LevelMetaData:
-			ParseLevelMetaData(&buffer[counter], levelHeader, counter);
-			return levelHeader;
-			break;
-		
-			//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them.
-		case ObjectType_Static: case ObjectType_Dynamic:
-		{
-			ObjectHeader header;
-			ParseObject(&buffer[counter], &header, counter);
-
-			switch(header.specialTypeID)
-			{
-			case ObjectSpecialType_JumpPad:
-				counter += sizeof(16);
-				break;
-			case ObjectSpecialType_Portal:
-				counter += sizeof(12);
-				break;
-			default:
-				break;
-			}	
-			break;
-		}
-
-		case ObjectType_Light:
-		{
-			LightType lightType;
-			ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
-
-			//We only support pointlight for now.
-			counter += sizeof(BasicLight);
-			/*
-			switch(lightType)
-			{
-			case LightType_PointLight:
-			{
-				counter += sizeof(PointLight);
-				break;
-			}
-			case LightType_DirectionalLight:
-			{
-				counter += sizeof(DirectionalLight);
-				break;
-			}
-			case LightType_SpotLight:
-			{
-				counter += sizeof(SpotLight);
-				break;
-			}
-			default:
-				//Undefined LightType.
-				break;
-			}*/
-		}
-
-		default:
-			//Couldn't find typeID. FAIL!!!!!!
-			break;
-		}
-	}
-
-	return levelHeader;
-}

Code/Game/GameLogic/LevelLoader/LevelParser.h

@@ -1,31 +0,0 @@
-#ifndef LEVEL_PARSER_H
-#define LEVEL_PARSER_H
-
-#include <string>
-#include <vector>
-#include "ObjectDefines.h"
-#include "Utilities.h"
-
-namespace GameLogic
-{
-	namespace LevelFileLoader
-	{
-		class LevelParser
-		{
-		public:
-			LevelParser();
-			~LevelParser();
-
-			//
-			std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> Parse(std::wstring filename);
-
-			//
-			LevelMetaData ParseHeader(std::wstring filename);
-
-		private:
-			LevelLoaderInternal::FormatVersion formatVersion;
-
-		};
-	}
-}
-#endif

Code/Game/GameLogic/LevelLoader/Loader.cpp

@@ -1,22 +0,0 @@
-//////////////////////////////////
-// Created by Sam Svensson 2013 //
-//////////////////////////////////
-
-#include "Loader.h"
-#include <fstream>
-
-using namespace GameLogic::LevelFileLoader;
-using namespace Oyster::Resource;
-using namespace std;
-
-char* Loader::LoadFile(std::wstring fileName, int &size)
-{
-	//convert from string to wstring
-	//std::wstring temp(fileName.begin(), fileName.end());
-
-	//convert from wstring to wchar then loads the file
-	char* buffer = (char*)OysterResource::LoadResource(fileName.c_str(), Oyster::Resource::ResourceType::ResourceType_Byte_Raw, -1 , false);
-
-	size = OysterResource::GetResourceSize(buffer);
-	return buffer;
-}

Code/Game/GameLogic/LevelLoader/Loader.h

@@ -1,28 +0,0 @@
-//////////////////////////////////
-// Created by Sam Svensson 2013 //
-//////////////////////////////////
-
-#ifndef LOADER_H
-#define LOADER_H
-
-#include "Resource\OysterResource.h"
-#include <string>
-
-namespace GameLogic
-{
-	namespace LevelFileLoader
-	{
-		class Loader
-		{
-		public:
-			Loader (){};
-			~Loader(){};
-			char* LoadFile(std::wstring fileName, int &size); 
-
-			//TODO:
-			//Add functionality to load physicsObjects (hitboxes)
-		};
-	}
-}
-
-#endif;

Code/Game/GameLogic/LevelLoader/ObjectDefines.h

@@ -1,290 +0,0 @@
-#ifndef OBJECT_DEFINES_H
-#define OBJECT_DEFINES_H
-
-#include <string>
-#include <vector>
-
-namespace GameLogic
-{
-	/************************************
-				Enums
-	*************************************/
-	
-	enum ObjectType
-	{
-		ObjectType_LevelMetaData,
-		ObjectType_Static,
-		ObjectType_Dynamic,
-		ObjectType_Light,
-		ObjectType_SpawnPoint,
-		//Etc
-
-		ObjectType_NUM_OF_TYPES,
-
-		ObjectType_Unknown = -1
-	};
-
-	enum ObjectSpecialType
-	{
-		ObjectSpecialType_None,
-		ObjectSpecialType_Sky,
-		ObjectSpecialType_World,		//Always the main celestial body
-		ObjectSpecialType_Building,
-		ObjectSpecialType_Stone,
-		ObjectSpecialType_StandardBox,
-		ObjectSpecialType_RedExplosiveBox,
-		ObjectSpecialType_SpikeBox,
-		ObjectSpecialType_Spike,
-		ObjectSpecialType_CrystalFormation,
-		ObjectSpecialType_CrystalShard,
-		ObjectSpecialType_JumpPad,
-		ObjectSpecialType_Portal,
-		ObjectSpecialType_Player,
-		ObjectSpecialType_Generic,
-		
-
-		ObjectSpecialType_Count,
-		ObjectSpecialType_Unknown  = -1
-	};
-
-	enum CollisionGeometryType
-	{
-		CollisionGeometryType_Box,
-		CollisionGeometryType_Sphere,
-		CollisionGeometryType_Cylinder,
-		CollisionGeometryType_TriangleMesh,
-
-		CollisionGeometryType_Count,
-		CollisionGeometryType_Unknown = -1
-	};
-
-	//Only supports Pointlight right now.
-	enum LightType
-	{
-		LightType_PointLight,
-		//LightType_DirectionalLight,
-		//LightType_SpotLight,
-
-		LightType_Count,
-		LightType_Unknown = -1
-	};
-
-	//Should this be moved somewhere else?
-	enum GameMode
-	{
-		GameMode_FreeForAll,
-		GameMode_TeamDeathMatch,
-		//Etc
-
-		GameMode_Count,
-		GameMode_Unknown = -1
-	};
-
-	enum WorldSize
-	{
-		WorldSize_Tiny,
-		WorldSize_Small,
-		WorldSize_Medium,
-		WorldSize_Big,
-		WorldSize_Humongous,
-
-		WorldSize_Count,
-		WorldSize_Unknown = -1
-	};
-
-
-	/************************************
-				Structs
-	*************************************/
-	namespace LevelLoaderInternal
-	{
-		struct FormatVersion
-		{
-			unsigned int formatVersionMajor;
-			unsigned int formatVersionMinor;
-			
-			FormatVersion()
-				: formatVersionMajor(0), formatVersionMinor(0)
-			{}
-
-			FormatVersion(unsigned int major, unsigned int minor)
-				: formatVersionMajor(major), formatVersionMinor(minor)
-			{}
-
-			bool operator ==(const FormatVersion& obj)
-			{
-				return (this->formatVersionMajor == obj.formatVersionMajor && this->formatVersionMinor == obj.formatVersionMinor);
-			}
-
-			bool operator !=(const FormatVersion& obj)
-			{
-				return !(*this == obj);
-			}
-		};
-	}
-
-	struct ObjectTypeHeader
-	{
-		ObjectType typeID;
-
-		//Unless this is here the object destructor wont be called.
-		virtual ~ObjectTypeHeader(){}
-	};
-
-	namespace LevelLoaderInternal
-	{
-		const FormatVersion boundingVolumeVersion(2, 0);
-
-		struct BoundingVolumeBase
-		{
-			CollisionGeometryType geoType;
-			float position[3];
-			float rotation[4];
-			float frictionCoeffStatic;
-			float frictionCoeffDynamic;
-			float restitutionCoeff;
-			float mass;
-		};
-
-		struct BoundingVolumeBox : public BoundingVolumeBase
-		{
-			float size[3];
-		};
-
-		struct BoundingVolumeSphere : public BoundingVolumeBase
-		{
-			float radius;
-		};
-
-		struct BoundingVolumeCylinder : public BoundingVolumeBase
-		{
-			float length;
-			float radius;
-		};
-
-		struct BoundingVolumeTriangleMesh : public BoundingVolumeBase
-		{
-			//Null terminated
-			wchar_t* filename;
-		};
-
-		struct BoundingVolume
-		{
-			CollisionGeometryType geoType;
-			union
-			{
-				LevelLoaderInternal::BoundingVolumeBox box;
-				LevelLoaderInternal::BoundingVolumeSphere sphere;
-				LevelLoaderInternal::BoundingVolumeCylinder cylinder;
-				LevelLoaderInternal::BoundingVolumeTriangleMesh triangleMesh;
-			};
-
-			virtual ~BoundingVolume()
-			{
-				if(geoType == CollisionGeometryType_TriangleMesh)
-				{
-					delete[] triangleMesh.filename;
-				}
-			}
-		};
-
-	}
-
-	struct LevelMetaData : public ObjectTypeHeader
-	{
-		std::string levelName;
-		unsigned int levelVersion;
-		std::string levelDescription;
-		std::string levelAuthor;
-		unsigned int maxNumberOfPlayer;
-		WorldSize worldSize;
-		std::string overviewPicturePath;
-		std::vector<GameMode> gameModesSupported;
-		
-		virtual ~LevelMetaData(){}
-
-	};
-
-	struct ObjectHeader : public ObjectTypeHeader
-	{
-		//Special type id for special objects: portal, jumppad, exploding objects, etc.
-		ObjectSpecialType specialTypeID;
-		//Model,
-		std::string ModelFile;
-		//Position
-		float position[3];
-		//Rotation Quaternion
-		float rotation[4];
-		//Scale
-		float scale[3];
-
-		::GameLogic::LevelLoaderInternal::BoundingVolume boundingVolume;
-
-		virtual ~ObjectHeader(){}
-	};
-
-	struct SpawnPointAttributes : public ObjectTypeHeader
-	{
-		ObjectSpecialType specialTypeID;
-		float position[3];
-	};
-	/************************************
-				Special objects
-	*************************************/
-
-	struct JumpPadAttributes : public ObjectHeader
-	{
-		float direction[3];
-		float power;
-	};
-
-	struct PortalAttributes : public ObjectHeader
-	{
-		float destination[3];
-	};
-
-	struct WorldAttributes : public ObjectHeader
-	{
-		float worldSize;
-		float atmoSphereSize;
-	};
-
-	struct SkyAttributes : public ObjectHeader
-	{
-		float skySize;
-	};
-
-	
-
-	/************************************
-				Lights
-	*************************************/
-
-	struct BasicLight : public ObjectTypeHeader
-	{
-		LightType lightType;	//Is not used right now
-		float color[3];
-		float position[3];
-		float raduis;
-		float intensity;
-	};
-	/* We only support pointlight right now.
-	struct PointLight : public BasicLight
-	{
-		float position[3];
-	};
-
-	struct DirectionalLight : public BasicLight
-	{
-		float direction[3];
-	};
-
-	struct SpotLight : public BasicLight
-	{
-		float direction[3];
-		float range;
-		float attenuation[3];
-	};*/
-}
-
-#endif

Code/Game/GameLogic/LevelLoader/ParseFunctions.cpp

@@ -1,195 +0,0 @@
-//////////////////////////////////
-// Created by Sam Svensson 2013 //
-//////////////////////////////////
-
-#include "ParseFunctions.h"
-#include "Packing/Packing.h"
-#include "Loader.h"
-#include "Utilities.h"
-#include <string>
-
-using namespace Oyster::Packing;
-using namespace GameLogic::LevelFileLoader;
-using namespace GameLogic;
-using namespace std;
-
-namespace GameLogic
-{
-	namespace LevelFileLoader
-	{
-		//can parse any struct if the struct doesnt contain strings or char[]
-		void ParseObject(char* buffer, void *header, int size)
-		{
-			memcpy(header, buffer, size);
-		}
-
-		void ParseObject(char* buffer, ObjectHeader& header, int& size, bool loadCgf)
-		{
-			char tempName[128];
-			unsigned int tempSize = 0;
-			int start = 0;
-
-			memcpy(&header.typeID, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&header.specialTypeID, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempSize, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempName, &buffer[start], tempSize);
-			header.ModelFile.assign(&tempName[0], &tempName[tempSize]);
-			start += tempSize;
-
-			//The reset of the object struct
-			//3 float[3], 1 float
-			memcpy(&header.position, &buffer[start], 40);
-			start += 40;
-			
-			//if loadCgf : Read path for bounding volume
-			if(loadCgf)
-			{
-				ParseBoundingVolume(&buffer[start], header.boundingVolume, start);
-			}
-
-			//else make sure the counter counts the name so we can jump over the string in the buffer. 
-			else
-			{
-				memcpy(&tempSize, &buffer[start], 4);
-				start += 4;
-
-				memcpy(&tempName, &buffer[start], tempSize);
-
-				string fileName;
-				fileName.assign(&tempName[0], &tempName[tempSize]);
-				start += tempSize;
-			}
-
-			size += start;
-		}
-
-		void ParseLevelMetaData(char* buffer, LevelMetaData &header, int &size)
-		{
-			int start = 0;
-			unsigned int tempSize;
-			char tempName[128];
-
-			memcpy(&header.typeID, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempSize , &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempName, &buffer[start], tempSize);
-			header.levelName.assign(&tempName[0], &tempName[tempSize]);
-			start += tempSize;
-
-			memcpy(&header.levelVersion, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempSize, &buffer[start], 4);
-			start +=4;
-
-			memcpy(&tempName, &buffer[start], tempSize);
-			header.levelDescription.assign(&tempName[0], &tempName[tempSize]);
-			start += tempSize;
-
-			memcpy(&tempSize, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempName, &buffer[start], tempSize);
-			header.levelAuthor.assign(&tempName[0], &tempName[tempSize]);
-			start += tempSize;
-
-			memcpy(&header.maxNumberOfPlayer, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&header.worldSize, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempSize, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempName, &buffer[start], tempSize);
-			header.overviewPicturePath.assign(&tempName[0], &tempName[tempSize]);
-			start += tempSize;
-
-			memcpy(&tempSize, &buffer[start], 4);
-			start += 4;
-
-			int temp;
-
-			for(int i = 0; i < (int)tempSize; i++)
-			{
-				memcpy(&temp, &buffer[start], 4);
-				start += 4;
-				header.gameModesSupported.push_back((GameMode)temp);
-			}
-
-			size += start;
-		}
-
-		void ParseBoundingVolume(char* buffer, LevelLoaderInternal::BoundingVolume& volume, int &size)
-		{
-			int start = 0;
-			int tempSize = 0;
-			char tempName[128];
-			
-			memcpy(&tempSize, &buffer[start], 4);
-			start += 4;
-
-			memcpy(&tempName, &buffer[start], tempSize);
-
-			string fileName;
-			fileName.assign(&tempName[0], &tempName[tempSize]);
-			start += tempSize;
-
-			size += start;
-
-			//Läs in filen.
-			int fileLength = 0;
-			Loader loader;
-			char* buf = loader.LoadFile(L"../Content/Worlds/cgf/" + Utility::String::StringToWstring(fileName, wstring()), fileLength);
-
-			start = 0;
-			LevelLoaderInternal::FormatVersion version;
-			memcpy(&version, &buf[0], sizeof(version));
-			start += 8;
-
-			memcpy(&volume.geoType, &buf[start], sizeof(volume.geoType));
-
-			switch(volume.geoType)
-			{
-			case CollisionGeometryType_Box:
-				memcpy(&volume.box, &buf[start], sizeof(volume.box));
-				start += sizeof(volume.box);
-				break;
-
-			case CollisionGeometryType_Sphere:
-				memcpy(&volume.sphere, &buf[start], sizeof(volume.sphere));
-				start += sizeof(volume.sphere);
-				break;
-
-			case CollisionGeometryType_Cylinder:
-				memcpy(&volume.cylinder, &buf[start], sizeof(volume.cylinder));
-				start += sizeof(volume.cylinder);
-				break;
-
-			case CollisionGeometryType_TriangleMesh:
-				//Get string size
-				memcpy(&tempSize, &buf[start], sizeof(tempSize));
-				start += sizeof(tempSize);
-
-				//Get actual string
-				volume.triangleMesh.filename = new wchar_t[tempSize+1];
-				memcpy(volume.triangleMesh.filename, &buf[start], tempSize);
-				volume.triangleMesh.filename[tempSize] = '\0';
-				break;
-
-			default:
-				break;
-			}
-		}
-	}
-}

Code/Game/GameLogic/LevelLoader/ParseFunctions.h

@@ -1,28 +0,0 @@
-//////////////////////////////////
-// Created by Sam Svensson 2013 //
-//////////////////////////////////
-
-#ifndef PARSERFUNCTIONS_H
-#define PARSERFUNCTIONS_H
-#include "ObjectDefines.h"
-
-namespace GameLogic
-{
-	namespace LevelFileLoader
-	{
-		/*
-			These functions will copy data from where the buffer pointer points.
-			header is the destination where the data will be copied.
-			size is either the size of the data to be copied (if it is NOT sent by reference). 
-			Or the current index that is being used to parse the entire file (if it is sent by reference) this means you have to increase size with the appropiate size after you have copied.
-
-		*/
-		void ParseObject(char* buffer, void *header, int size);
-		void ParseObject(char* buffer, ObjectHeader& header, int& size , bool loadCgf);
-		void ParseLevelMetaData(char* buffer, LevelMetaData &header, int &size);
-		void ParseBoundingVolume(char* buffer, LevelLoaderInternal::BoundingVolume& volume, int &size);
-	}
-}
-
-
-#endif

Code/Game/GameLogic/Object.cpp

@@ -15,11 +15,11 @@ const Game *Object::gameInstance = (Game*)(&Game::Instance());
 
 Object::Object()
 {	
-
 	this->rigidBody = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.0f, 0.0f, 0.0f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(0, 0, 0), 0, 0.5f, 0.8f, 0.6f);
 
 	this->type = ObjectSpecialType_Unknown;
 	this->objectID = -1;
+	this->scale = Float3(1.0f, 1.0f, 1.0f);
 }
 
 Object::Object(Oyster::Physics::ICustomBody *rigidBody, void (*collisionFuncAfter)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss), ObjectSpecialType type, int objectID)
@@ -48,39 +48,12 @@ Object::~Object(void)
 
 }
 
-ObjectSpecialType Object::GetObjectType() const
+
+void Object::SetOnCollision(OnCollisionCallback func)
 {
-	return this->type;
+	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse)(func));
-}
-int Object::GetID() const
-{
-	return this->objectID;
 }
 
-Oyster::Physics::ICustomBody* Object::GetRigidBody()
-{
-	return this->rigidBody;
-}
-
-
-void Object::BeginFrame()
-{
-	
-}
-// update physic 
-void Object::EndFrame()
-{
-
-}
-
-void Object::setBeforeCollisonFunc(Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncBefore)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter))
-{
-	//this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse)(collisionFuncBefore));
-}
-void Object::setAfterCollisonFunc(Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncAfter)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss))
-{
-	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse)(collisionFuncAfter));
-}
 
 Oyster::Math::Float3 Object::GetPosition() 
 {
@@ -94,21 +67,9 @@ Oyster::Math::Quaternion Object::GetRotation()
 	state = this->rigidBody->GetState();
 	return state.quaternion;
 }
-Oyster::Math::Float3 Object::GetScale() 
-{
-	Oyster::Physics::ICustomBody::State state; 
-	state = this->rigidBody->GetState();
-	return Float3();
-}
 Oyster::Math::Float4x4 Object::GetOrientation() 
 {
 	Oyster::Physics::ICustomBody::State state; 
 	state = this->rigidBody->GetState();
 	return state.GetOrientation();
 }
-
-
-Oyster::Math::Float Object::getExtraDamageOnCollision()
-{
-	return this->extraDamageOnCollision;
-}

Code/Game/GameLogic/Object.h

@@ -17,46 +17,38 @@ namespace GameLogic
 	class Object	:public IObjectData
 	{
 	public:
-		Object();
+		typedef Oyster::Physics::ICustomBody::SubscriptMessage (*OnCollisionCallback)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss);
 
+	public:		
+		Object();
 		Object(Oyster::Physics::ICustomBody *rigidBody, void (*collisionFuncAfter)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss), ObjectSpecialType type, int objectID);
 		Object(Oyster::Physics::ICustomBody *rigidBody, Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncAfter)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss), ObjectSpecialType type, int objectID);
 		~Object(void);
 
-		ObjectSpecialType GetObjectType() const			override;
+		inline ObjectSpecialType				GetObjectType() const	override	{ return this->type; }
-		int GetID() const								override;	
+		inline int								GetID()			const	override	{ return this->objectID; }	
-		void setID(int id);
+		inline Oyster::Math::Float3				GetScale()				override	{ return this->scale; }
-		Oyster::Math::Float3 GetPosition()			override;
+		inline Oyster::Math::Float3				GetPosition()			override;
-		Oyster::Math::Quaternion GetRotation()		override;
+		inline Oyster::Math::Quaternion			GetRotation()			override;
-		Oyster::Math::Float3 GetScale()				override;
+		inline Oyster::Math::Float4x4			GetOrientation()		override;
-		Oyster::Math::Float4x4 GetOrientation()		override;
+		inline Oyster::Physics::ICustomBody*	GetRigidBody()						{ return this->rigidBody; }
+		inline Oyster::Math::Float				GetExtraDamageOnCollision()			{ return this->extraDamageOnCollision; }
 
-		Oyster::Math::Float getExtraDamageOnCollision();
+		virtual void BeginFrame()	{ };
+		virtual void EndFrame()		{ };
 
-		// API overrides
+		void SetOnCollision(OnCollisionCallback func);
-		
-
-
-		Oyster::Physics::ICustomBody* GetRigidBody();
-
-		virtual void BeginFrame();
-		virtual void EndFrame();
-
-		void setBeforeCollisonFunc(Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncBefore)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter));
-		void setAfterCollisonFunc(Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncAfter)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss));
-
-		static Oyster::Physics::ICustomBody::SubscriptMessage DefaultCollisionAfter(Oyster::Physics::ICustomBody *rigidBodyLevel, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss);
-	
-
-	public: //TODO: Hax This should be private when level is dynamic
 
+		static Oyster::Physics::ICustomBody::SubscriptMessage DefaultOnCollision(Oyster::Physics::ICustomBody *rigidBodyObject, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss);
 
 	protected:
 		Oyster::Physics::ICustomBody *rigidBody;
 
 		static const Game* gameInstance;
-		Oyster::Math::Float3 currLook;
+
-		Oyster::Math::Float3 newLook;
+		Oyster::Math::Float3 lookDirection;		//The look direction for the camera
+		Oyster::Math::Float3 forwardDirection;	//The forward direction of the rigid body
+		Oyster::Math::Float3 scale;				//The scale of both rigid body and the mesh
 
 		ObjectSpecialType type;
 		int objectID;

Code/Game/GameLogic/Player.cpp

@@ -33,6 +33,8 @@ Player::Player(Oyster::Physics::ICustomBody *rigidBody, void (*EventOnCollision)
 	this->moveDir = Oyster::Math::Float3(0,0,0);
 	this->moveSpeed = 100;
 	this->previousMoveSpeed = Oyster::Math::Float3(0,0,0);
+
+	this->rotationUp = 0;
 }
 
 Player::Player(Oyster::Physics::ICustomBody *rigidBody, Oyster::Physics::ICustomBody::SubscriptMessage (*EventOnCollision)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss), ObjectSpecialType type, int objectID, int teamID)
@@ -53,6 +55,8 @@ Player::Player(Oyster::Physics::ICustomBody *rigidBody, Oyster::Physics::ICustom
 	this->moveDir = Oyster::Math::Float3(0,0,0);
 	this->moveSpeed = 20;
 	this->previousMoveSpeed = Oyster::Math::Float3(0,0,0);
+
+	this->rotationUp = 0;
 }
 
 Player::~Player(void)
@@ -160,7 +164,6 @@ void Player::EndFrame()
 	
 	this->rigidBody->SetUp(this->rigidBody->GetState().centerPos.GetNormalized());
 	
-	
 	Object::EndFrame();	
 }
 
@@ -220,7 +223,7 @@ void Player::Respawn(Oyster::Math::Float3 spawnPoint)
 	this->rigidBody->SetPosition(spawnPoint);
 }
 
-void Player::Rotate(const Oyster::Math3D::Float3 lookDir, const Oyster::Math3D::Float3 right)
+void Player::Rotate(const Oyster::Math3D::Float3& lookDir, const Oyster::Math3D::Float3& right)
 {
 	// this is the camera right vector
 	this->lookDir = lookDir;
@@ -228,6 +231,11 @@ void Player::Rotate(const Oyster::Math3D::Float3 lookDir, const Oyster::Math3D::
 	//Oyster::Math::Float3 up = this->rigidBody->GetState().GetOrientation().v[1];
 	//this->rigidBody->SetUpAndRight(up, right);
 }
+void Player::TurnLeft(Oyster::Math3D::Float deltaRadians)
+{
+	this->rotationUp += deltaRadians;
+	this->rigidBody->SetRotationAsAngularAxis(Oyster::Math3D::Float4(this->rigidBody->GetState().centerPos.GetNormalized(), this->rotationUp));
+}
 
 void Player::Jump()
 {

Code/Game/GameLogic/Player.h

@@ -46,7 +46,9 @@ namespace GameLogic
 		void Respawn(Oyster::Math::Float3 spawnPoint);
 
 
-		void Rotate(const Oyster::Math3D::Float3 lookDir, const Oyster::Math3D::Float3 right);
+		void Rotate(const Oyster::Math3D::Float3& lookDir, const Oyster::Math3D::Float3& right);
+
+		void TurnLeft(Oyster::Math3D::Float deltaRadians);
 
 		/********************************************************
 		* Collision function for player, this is to be sent to physics through the subscribe function with the rigidbody
@@ -94,6 +96,8 @@ namespace GameLogic
 		Oyster::Math::Float moveSpeed;
 		Oyster::Math::Float3 previousMoveSpeed;
 
+		Oyster::Math::Float rotationUp;
+
 
 		bool hasTakenDamage;
 		float invincibleCooldown;

Code/Game/GameProtocols/ObjectProtocols.h

@@ -561,11 +561,11 @@ namespace GameLogic
 			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
 
 		//PLAYER_ID
-			this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Bool;
 		//TEAM_ID
 			this->protocol[2].type = Oyster::Network::NetAttributeType_Int;
 		//OWNER
-			this->protocol[3].type = Oyster::Network::NetAttributeType_Bool;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_Int;
 		//PLAYER-NAME
 			this->protocol[4].type = Oyster::Network::NetAttributeType_CharArray;
 		//MESH-NAME
@@ -585,9 +585,10 @@ namespace GameLogic
 		}
 		Protocol_ObjectCreatePlayer(Oyster::Network::CustomNetProtocol& p)
 		{
-			this->object_ID = p[1].value.netInt;
+			this->owner = p[1].value.netBool;
-			this->teamId = this->protocol[2].value.netInt;
+			this->object_ID = p[2].value.netInt;
-			this->owner = this->protocol[3].value.netBool;
+			this->teamId = p[3].value.netInt;
+
 			this->name.assign(p[4].value.netCharPtr);
 			this->meshName.assign(p[5].value.netCharPtr);
 			
@@ -610,11 +611,11 @@ namespace GameLogic
 			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
 
 		//PLAYER_ID
-			this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Bool;
 		//TEAM_ID
 			this->protocol[2].type = Oyster::Network::NetAttributeType_Int;
 		//OWNER
-			this->protocol[3].type = Oyster::Network::NetAttributeType_Bool;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_Int;
 		//PLAYER-NAME
 			this->protocol[4].type = Oyster::Network::NetAttributeType_CharArray;
 		//MESH-NAME
@@ -644,10 +645,10 @@ namespace GameLogic
 		}
 		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
+			this->protocol[1].value = this->owner;
+			this->protocol[2].value = this->object_ID;
+			this->protocol[3].value = this->teamId;
 			
-			this->protocol[1].value = this->object_ID;
-			this->protocol[2].value = this->teamId;
-			this->protocol[3].value = this->owner;
 			this->protocol.Set(4, this->name);
 			this->protocol.Set(5, this->meshName);
 

Code/Game/GameProtocols/PlayerProtocols.h

@@ -74,69 +74,40 @@ namespace GameLogic
 			Oyster::Network::CustomNetProtocol protocol;
 	};
 
-	struct Protocol_PlayerLook :public Oyster::Network::CustomProtocolObject
+	//protocol_Gameplay_PlayerLeftTurn
+	struct Protocol_PlayerLeftTurn : public ::Oyster::Network::CustomProtocolObject
 	{
-		// can be swapped to a quaternion later
+	public:
-		float lookDir[3]; 
+		float deltaRadian;
-		float right[3]; 
 		
-		Protocol_PlayerLook()
+		Protocol_PlayerLeftTurn()
 		{
-			this->protocol[0].value = protocol_Gameplay_PlayerLookDir;
+			this->protocol[0].value = protocol_Gameplay_PlayerLeftTurn;
-			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[0].type = ::Oyster::Network::NetAttributeType_Short;
-			// LookDir
+			// deltaRadian
-			this->protocol[1].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[1].type = ::Oyster::Network::NetAttributeType_Float;
-			this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[3].type = Oyster::Network::NetAttributeType_Float;
-			// Right
-			this->protocol[4].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[5].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[6].type = Oyster::Network::NetAttributeType_Float;
-
-			memset(&this->lookDir[0], 0, sizeof(float) * 3);
-			memset(&this->right[0], 0, sizeof(float) * 3);
-		}
-		Protocol_PlayerLook(Oyster::Network::CustomNetProtocol& p)
-		{
-			this->lookDir[0] = p[1].value.netFloat;
-			this->lookDir[1] = p[2].value.netFloat;
-			this->lookDir[2] = p[3].value.netFloat;
-
-			this->right[0] = p[4].value.netFloat;
-			this->right[1] = p[5].value.netFloat;
-			this->right[2] = p[6].value.netFloat;
-		}
-		Protocol_PlayerLook(float l[3], float r[3])
-		{
-			this->protocol[0].value = protocol_Gameplay_PlayerLookDir;
-			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
-
-			this->protocol[1].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[3].type = Oyster::Network::NetAttributeType_Float;
-
-			this->protocol[4].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[5].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[6].type = Oyster::Network::NetAttributeType_Float;
-
-			memcpy(&this->lookDir[0], &l[0], sizeof(float) * 3);
-			memcpy(&this->right[0], &r[0], sizeof(float) * 3);
 		}
 
-		Oyster::Network::CustomNetProtocol GetProtocol() override
+		Protocol_PlayerLeftTurn( const ::Oyster::Network::CustomNetProtocol &p )
 		{
-			this->protocol[1].value = this->lookDir[0];
+			this->deltaRadian = p[1].value.netFloat;
-			this->protocol[2].value = this->lookDir[1];
+		}
-			this->protocol[3].value = this->lookDir[2];
-			this->protocol[4].value = this->right[0];
-			this->protocol[5].value = this->right[1];
-			this->protocol[6].value = this->right[2];	
 
+		Protocol_PlayerLeftTurn( float deltaRadian )
+		{
+			this->protocol[0].value = protocol_Gameplay_PlayerLeftTurn;
+			this->protocol[0].type = ::Oyster::Network::NetAttributeType_Short;
+			this->deltaRadian = deltaRadian;
+		}
+		
+		::Oyster::Network::CustomNetProtocol GetProtocol() override
+		{
+			this->protocol[1].value = this->deltaRadian;
 			return protocol;
 		}
 
-	private:
+		private:
-		Oyster::Network::CustomNetProtocol protocol;
+		::Oyster::Network::CustomNetProtocol protocol;
 	};
 
 	struct Protocol_PlayerChangeWeapon :public Oyster::Network::CustomProtocolObject

Code/Game/GameProtocols/ProtocolIdentificationID.h

@@ -47,7 +47,7 @@
 #define protocol_Gameplay_PlayerMovementLeft		301
 #define protocol_Gameplay_PlayerMovementForward		302
 #define protocol_Gameplay_PlayerMovementBackward	303
-#define protocol_Gameplay_PlayerLookDir				304
+#define protocol_Gameplay_PlayerLeftTurn			304
 #define protocol_Gameplay_PlayerChangeWeapon		305
 #define protocol_Gameplay_PlayerShot				306
 #define protocol_Gameplay_PlayerJump				307

Code/Game/GameServer/GameServer.vcxproj

@@ -198,6 +198,9 @@
     <ClInclude Include="GameSession.h" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\Misc\OysterMath\OysterMath.vcxproj">
+      <Project>{f10cbc03-9809-4cba-95d8-327c287b18ee}</Project>
+    </ProjectReference>
     <ProjectReference Include="..\..\Misc\Utilities\Utilities.vcxproj">
       <Project>{2ec4dded-8f75-4c86-a10b-e1e8eb29f3ee}</Project>
     </ProjectReference>

Code/Game/GameServer/GameSession.h

@@ -84,7 +84,7 @@ namespace DanBias
 		void Gameplay_PlayerMovementBack	( DanBias::GameClient* c );
 		void Gameplay_PlayerMovementForth	( DanBias::GameClient* c );
 		void Gameplay_PlayerJump			( DanBias::GameClient* c );
-		void Gameplay_PlayerLookDir			( GameLogic::Protocol_PlayerLook& p, DanBias::GameClient* c );
+		void Gameplay_PlayerLeftTurn		( GameLogic::Protocol_PlayerLeftTurn& p, DanBias::GameClient* c );
 		void Gameplay_PlayerChangeWeapon	( GameLogic::Protocol_PlayerChangeWeapon& p, DanBias::GameClient* c );
 		void Gameplay_PlayerShot			( GameLogic::Protocol_PlayerShot& p, DanBias::GameClient* c );
 		void Gameplay_ObjectPickup			( GameLogic::Protocol_ObjectPickup& p, DanBias::GameClient* c );

Code/Game/GameServer/Implementation/GameClient.cpp

@@ -17,7 +17,7 @@ GameClient::GameClient(Utility::DynamicMemory::SmartPointer<Oyster::Network::Net
 	this->client = nwClient;
 	this->player = 0;
 	isReady = false;
-	this->character = L"Unknown";
+	this->character = L"crate_colonists.dan";
 	this->alias = L"Unknown";
 	this->secondsSinceLastResponse = 0.0f;
 }
@@ -25,7 +25,7 @@ GameClient::~GameClient()
 {
 	this->player = 0;
 	this->isReady = false;
-	this->character = L"Unknown";
+	this->character = L"crate_colonists.dan";
 	this->alias = L"Unknown";
 	this->secondsSinceLastResponse = 0.0f;
 }

Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp

@@ -66,10 +66,10 @@ using namespace DanBias;
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend:
 				printf("\t(%i : %s) - EventType_ProtocolFailedToSend\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
-				this->Detach(e.sender);
+				//this->Detach(e.sender);
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolRecieved:
-				printf("\t(%i : %s) - EventType_ProtocolRecieved\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
+				//printf("\t(%i : %s) - EventType_ProtocolRecieved\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
 				this->ParseProtocol(e.args.data.protocol, cl);
 			break;
 		}
@@ -156,7 +156,7 @@ using namespace DanBias;
 			break;
 			case protocol_Gameplay_PlayerJump:					this->Gameplay_PlayerJump				( c );
 			break;
-			case protocol_Gameplay_PlayerLookDir:				this->Gameplay_PlayerLookDir			( Protocol_PlayerLook			(p), c );
+			case protocol_Gameplay_PlayerLeftTurn:				this->Gameplay_PlayerLeftTurn			( Protocol_PlayerLeftTurn		(p), c );
 			break;
 			case protocol_Gameplay_PlayerChangeWeapon:			this->Gameplay_PlayerChangeWeapon		( Protocol_PlayerChangeWeapon	(p), c );
 			break;
@@ -203,12 +203,9 @@ using namespace DanBias;
 	{
 		c->GetPlayer()->Move(GameLogic::PLAYER_MOVEMENT_JUMP);
 	}
-	void GameSession::Gameplay_PlayerLookDir			( Protocol_PlayerLook& p, DanBias::GameClient* c )
+	void GameSession::Gameplay_PlayerLeftTurn			( Protocol_PlayerLeftTurn& p, DanBias::GameClient* c )
 	{
-		Oyster::Math3D::Float3 lookDir = p.lookDir; 
+		c->GetPlayer()->TurnLeft( p.deltaRadian );
-		Oyster::Math3D::Float3 right = p.right; 
-		
-		c->GetPlayer()->Rotate(lookDir, right);
 	}
 	void GameSession::Gameplay_PlayerChangeWeapon		( Protocol_PlayerChangeWeapon& p, DanBias::GameClient* c )
 	{

Code/Game/GameServer/Implementation/GameSession_General.cpp

@@ -165,7 +165,8 @@ void GameSession::ThreadEntry(  )
 						IPlayerData* pl = this->gClients[k]->GetPlayer();
 						Protocol_ObjectCreatePlayer p(	pl->GetPosition(), pl->GetRotation(), pl->GetScale(),
 														pl->GetID(), true, this->gClients[k]->GetPlayer()->GetTeamID(),
-														/*nwClient->GetAlias()*/"", /*playerData->GetMesh()*/"char_white.dan");
+														Utility::String::WStringToString(this->gClients[k]->GetAlias(), std::string()), 
+														Utility::String::WStringToString(this->gClients[k]->GetCharacter(), std::string()));
 						readyList[i]->GetClient()->Send(p);
 					}
 				}
@@ -204,7 +205,8 @@ bool GameSession::Join(gClient gameClient)
 	{
 		Protocol_ObjectCreatePlayer oc(	playerData->GetPosition(), playerData->GetRotation(), playerData->GetScale(), 
 										playerData->GetID(), true, playerData->GetTeamID(), 
-										/*nwClient->GetAlias()*/"Unknown", /*playerData->GetMesh()*/"char_white.dan");
+										Utility::String::WStringToString(gameClient->GetAlias(), std::string()), 
+										Utility::String::WStringToString(gameClient->GetCharacter(), std::string()));
 		nwClient->Send(oc);
 	}
 
@@ -217,7 +219,8 @@ bool GameSession::Join(gClient gameClient)
 				IPlayerData* temp = this->gClients[i]->GetPlayer();
 				Protocol_ObjectCreatePlayer oc(	temp->GetPosition(), temp->GetRotation(), temp->GetScale(), 
 												temp->GetID(), false, temp->GetTeamID(), 
-												/*nwClient->GetAlias()*/"Unknown", /*playerData->GetMesh()*/"char_white.dan");
+												Utility::String::WStringToString(this->gClients[i]->GetAlias(), std::string()), 
+												Utility::String::WStringToString(this->gClients[i]->GetCharacter(), std::string()));
 				nwClient->Send(oc);
 			}
 		}

Code/Game/LanServer/StandAloneLauncher/Form1.Designer.cs

@@ -210,11 +210,12 @@
             this.mapName.FormattingEnabled = true;
             this.mapName.IntegralHeight = false;
             this.mapName.Items.AddRange(new object[] {
-            "Set default"});
+            "Set directory"});
             this.mapName.Location = new System.Drawing.Point(72, 7);
             this.mapName.Name = "mapName";
             this.mapName.Size = new System.Drawing.Size(163, 21);
             this.mapName.TabIndex = 10;
+            this.mapName.SelectedIndexChanged += new System.EventHandler(this.mapName_SelectedIndexChanged);
             // 
             // gameModes
             // 
@@ -481,7 +482,7 @@
             this.tableLayoutPanel1.ColumnCount = 3;
             this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 35.29412F));
             this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 64.70588F));
-            this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 118F));
+            this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 112F));
             this.tableLayoutPanel1.Controls.Add(this.label6, 0, 0);
             this.tableLayoutPanel1.Controls.Add(this.label7, 1, 0);
             this.tableLayoutPanel1.Controls.Add(this.label8, 2, 0);
@@ -515,7 +516,7 @@
             // label8
             // 
             this.label8.AutoSize = true;
-            this.label8.Location = new System.Drawing.Point(116, 1);
+            this.label8.Location = new System.Drawing.Point(122, 1);
             this.label8.Name = "label8";
             this.label8.Size = new System.Drawing.Size(34, 13);
             this.label8.TabIndex = 8;

Code/Game/LanServer/StandAloneLauncher/Form1.cs

@@ -25,12 +25,16 @@ namespace StandAloneLauncher
         {
             InitializeComponent();
 
-            string[] maps = Directory.GetFiles("..\\Content\\Worlds\\");
 
+            string[] maps = Directory.GetFiles("..\\Content\\Worlds\\");
             for (int i = 0; i < maps.Length; i++)
             {
-                string temp = maps[i].Split('\\').Last() ;
+                string temp = maps[i].Split('\\').Last();
-                this.mapName.Items.Add(temp);
+                string type = temp.Split('.').Last();
+                if (type == "bias")
+                {
+                    this.mapName.Items.Add(temp);
+                }
             }
 
             this.gameModes.SelectedIndex = 0;
@@ -58,6 +62,19 @@ namespace StandAloneLauncher
         {
             if (this.serverIsRunning)
             {
+                if (gameIsStarted)
+                {
+                    //this.gameServer.GameStop();
+
+                    this.gameIsStarted = false;
+                    this.buttonStartGame.Text = "Start Game";
+                    this.mapName.Enabled = true;
+                    this.nrOfClients.Enabled = true;
+                    this.gameModes.Enabled = true;
+                    this.timeLimit.Enabled = true;
+                    this.forceStart.Enabled = true;
+                }
+
                 this.serverIsRunning = false;
                 this.gameServer.ServerStop();
                 this.listenPort.Enabled = true;
@@ -66,7 +83,7 @@ namespace StandAloneLauncher
                 this.serverToggle.Text = "Start server";
                 this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Server terminated!\n");
                 this.panel_commands.Visible = false;
-                this.panelServerCommands.Visible = false;
+                //this.panelServerCommands.Visible = false;
             }
             else
             {
@@ -89,11 +106,11 @@ namespace StandAloneLauncher
                     this.gameServer.ServerStart();
                     this.panel_commands.Visible = true;
                     this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Server initiated!\n\tListening on port " + this.listenPort.Value.ToString() + "\n\tLocal IP: " + info.serverIp + "\n");
-                    this.panelServerCommands.Visible = true;
+                    //this.panelServerCommands.Visible = true;
                 }
                 else
                 {
-                    this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Failed to initiate the server!");
+                    this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Failed to initiate the server!\n");
                 }
             }
         }
@@ -104,6 +121,9 @@ namespace StandAloneLauncher
             {
                 //this.gameServer.GameSetGameMode(this.gameModes.SelectedText);
                 this.gameServer.GameSetGameTime((int)this.timeLimit.Value);
+
+
+
                 this.gameServer.GameSetMapName(this.mapName.Text);
                 this.gameServer.GameSetMaxClients((int)this.nrOfClients.Value);
 
@@ -125,6 +145,8 @@ namespace StandAloneLauncher
             }
             else
             {
+                //this.gameServer.GameStop();
+
                 this.gameIsStarted = false;
                 this.buttonStartGame.Text = "Start Game";
                 this.mapName.Enabled        = true;
@@ -154,5 +176,29 @@ namespace StandAloneLauncher
             this.dataProtocolFields.RowStyles.Add(new RowStyle(SizeType.Absolute, 27));
 
         }
+
+        private void mapName_SelectedIndexChanged(object sender, EventArgs e)
+        {
+            if ( this.panel_commands.Visible && (this.mapName.SelectedItem.ToString() == "Set directory"))
+            {
+                FolderBrowserDialog f = new FolderBrowserDialog();
+                DialogResult r = f.ShowDialog();
+                if (r == System.Windows.Forms.DialogResult.OK)
+                {
+                    this.mapName.Items.Clear();
+                    this.mapName.Items.Add("Set directory");
+                    string[] maps = Directory.GetFiles(f.SelectedPath);
+                    for (int i = 0; i < maps.Length; i++)
+                    {
+                        string temp = maps[i].Split('\\').Last();
+                        string type = temp.Split('.').Last();
+                        if (type == "bias")
+                        {
+                            this.mapName.Items.Add(temp);
+                        }
+                    }
+                }
+            }
+        }
     }
 }

Code/Game/LevelLoader/LevelLoader.cpp

@@ -48,5 +48,5 @@ std::string LevelLoader::GetFolderPath()
 
 void LevelLoader::SetFolderPath(std::string folderPath)
 {
-
+	this->pData->folderPath = folderPath;
 }

Code/Game/LevelLoader/LevelLoader.vcxproj

@@ -19,35 +19,35 @@
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
-    <ProjectGuid>{104FA3E9-94D9-4E1D-A941-28A03BC8A095}</ProjectGuid>
+    <ProjectGuid>{6391E709-D9FA-4FEF-A3B9-4343DB5A0C63}</ProjectGuid>
-    <RootNamespace>GamePhysics</RootNamespace>
+    <RootNamespace>LevelLoader</RootNamespace>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v110</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
+    <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v110</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
+    <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v110</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
+    <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v110</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
+    <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -66,53 +66,45 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
+    <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
-    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
+    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
+    <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
-    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
+    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
+    <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
-    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
+    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
+    <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
-    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
+    <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;$(SolutionDir)Physics\Bullet Source\</AdditionalIncludeDirectories>
+      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;</AdditionalIncludeDirectories>
-      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ModuleDefinitionFile>
-      </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debug.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;$(SolutionDir)Physics\Bullet Source\</AdditionalIncludeDirectories>
+      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;</AdditionalIncludeDirectories>
-      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ModuleDefinitionFile>
-      </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debugx64.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debugx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -121,18 +113,18 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;$(SolutionDir)Physics\Bullet Source\</AdditionalIncludeDirectories>
+      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;</AdditionalIncludeDirectories>
-      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <ModuleDefinitionFile>
-      </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollision.lib;$(SolutionDir)Physics/lib/release/BulletDynamics.lib;$(SolutionDir)Physics/lib/release/LinearMath.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
+    <Lib>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Lib>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
@@ -140,30 +132,32 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;$(SolutionDir)Physics\Bullet Source\</AdditionalIncludeDirectories>
+      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc\Utilities;</AdditionalIncludeDirectories>
-      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <ModuleDefinitionFile>
-      </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollisionx64.lib;$(SolutionDir)Physics/lib/release/BulletDynamicsx64.lib;$(SolutionDir)Physics/lib/release/LinearMathx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="Implementation\PhysicsAPI_Impl.h" />
+    <ClCompile Include="LevelLoader.cpp" />
-    <ClInclude Include="Implementation\SimpleRigidBody.h" />
+    <ClCompile Include="LevelParser.cpp" />
-    <ClInclude Include="PhysicsAPI.h" />
+    <ClCompile Include="Loader.cpp" />
-    <ClInclude Include="PhysicsStructs-Impl.h" />
+    <ClCompile Include="ParseFunctions.cpp" />
-    <ClInclude Include="PhysicsStructs.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="Implementation\DLLMain.cpp" />
+    <ClInclude Include="LevelLoader.h" />
-    <ClCompile Include="Implementation\PhysicsAPI_Impl.cpp" />
+    <ClInclude Include="LevelParser.h" />
-    <ClCompile Include="Implementation\SimpleRigidBody.cpp" />
+    <ClInclude Include="Loader.h" />
+    <ClInclude Include="ObjectDefines.h" />
+    <ClInclude Include="ParseFunctions.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Misc\Utilities\Utilities.vcxproj">
+      <Project>{2ec4dded-8f75-4c86-a10b-e1e8eb29f3ee}</Project>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Code/Game/LevelLoader/LevelLoader.vcxproj.user

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ShowAllFiles>true</ShowAllFiles>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+</Project>

Code/Game/LevelLoader/LevelParser.cpp

@@ -0,0 +1,318 @@
+/////////////////////////////////////
+// Created by Pontus Fransson 2013 //
+/////////////////////////////////////
+
+#include "LevelParser.h"
+
+#include "Loader.h"
+#include "ParseFunctions.h"
+
+using namespace GameLogic;
+using namespace ::LevelFileLoader;
+using namespace Utility::DynamicMemory;
+
+LevelParser::LevelParser()
+{
+	formatVersion.formatVersionMajor = 3;
+	formatVersion.formatVersionMinor = 0;
+}
+
+LevelParser::~LevelParser()
+{
+}
+
+std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filename)
+{
+	int bufferSize = 0;
+	int counter = 0;
+	bool loadCgf;
+
+	std::vector<SmartPointer<ObjectTypeHeader>> objects;
+
+	//Read entire level file.
+	Loader loader;
+	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
+
+	if(buffer)
+	{
+		//Read format version
+		LevelLoaderInternal::FormatVersion levelFormatVersion;
+		ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
+		counter += sizeof(levelFormatVersion);
+		if(this->formatVersion != levelFormatVersion)
+		{
+			//Returns an empty vector, because it will most likely fail to read the level format.
+			return objects;
+		}
+
+  		while(counter < bufferSize)
+		{
+			loadCgf = true;
+			//Get typeID
+			ObjectType typeID;
+			ParseObject(&buffer[counter], &typeID, sizeof(typeID));
+			switch((int)typeID)
+			{
+				case ObjectType_LevelMetaData:
+				{
+					SmartPointer<ObjectTypeHeader> header = new LevelMetaData;
+					ParseLevelMetaData(&buffer[counter], *(LevelMetaData*)header.Get(), counter);
+					objects.push_back(header);
+					break;
+				}
+
+				case ObjectType_SpawnPoint:
+				{
+					loadCgf = false;
+					ObjectHeader* header = new ObjectHeader;
+					ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+					SpawnPointAttributes* spawn = new SpawnPointAttributes;
+
+					spawn->typeID = header->typeID;
+
+					for(int i = 0; i < 3; i++)
+					{
+						spawn->position[i] = header->position[i];
+					}
+
+					delete header;
+					//objects.push_back(header);
+					objects.push_back(spawn);
+					break;
+				}
+
+				//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them. 
+				//Unless they are changed to not be the same.
+				case ObjectType_Static: case ObjectType_Dynamic:
+				{
+					//Get specialType.
+					ObjectSpecialType specialType;
+					ParseObject(&buffer[counter+4], &specialType, sizeof(typeID));
+
+					switch(specialType)
+					{
+						//there is no difference when parsing these specialTypes.
+						case ObjectSpecialType_CrystalShard:
+						case ObjectSpecialType_CrystalFormation:
+						case ObjectSpecialType_Spike:
+						case ObjectSpecialType_SpikeBox:
+						case ObjectSpecialType_RedExplosiveBox:
+						case ObjectSpecialType_StandardBox:
+						case ObjectSpecialType_Stone:
+						case ObjectSpecialType_Building:
+						{
+							ObjectHeader* header = new ObjectHeader;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+							objects.push_back(header);
+
+							break;
+						}
+
+						case ObjectSpecialType_JumpPad:
+						{
+							JumpPadAttributes* header = new JumpPadAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							//Read the spec
+							ParseObject(&buffer[counter], header->direction, 16);
+							counter += 16;
+							objects.push_back(header);
+
+							break;
+						}
+		
+						case ObjectSpecialType_Portal:
+						{
+							PortalAttributes* header = new PortalAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							ParseObject(&buffer[counter], header->destination, 12);
+							counter += 12;
+							objects.push_back(header);
+
+							break;
+						}
+					
+						case ObjectSpecialType_World:
+						{
+							WorldAttributes* header = new WorldAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							ParseObject(&buffer[counter], &header->worldSize, 8);
+							counter += 8;
+							objects.push_back(header);
+							break;
+						}
+
+						case ObjectSpecialType_Sky:
+						{
+							loadCgf = false; 
+							SkyAttributes* header = new SkyAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							ParseObject(&buffer[counter], &header->skySize, 4);
+							counter += 4;
+							objects.push_back(header);
+							break;
+						}
+						//this is a hotfix, fix so you only load the relevant data when the file is updated
+						default:
+							//Couldn't find specialType
+							break;
+					}
+					break;
+				}
+			
+				case ObjectType_Light:
+				{
+					LightType lightType;
+
+					//Get Light type
+					ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
+
+					//We only support PointLight for now.
+					BasicLight* header = new BasicLight;
+					ParseObject(&buffer[counter], header, sizeof(*header));
+					counter += sizeof(*header);
+					objects.push_back(header);
+					/*switch(lightType)
+					{
+					case LightType_PointLight:
+					{
+						PointLight* header = new PointLight;
+						ParseObject(&buffer[counter], header, sizeof(*header));
+						counter += sizeof(*header);
+						objects.push_back(header);
+						break;
+					}
+					case LightType_DirectionalLight:
+					{
+						DirectionalLight* header = new DirectionalLight;
+						ParseObject(&buffer[counter], header, sizeof(*header));
+						counter += sizeof(*header);
+						objects.push_back(header);
+						break;
+					}
+					case LightType_SpotLight:
+					{
+						SpotLight* header = new SpotLight;
+						ParseObject(&buffer[counter], header, sizeof(*header));
+						counter += sizeof(*header);
+						objects.push_back(header);
+						break;
+					}
+					default:
+						//Undefined LightType.
+						break;
+					}
+					break;*/
+				}
+				default:
+					//Couldn't find typeID. FAIL!!!!!!
+					break;
+			}
+		}
+	}
+
+	return objects;
+}
+
+//för meta information om leveln.
+LevelMetaData LevelParser::ParseHeader(std::string filename)
+{
+	int bufferSize = 0;
+	int counter = 0;
+
+	LevelMetaData levelHeader;
+	levelHeader.typeID = ObjectType::ObjectType_Unknown;
+
+	//Read entire level file.
+	Loader loader;
+	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
+
+	//Read format version
+	LevelLoaderInternal::FormatVersion levelFormatVersion;
+	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(formatVersion));
+	counter += sizeof(levelFormatVersion);
+	if(this->formatVersion != levelFormatVersion)
+	{
+		//Do something if it's not the same version
+
+		//Returns an empty levelHeader with ObjectType_Unknown.
+		//Because it will not be able to read another version of the level format.
+		return levelHeader;
+	}
+
+	//Find the header in the returned string.
+	while(counter < bufferSize)
+	{
+		ObjectType typeID;
+		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
+
+		switch(typeID)
+		{
+		case ObjectType_LevelMetaData:
+			ParseLevelMetaData(&buffer[counter], levelHeader, counter);
+			return levelHeader;
+			break;
+		
+			//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them.
+		case ObjectType_Static: case ObjectType_Dynamic:
+		{
+			ObjectHeader header;
+			ParseObject(&buffer[counter], &header, counter);
+
+			switch(header.specialTypeID)
+			{
+			case ObjectSpecialType_JumpPad:
+				counter += sizeof(16);
+				break;
+			case ObjectSpecialType_Portal:
+				counter += sizeof(12);
+				break;
+			default:
+				break;
+			}	
+			break;
+		}
+
+		case ObjectType_Light:
+		{
+			LightType lightType;
+			ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
+
+			//We only support pointlight for now.
+			counter += sizeof(BasicLight);
+			/*
+			switch(lightType)
+			{
+			case LightType_PointLight:
+			{
+				counter += sizeof(PointLight);
+				break;
+			}
+			case LightType_DirectionalLight:
+			{
+				counter += sizeof(DirectionalLight);
+				break;
+			}
+			case LightType_SpotLight:
+			{
+				counter += sizeof(SpotLight);
+				break;
+			}
+			default:
+				//Undefined LightType.
+				break;
+			}*/
+		}
+
+		default:
+			//Couldn't find typeID. FAIL!!!!!!
+			break;
+		}
+	}
+
+	return levelHeader;
+}

Code/Game/LevelLoader/ObjectDefines.h

@@ -31,7 +31,7 @@ namespace GameLogic
 		ObjectSpecialType_World,		//Always the main celestial body
 		ObjectSpecialType_Building,
 		ObjectSpecialType_Stone,
-		ObjectSpecialType_StandarsBox,
+		ObjectSpecialType_StandardBox,
 		ObjectSpecialType_RedExplosiveBox,
 		ObjectSpecialType_SpikeBox,
 		ObjectSpecialType_Spike,
@@ -40,6 +40,7 @@ namespace GameLogic
 		ObjectSpecialType_JumpPad,
 		ObjectSpecialType_Portal,
 		ObjectSpecialType_Player,
+		ObjectSpecialType_Generic,
 		
 
 		ObjectSpecialType_Count,

Code/Game/LevelLoader/ParseFunctions.cpp

@@ -117,7 +117,7 @@ namespace GameLogic
 
 			int temp;
 
-			for(int i = 0; i < tempSize; i++)
+			for(int i = 0; i < (int)tempSize; i++)
 			{
 				memcpy(&temp, &buffer[start], 4);
 				start += 4;
@@ -152,10 +152,9 @@ namespace GameLogic
 			start = 0;
 			LevelLoaderInternal::FormatVersion version;
 			memcpy(&version, &buf[0], sizeof(version));
-			start += 4;
+			start += 8;
 
 			memcpy(&volume.geoType, &buf[start], sizeof(volume.geoType));
-			start += sizeof(volume.geoType);
 
 			switch(volume.geoType)
 			{

Code/Misc/Input/L_inputClass.h

@@ -7,6 +7,7 @@
 #ifndef _INPUTCLASS_H_
 #define _INPUTCLASS_H_
 
+#define NOMINMAX
 #define DIRECTINPUT_VERSION 0x0800
 
 #pragma comment(lib, "dinput8.lib")

Code/Misc/OysterMath/Quaternion.h

@@ -49,7 +49,16 @@ namespace LinearAlgebra
 		Quaternion<ScalarType>   operator  - ( const Quaternion<ScalarType> &quaternion ) const;
 		Quaternion<ScalarType>   operator  - ( ) const;
 
+		Quaternion<ScalarType> & Conjugate( );
+		Quaternion<ScalarType> & Normalize( );
+		Quaternion<ScalarType> & Inverse( );
+
 		Quaternion<ScalarType> GetConjugate( ) const;
+		Quaternion<ScalarType> GetNormalized( ) const;
+		Quaternion<ScalarType> GetInversed( ) const;
+		ScalarType			   GetNorm( ) const;
+		ScalarType			   GetModulus( ) const;
+
 	};
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -205,11 +214,54 @@ namespace LinearAlgebra
 		return Quaternion<ScalarType>(-this->imaginary, -this->real);
 	}
 
+	template<typename ScalarType>
+	inline Quaternion<ScalarType> & Quaternion<ScalarType>::Conjugate( )
+	{
+		this->imaginary = -this->imaginary;
+		return *this;
+	}
+
+	template<typename ScalarType>
+	inline Quaternion<ScalarType> & Quaternion<ScalarType>::Normalize( )
+	{
+		return *this /= this->GetModulus();
+	}
+
+	template<typename ScalarType>
+	inline Quaternion<ScalarType> & Quaternion<ScalarType>::Inverse( )
+	{
+		return this->Conjugate() /= this->GetNorm();
+	}
+
 	template<typename ScalarType>
 	inline Quaternion<ScalarType> Quaternion<ScalarType>::GetConjugate( ) const
 	{
 		return Quaternion<ScalarType>(-this->imaginary, this->real );
 	}
+
+	template<typename ScalarType>
+	inline Quaternion<ScalarType> Quaternion<ScalarType>::GetNormalized( ) const
+	{
+		return *this / this->GetModulus();
+	}
+
+	template<typename ScalarType>
+	inline Quaternion<ScalarType> Quaternion<ScalarType>::GetInversed( ) const
+	{
+		return this->GetConjugate() /= this->GetNorm();
+	}
+
+	template<typename ScalarType>
+	inline ScalarType Quaternion<ScalarType>::GetNorm( ) const
+	{
+		return this->imaginary.Dot(this->imaginary) + this->real * this->real;
+	}
+
+	template<typename ScalarType>
+	inline ScalarType Quaternion<ScalarType>::GetModulus( ) const
+	{
+		return (ScalarType)::std::sqrt( this->GetNorm() );
+	}
 }
 
 #endif

Code/Misc/Utilities/Utilities.h

@@ -337,11 +337,7 @@ namespace Utility
 
 		template<typename ValueType>
 		inline ValueType Clamp( const ValueType &value, const ValueType &min, const ValueType &max )
-		{
+		{ return value < min ? Max( value, max ) : min; }
-			if( value < min ) return min;
-			if( value > max ) return max;
-			return value;
-		}
 
 		template<typename ValueType>
 		inline ValueType Average( const ValueType &valueA, const ValueType &valueB )

Code/Network/NetworkAPI/NetworkClient.cpp

@@ -290,9 +290,12 @@ bool NetworkClient::Connect(ConnectionInfo& socket)
 
 bool NetworkClient::Connect(unsigned short port, const char serverIP[])
 {
-	if(this->IsConnected())	return false;
+	//Return true if you are already connected.
-	if(this->privateData)	return false;
+	if(this->IsConnected())
-	if(!this->privateData)	this->privateData = new PrivateData();
+		return true;
+
+	if(!this->privateData)
+		this->privateData = new PrivateData();
 	
 	int result = this->privateData->connection.Connect(port, serverIP, false);
 	
@@ -317,15 +320,35 @@ bool NetworkClient::Connect(unsigned short port, std::wstring serverIP)
 	return this->Connect(port, ip.c_str());
 }
 
+bool NetworkClient::Reconnect()
+{
+	//Return true if you are already connected.
+	if(this->IsConnected())	
+		return true;
+
+	if(!this->privateData)	this->privateData = new PrivateData();
+
+	int result = this->privateData->connection.Reconnect();
+
+	if(result != 0)
+	{
+		return false;
+	}
+	this->privateData->owner = 0;
+	this->privateData->parent = this;
+	this->privateData->thread.Start();
+
+	return true;
+}
+
 void NetworkClient::Disconnect()
 {
 	if(!privateData) return;
 
-	privateData->thread.Terminate();
+	privateData->thread.Stop();
 	privateData->connection.Disconnect();
 	this->privateData->sendQueue.Clear();
 	this->privateData->recieveQueue.Clear();
-
 }
 
 void NetworkClient::Send(CustomProtocolObject& protocol)

Code/Network/NetworkAPI/NetworkClient.h

@@ -93,6 +93,11 @@ namespace Oyster
 				*/
 				bool Connect(unsigned short port, std::wstring serverIP);
 
+				/**Tries to connect with the same port and ip it earlier used for Connect.
+				*	
+				*/
+				bool Reconnect();
+
 				/**
 				*	
 				*/

Code/Network/NetworkDependencies/Connection.cpp

@@ -58,6 +58,9 @@ int Connection::Connect(unsigned short port , const char serverName[], bool bloc
 {
 	if(this->socket == -1 || this->socket == 0) InitiateSocket();
 
+	lastConnectPort = port;
+	lastConnectAddr = serverName;
+
 	struct hostent *hostEnt;
 	if((hostEnt = gethostbyname(serverName)) == NULL)
 	{
@@ -83,6 +86,37 @@ int Connection::Connect(unsigned short port , const char serverName[], bool bloc
 	return 0;
 }
 
+int Connection::Reconnect()
+{
+	if(this->socket == -1 || this->socket == 0) InitiateSocket();
+
+	struct hostent *hostEnt;
+	if((hostEnt = gethostbyname(this->lastConnectAddr.c_str())) == NULL)
+	{
+		return WSAGetLastError();
+	}
+
+	struct sockaddr_in server;
+	server.sin_family = AF_INET;
+	server.sin_port = htons(this->lastConnectPort);
+	server.sin_addr.s_addr = *(unsigned long*) hostEnt->h_addr;
+
+	SetBlockingMode(true);
+
+	if(connect(this->socket, (sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
+	{
+		return WSAGetLastError();
+	}
+	
+	closed = false;
+	stillSending = true;
+
+	SetBlockingMode(blocking);
+
+	//connection succesfull!
+	return 0;
+}
+
 int Connection::InitiateServer(unsigned short port)
 {
 	int errorCode = 0;

Code/Network/NetworkDependencies/Connection.h

@@ -28,6 +28,7 @@ namespace Oyster
 			virtual int Disconnect();
 			virtual int Connect(ConnectionInfo info, bool blocking = false);
 			virtual int Connect(unsigned short port , const char serverName[], bool blocking = false);
+			virtual int Reconnect();
 			
 			virtual ConnectionInfo Listen();
 
@@ -47,6 +48,11 @@ namespace Oyster
 			bool stillSending;
 			bool closed;
 			std::string addr;
+
+			std::string lastConnectAddr;
+			unsigned short lastConnectPort;
+
+			bool blocking;
 		};
 	}
 }

Code/Network/NetworkDependencies/IConnection.h

@@ -39,6 +39,9 @@ namespace Oyster
 			//(servers uses Listen instead of connect)
 			virtual int Connect( unsigned short port, const char serverName[] ) { return false; };
 
+			//Tries to connect with the same port and ip used for Connect.
+			virtual int Reconnect() = 0;
+
 			//Disconnects the client or server TODO: optimize!
 			virtual int Disconnect() = 0;
 		};

Code/OysterGraphics/DllInterfaces/GFXAPI.cpp

@@ -24,6 +24,8 @@ namespace Oyster
 			Model::Model* sphere;
 
 			ID3D11RasterizerState* wire;
+
+			ID3D11ShaderResourceView* debugSRV;
 #endif
 		}
 
@@ -50,8 +52,15 @@ namespace Oyster
 			Render::Preparations::Basic::SetViewPort();
 #ifdef _DEBUG
 			//fix load model
-			cube = CreateModel(L"debug_cube.dan");
+			
-			sphere = CreateModel(L"debug_sphere.dan");
+			debugSRV = (ID3D11ShaderResourceView*)API::CreateTexture(L"color_white.png");
+			debugSRV = (ID3D11ShaderResourceView*)API::CreateTexture(L"color_white.png");
+
+			cube = CreateModel(L"generic_cube.dan");
+			cube->Tint = Math::Float3(0.0f,0.0f,1.0f);
+			sphere = CreateModel(L"generic_sphere.dan");
+			sphere->Tint = Math::Float3(1.0f,0.5f,182/255.0f);
+
 
 			D3D11_RASTERIZER_DESC desc;
 			desc.CullMode = D3D11_CULL_BACK;
@@ -196,6 +205,7 @@ namespace Oyster
 
 		void API::StartRenderWireFrame()
 		{
+			Core::deviceContext->OMSetRenderTargets(Render::Resources::Gather::Pass.RTV.size(),&Render::Resources::Gather::Pass.RTV[0],NULL);
 			Core::deviceContext->RSSetState(wire);
 			Core::deviceContext->OMSetRenderTargets(Render::Resources::Gather::Pass.RTV.size(),&Render::Resources::Gather::Pass.RTV[0],NULL);
 		}

Code/OysterGraphics/FileLoader/ModelLoader.cpp

@@ -700,7 +700,7 @@ static HRESULT CreateTextureFromWIC( _In_ ID3D11Device* d3dDevice,
 				return hr;
 			}
 			//todo check calc
-			int TexSize = twidth * theight * bpp;
+			int TexSize = twidth * theight * (int)bpp;
 			Oyster::Graphics::Core::UsedMem += TexSize;
 
 			if ( autogen )

Code/OysterGraphics/OysterGraphics.vcxproj.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ShowAllFiles>false</ShowAllFiles>
+    <ShowAllFiles>true</ShowAllFiles>
   </PropertyGroup>
 </Project>

Code/Physics/Bullet Source/BulletFileLoader/CMakeLists.txt

@@ -0,0 +1,49 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src  
+)
+
+SET(BulletFileLoader_SRCS
+bChunk.cpp
+bDNA.cpp
+bFile.cpp
+btBulletFile.cpp
+)
+
+SET(BulletFileLoader_HDRS
+bChunk.h
+bCommon.h
+bDefines.h
+bDNA.h
+bFile.h
+btBulletFile.h
+)
+
+ADD_LIBRARY(BulletFileLoader ${BulletFileLoader_SRCS} ${BulletFileLoader_HDRS})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES VERSION ${BULLET_VERSION}) 
+SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (INSTALL_EXTRA_LIBS)
+        IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+                #FILES_MATCHING requires CMake 2.6
+                IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+                        IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                                INSTALL(TARGETS BulletFileLoader DESTINATION .)
+                        ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                                INSTALL(TARGETS BulletFileLoader DESTINATION lib${LIB_SUFFIX})
+                                INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+                        ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+                IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                        SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES FRAMEWORK true)
+                        SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES PUBLIC_HEADER "${BulletFileLoader_HDRS}")
+                ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+        ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Code/Physics/Bullet Source/BulletFileLoader/bChunk.cpp

@@ -0,0 +1,75 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "bChunk.h"
+#include "bDefines.h"
+#include "bFile.h"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+short ChunkUtils::swapShort(short sht)
+{
+	SWITCH_SHORT(sht);
+	return sht;
+}
+
+// ----------------------------------------------------- //
+int ChunkUtils::swapInt(int inte)
+{
+	SWITCH_INT(inte);
+	return inte;
+}
+
+// ----------------------------------------------------- //
+long64 ChunkUtils::swapLong64(long64 lng)
+{
+	SWITCH_LONGINT(lng);
+	return lng;
+}
+
+// ----------------------------------------------------- //
+int ChunkUtils::getOffset(int flags)
+{
+	// if the file is saved in a
+	// different format, get the
+	// file's chunk size
+	int res = CHUNK_HEADER_LEN;
+
+	if (VOID_IS_8)
+	{
+		if (flags &FD_BITS_VARIES)
+			res = sizeof(bChunkPtr4);
+	}
+	else
+	{
+		if (flags &FD_BITS_VARIES)
+			res = sizeof(bChunkPtr8);
+	}
+	return res;
+}
+
+
+
+
+
+//eof

Code/Physics/Bullet Source/BulletFileLoader/bChunk.h

@@ -0,0 +1,92 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCHUNK_H__
+#define __BCHUNK_H__
+
+#if defined (_WIN32) && ! defined (__MINGW32__)
+	#define long64 __int64
+#elif defined (__MINGW32__)	
+	#include <stdint.h>
+	#define long64 int64_t
+#else
+	#define long64 long long
+#endif
+
+
+namespace bParse {
+
+
+	// ----------------------------------------------------- //
+	class bChunkPtr4
+	{
+	public:
+		bChunkPtr4(){}
+		int code;
+		int len;
+		union
+		{
+			int m_uniqueInt;
+		};
+		int dna_nr;
+		int nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkPtr8
+	{
+	public:
+		bChunkPtr8(){}
+		int code,  len;
+		union
+		{
+			long64 oldPrev;
+			int	m_uniqueInts[2];
+		};
+		int dna_nr, nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkInd
+	{
+	public:
+		bChunkInd(){}
+		int code, len;
+		void *oldPtr;
+		int dna_nr, nr;
+	};
+
+
+	// ----------------------------------------------------- //
+	class ChunkUtils
+	{
+	public:
+		
+		// file chunk offset
+		static int getOffset(int flags);
+
+		// endian utils
+		static short swapShort(short sht);
+		static int swapInt(int inte);
+		static long64 swapLong64(long64 lng);
+
+	};
+
+
+	const int CHUNK_HEADER_LEN = ((sizeof(bChunkInd)));
+	const bool VOID_IS_8 = ((sizeof(void*)==8));
+}
+
+#endif//__BCHUNK_H__

Code/Physics/Bullet Source/BulletFileLoader/bCommon.h

@@ -0,0 +1,39 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCOMMON_H__
+#define __BCOMMON_H__
+
+
+#include <assert.h>
+//#include "bLog.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+namespace bParse {
+
+	class bMain;
+	class bFileData;
+	class bFile;
+	class bDNA;
+
+	// delete void* undefined
+	typedef struct bStructHandle {int unused;}bStructHandle;
+	typedef btAlignedObjectArray<bStructHandle*>	bListBasePtr;
+	typedef btHashMap<btHashPtr, bStructHandle*> bPtrMap;
+}
+
+
+#endif//__BCOMMON_H__

Code/Physics/Bullet Source/BulletFileLoader/bDNA.cpp

@@ -0,0 +1,644 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#include <assert.h>
+
+#include "bDNA.h"
+#include "bChunk.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+//this define will force traversal of structures, to check backward (and forward) compatibility
+//#define TEST_BACKWARD_FORWARD_COMPATIBILITY
+
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+bDNA::bDNA()
+	:	mPtrLen(0)
+{
+	// --
+}
+
+// ----------------------------------------------------- //
+bDNA::~bDNA()
+{
+	// --
+}
+
+// ----------------------------------------------------- //
+bool bDNA::lessThan(bDNA *file)
+{
+	return ( m_Names.size() < file->m_Names.size());
+}
+
+// ----------------------------------------------------- //
+char *bDNA::getName(int ind)
+{
+	assert(ind <= (int)m_Names.size());
+	return m_Names[ind].m_name;
+}
+
+
+// ----------------------------------------------------- //
+char *bDNA::getType(int ind)
+{
+	assert(ind<=  (int)mTypes.size());
+	return mTypes[ind];
+}
+
+
+// ----------------------------------------------------- //
+short *bDNA::getStruct(int ind)
+{
+	assert(ind <=  (int)mStructs.size());
+	return mStructs[ind];
+}
+
+
+// ----------------------------------------------------- //
+short bDNA::getLength(int ind)
+{
+	assert(ind <=  (int)mTlens.size());
+	return mTlens[ind];
+}
+
+
+// ----------------------------------------------------- //
+int bDNA::getReverseType(short type)
+{
+
+	int* intPtr = mStructReverse.find(type);
+	if (intPtr)
+		return *intPtr;
+
+	return -1;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getReverseType(const char *type)
+{
+
+	btHashString key(type);
+	int* valuePtr = mTypeLookup.find(key);
+	if (valuePtr)
+		return *valuePtr;
+	
+	return -1;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getNumStructs()
+{
+	return (int)mStructs.size();
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagNotEqual(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	return mCMPFlags[dna_nr] == FDF_STRUCT_NEQU;
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagEqual(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	int flag = mCMPFlags[dna_nr];
+	return  flag == FDF_STRUCT_EQU;
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagNone(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	return mCMPFlags[dna_nr] == FDF_NONE;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getPointerSize()
+{
+	return mPtrLen;
+}
+
+// ----------------------------------------------------- //
+void bDNA::initRecurseCmpFlags(int iter)
+{
+	// iter is FDF_STRUCT_NEQU
+
+	short *oldStrc = mStructs[iter];
+	short type = oldStrc[0];
+
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		if (i != iter && mCMPFlags[i] == FDF_STRUCT_EQU )
+		{
+			short *curStruct = mStructs[i];
+			int eleLen = curStruct[1];
+			curStruct+=2;
+
+			for (int j=0; j<eleLen; j++, curStruct+=2)
+			{
+				if (curStruct[0] == type)
+				{
+					//char *name = m_Names[curStruct[1]].m_name;
+					//if (name[0] != '*')
+					if (m_Names[curStruct[1]].m_isPointer)
+					{
+						mCMPFlags[i] = FDF_STRUCT_NEQU;
+						initRecurseCmpFlags(i);
+					}
+				}
+			}
+		}
+	}
+}
+
+// ----------------------------------------------------- //
+void bDNA::initCmpFlags(bDNA *memDNA)
+{
+
+    // compare the file to memory
+	// this ptr should be the file data
+
+
+	assert(!m_Names.size() == 0 && "SDNA empty!");
+	mCMPFlags.resize(mStructs.size(), FDF_NONE);
+
+
+
+	int i;
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+		//char* typeName = mTypes[oldStruct[0]];
+
+//#define SLOW_FORWARD_COMPATIBLE 1
+#ifdef SLOW_FORWARD_COMPATIBLE
+		char* typeName = mTypes[oldLookup];
+		int newLookup = memDNA->getReverseType(typeName);
+		if (newLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+		short *curStruct = memDNA->mStructs[newLookup];
+#else
+		// memory for file
+
+		if (oldLookup < memDNA->mStructs.size())
+		{
+			short *curStruct = memDNA->mStructs[oldLookup];
+#endif	
+	
+		
+
+			// rebuild...
+			mCMPFlags[i] = FDF_STRUCT_NEQU;
+
+#ifndef TEST_BACKWARD_FORWARD_COMPATIBILITY
+
+			if (curStruct[1] == oldStruct[1])
+			{
+				// type len same ...
+				if (mTlens[oldStruct[0]] == memDNA->mTlens[curStruct[0]])
+				{
+					bool isSame = true;
+					int elementLength = oldStruct[1];
+
+
+					curStruct+=2;
+					oldStruct+=2;
+
+
+					for (int j=0; j<elementLength; j++, curStruct+=2, oldStruct+=2)
+					{
+						// type the same
+						//const char* typeFileDNA = mTypes[oldStruct[0]];
+						//const char* typeMemDNA = mTypes[curStruct[0]];
+						if (strcmp(mTypes[oldStruct[0]], memDNA->mTypes[curStruct[0]])!=0)
+						{
+							isSame=false;
+							break;
+						}
+
+						// name the same
+						if (strcmp(m_Names[oldStruct[1]].m_name, memDNA->m_Names[curStruct[1]].m_name)!=0)
+						{
+							isSame=false;
+							break;
+						}
+					}
+					// flag valid ==
+					if (isSame)
+						mCMPFlags[i] = FDF_STRUCT_EQU;
+				}
+			}
+#endif
+		}
+	}
+
+
+
+
+
+	// recurse in
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		if (mCMPFlags[i] == FDF_STRUCT_NEQU)
+			initRecurseCmpFlags(i);
+	}
+}
+
+
+
+
+static int name_is_array(char* name, int* dim1, int* dim2) {
+	int len = strlen(name);
+	/*fprintf(stderr,"[%s]",name);*/
+	/*if (len >= 1) {
+	if (name[len-1] != ']')
+	return 1;
+	}
+	return 0;*/
+	char *bp;
+	int num;
+	if (dim1) {
+		*dim1 = 1;
+	}
+	if (dim2) {
+		*dim2 = 1;
+	}
+	bp = strchr(name, '[');
+	if (!bp) {
+		return 0;
+	}
+	num = 0;
+	while (++bp < name+len-1) {
+		const char c = *bp;
+		if (c == ']') {
+			break;
+		}
+		if (c <= '9' && c >= '0') {
+			num *= 10;
+			num += (c - '0');
+		} else {
+			printf("array parse error.\n");
+			return 0;
+		}
+	}
+	if (dim2) {
+		*dim2 = num;
+	}
+
+	/* find second dim, if any. */
+	bp = strchr(bp, '[');
+	if (!bp) {
+		return 1; /* at least we got the first dim. */
+	}
+	num = 0;
+	while (++bp < name+len-1) {
+		const char c = *bp;
+		if (c == ']') {
+			break;
+		}
+		if (c <= '9' && c >= '0') {
+			num *= 10;
+			num += (c - '0');
+		} else {
+			printf("array2 parse error.\n");
+			return 1;
+		}
+	}
+	if (dim1) {
+		if (dim2) {
+			*dim1 = *dim2;
+			*dim2 = num;
+		} else {
+			*dim1 = num;
+		}
+	}
+
+	return 1;
+}
+
+
+// ----------------------------------------------------- //
+void bDNA::init(char *data, int len, bool swap)
+{
+	int *intPtr=0;short *shtPtr=0;
+	char *cp = 0;int dataLen =0;long nr=0;
+	intPtr = (int*)data;
+
+	/*
+		SDNA (4 bytes) (magic number)
+		NAME (4 bytes)
+		<nr> (4 bytes) amount of names (int)
+		<string>
+		<string>
+	*/
+
+	if (strncmp(data, "SDNA", 4)==0)
+	{
+		// skip ++ NAME
+		intPtr++; intPtr++;
+	}
+
+
+
+	// Parse names
+	if (swap) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+	cp = (char*)intPtr;
+	int i;
+	for ( i=0; i<dataLen; i++)
+	{
+		bNameInfo info;
+		info.m_name = cp;
+		info.m_isPointer = (info.m_name[0] == '*') || (info.m_name[1] == '*');
+		name_is_array(info.m_name,&info.m_dim0,&info.m_dim1);
+		m_Names.push_back(info);
+		while (*cp)cp++;
+		cp++;
+	}
+
+	
+	{
+		nr= (long)cp;
+	//long mask=3;
+		nr= ((nr+3)&~3)-nr;
+		while (nr--)
+		{
+			cp++;
+		}
+	}
+
+
+	/*
+		TYPE (4 bytes)
+		<nr> amount of types (int)
+		<string>
+		<string>
+	*/
+
+	intPtr = (int*)cp;
+	assert(strncmp(cp, "TYPE", 4)==0); intPtr++;
+
+	if (swap) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+	cp = (char*)intPtr;
+	for ( i=0; i<dataLen; i++)
+	{
+		mTypes.push_back(cp);
+		while (*cp)cp++;
+		cp++;
+	}
+
+{
+		nr= (long)cp;
+	//	long mask=3;
+		nr= ((nr+3)&~3)-nr;
+		while (nr--)
+		{
+			cp++;
+		}
+	}
+
+
+	/*
+		TLEN (4 bytes)
+		<len> (short) the lengths of types
+		<len>
+	*/
+
+	// Parse type lens
+	intPtr = (int*)cp;
+	assert(strncmp(cp, "TLEN", 4)==0); intPtr++;
+
+	dataLen = (int)mTypes.size();
+
+	shtPtr = (short*)intPtr;
+	for ( i=0; i<dataLen; i++, shtPtr++)
+	{
+		if (swap)
+			shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
+		mTlens.push_back(shtPtr[0]);
+	}
+
+	if (dataLen & 1) shtPtr++;
+
+	/*
+		STRC (4 bytes)
+		<nr> amount of structs (int)
+		<typenr>
+		<nr_of_elems>
+		<typenr>
+		<namenr>
+		<typenr>
+		<namenr>
+	*/
+
+	intPtr = (int*)shtPtr;
+	cp = (char*)intPtr;
+	assert(strncmp(cp, "STRC", 4)==0); intPtr++;
+
+	if (swap) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+
+	shtPtr = (short*)intPtr;
+	for ( i=0; i<dataLen; i++)
+	{
+		mStructs.push_back (shtPtr);
+		if (swap)
+		{
+			shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
+			shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
+
+			int len = shtPtr[1];
+			shtPtr+= 2;
+
+			for (int a=0; a<len; a++, shtPtr+=2)
+			{
+				shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
+				shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
+			}
+		}
+		else
+			shtPtr+= (2*shtPtr[1])+2;
+	}
+
+
+	// build reverse lookups
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		short *strc = mStructs.at(i);
+		if (!mPtrLen && strcmp(mTypes[strc[0]],"ListBase")==0)
+		{
+			mPtrLen = mTlens[strc[0]]/2;
+		}
+
+		mStructReverse.insert(strc[0], i);
+		mTypeLookup.insert(btHashString(mTypes[strc[0]]),i);
+	}
+}
+
+
+// ----------------------------------------------------- //
+int bDNA::getArraySize(char* string)
+{
+	int ret = 1;
+	int len = strlen(string);
+
+	
+	char* next = 0;
+	for (int i=0; i<len; i++)
+	{
+		char c = string[i];
+
+		if (c == '[')
+			next = &string[i+1];
+		else if (c==']')
+			if (next)
+				ret *= atoi(next);
+	}
+
+//	print (string << ' ' << ret);
+	return ret;
+}
+
+
+void bDNA::dumpTypeDefinitions()
+{
+	int i;
+
+	int numTypes = mTypes.size();
+	
+	for (i=0;i<numTypes;i++)
+	{
+
+	}
+
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		int totalBytes=0;
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+
+		short* newStruct = mStructs[oldLookup];
+		char* typeName = mTypes[newStruct[0]];
+		printf("%3d: %s ",i,typeName);
+		
+		//char *name = mNames[oldStruct[1]];
+		int len = oldStruct[1];
+		printf(" (%d fields) ",len);
+		oldStruct+=2;
+
+		printf("{");
+		int j;
+		for (j=0; j<len; ++j,oldStruct+=2) {
+			const char* name = m_Names[oldStruct[1]].m_name;
+			printf("%s %s",	mTypes[oldStruct[0]],name);
+			int elemNumBytes= 0;
+			int arrayDimensions = getArraySizeNew(oldStruct[1]);
+
+			if (m_Names[oldStruct[1]].m_isPointer)
+			{
+				elemNumBytes = VOID_IS_8 ? 8 : 4;
+			} else
+			{
+				elemNumBytes = getLength(oldStruct[0]);
+			}
+			printf(" /* %d bytes */",elemNumBytes*arrayDimensions);
+			
+			if (j == len-1) {
+				printf(";}");
+			} else {
+				printf("; ");
+			}
+			totalBytes+=elemNumBytes*arrayDimensions;
+		}
+		printf("\ntotalBytes=%d\n\n",totalBytes);
+
+	}
+	
+
+
+#if 0
+	/* dump out display of types and their sizes */
+	for (i=0; i<bf->types_count; ++i) {
+		/* if (!bf->types[i].is_struct)*/
+		{
+			printf("%3d: sizeof(%s%s)=%d",
+				i,
+				bf->types[i].is_struct ? "struct " : "atomic ",
+				bf->types[i].name, bf->types[i].size);
+			if (bf->types[i].is_struct) {
+				int j;
+				printf(", %d fields: { ", bf->types[i].fieldtypes_count);
+				for (j=0; j<bf->types[i].fieldtypes_count; ++j) {
+					printf("%s %s",
+						bf->types[bf->types[i].fieldtypes[j]].name,
+						bf->names[bf->types[i].fieldnames[j]]);
+					if (j == bf->types[i].fieldtypes_count-1) {
+						printf(";}");
+					} else {
+						printf("; ");
+					}
+				}
+			}
+			printf("\n\n");
+
+		}
+	}
+#endif
+
+}
+
+
+
+
+//eof
+
+

Code/Physics/Bullet Source/BulletFileLoader/bDNA.h

@@ -0,0 +1,110 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BDNA_H__
+#define __BDNA_H__
+
+
+#include "bCommon.h"
+
+namespace bParse {
+
+	struct	bNameInfo
+	{
+		char*	m_name;
+		bool	m_isPointer;
+		int		m_dim0;
+		int		m_dim1;
+	};
+
+	class bDNA
+	{
+	public:
+		bDNA();
+		~bDNA();
+
+		void init(char *data, int len, bool swap=false);
+
+		int getArraySize(char* str);
+		int getArraySizeNew(short name)
+		{
+			const bNameInfo& nameInfo = m_Names[name];
+			return nameInfo.m_dim0*nameInfo.m_dim1;
+		}
+		int getElementSize(short type, short name)
+		{
+			const bNameInfo& nameInfo = m_Names[name];
+			int size = nameInfo.m_isPointer ? mPtrLen*nameInfo.m_dim0*nameInfo.m_dim1 : mTlens[type]*nameInfo.m_dim0*nameInfo.m_dim1;
+			return size;
+		}
+
+		int	getNumNames() const
+		{
+			return m_Names.size();
+		}
+
+		char *getName(int ind);
+		char *getType(int ind);
+		short *getStruct(int ind);
+		short getLength(int ind);
+		int getReverseType(short type);
+		int getReverseType(const char *type);
+
+
+		int getNumStructs();
+
+		//
+		bool lessThan(bDNA* other);
+
+		void initCmpFlags(bDNA *memDNA);
+		bool flagNotEqual(int dna_nr);
+		bool flagEqual(int dna_nr);
+		bool flagNone(int dna_nr);
+
+
+		int getPointerSize();
+
+		void	dumpTypeDefinitions();
+
+	
+	private:
+		enum FileDNAFlags
+		{
+			FDF_NONE=0,
+			FDF_STRUCT_NEQU,
+			FDF_STRUCT_EQU
+		};
+
+		void initRecurseCmpFlags(int i);
+
+		btAlignedObjectArray<int>			mCMPFlags;
+
+		btAlignedObjectArray<bNameInfo>			m_Names;
+		btAlignedObjectArray<char*>			mTypes;
+		btAlignedObjectArray<short*>			mStructs;
+		btAlignedObjectArray<short>			mTlens;
+		btHashMap<btHashInt, int>			mStructReverse;
+		btHashMap<btHashString,int>	mTypeLookup;
+
+		int							mPtrLen;
+		
+
+
+
+	};
+}
+
+
+#endif//__BDNA_H__

Code/Physics/Bullet Source/BulletFileLoader/bDefines.h

@@ -0,0 +1,140 @@
+/* Copyright (C) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef __B_DEFINES_H__
+#define __B_DEFINES_H__
+
+
+// MISC defines, see BKE_global.h, BKE_utildefines.h
+#define SIZEOFBLENDERHEADER 12
+
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
+#	define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
+#else
+#	define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
+#endif
+
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
+#	define MAKE_ID2(c, d) ( (c)<<8 | (d) )
+#	define MOST_SIG_BYTE   0
+#	define BBIG_ENDIAN
+#else
+#	define MAKE_ID2(c, d) ( (d)<<8 | (c) )
+#	define MOST_SIG_BYTE  1
+#	define BLITTLE_ENDIAN
+#endif
+
+// ------------------------------------------------------------
+#define ID_SCE		MAKE_ID2('S', 'C')
+#define ID_LI		MAKE_ID2('L', 'I')
+#define ID_OB		MAKE_ID2('O', 'B')
+#define ID_ME		MAKE_ID2('M', 'E')
+#define ID_CU		MAKE_ID2('C', 'U')
+#define ID_MB		MAKE_ID2('M', 'B')
+#define ID_MA		MAKE_ID2('M', 'A')
+#define ID_TE		MAKE_ID2('T', 'E')
+#define ID_IM		MAKE_ID2('I', 'M')
+#define ID_IK		MAKE_ID2('I', 'K')
+#define ID_WV		MAKE_ID2('W', 'V')
+#define ID_LT		MAKE_ID2('L', 'T')
+#define ID_SE		MAKE_ID2('S', 'E')
+#define ID_LF		MAKE_ID2('L', 'F')
+#define ID_LA		MAKE_ID2('L', 'A')
+#define ID_CA		MAKE_ID2('C', 'A')
+#define ID_IP		MAKE_ID2('I', 'P')
+#define ID_KE		MAKE_ID2('K', 'E')
+#define ID_WO		MAKE_ID2('W', 'O')
+#define ID_SCR		MAKE_ID2('S', 'R')
+#define ID_VF		MAKE_ID2('V', 'F')
+#define ID_TXT		MAKE_ID2('T', 'X')
+#define ID_SO		MAKE_ID2('S', 'O')
+#define ID_SAMPLE	MAKE_ID2('S', 'A')
+#define ID_GR		MAKE_ID2('G', 'R')
+#define ID_ID		MAKE_ID2('I', 'D')
+#define ID_AR		MAKE_ID2('A', 'R')
+#define ID_AC		MAKE_ID2('A', 'C')
+#define ID_SCRIPT	MAKE_ID2('P', 'Y')
+#define ID_FLUIDSIM	MAKE_ID2('F', 'S')
+#define ID_NT		MAKE_ID2('N', 'T')
+#define ID_BR		MAKE_ID2('B', 'R')
+
+
+#define ID_SEQ		MAKE_ID2('S', 'Q')
+#define ID_CO		MAKE_ID2('C', 'O')
+#define ID_PO		MAKE_ID2('A', 'C')
+#define ID_NLA		MAKE_ID2('N', 'L')
+
+#define ID_VS		MAKE_ID2('V', 'S')
+#define ID_VN		MAKE_ID2('V', 'N')
+
+
+// ------------------------------------------------------------
+#define FORM MAKE_ID('F','O','R','M')
+#define DDG1 MAKE_ID('3','D','G','1')
+#define DDG2 MAKE_ID('3','D','G','2')
+#define DDG3 MAKE_ID('3','D','G','3')
+#define DDG4 MAKE_ID('3','D','G','4')
+#define GOUR MAKE_ID('G','O','U','R')
+#define BLEN MAKE_ID('B','L','E','N')
+#define DER_ MAKE_ID('D','E','R','_')
+#define V100 MAKE_ID('V','1','0','0')
+#define DATA MAKE_ID('D','A','T','A')
+#define GLOB MAKE_ID('G','L','O','B')
+#define IMAG MAKE_ID('I','M','A','G')
+#define TEST MAKE_ID('T','E','S','T')
+#define USER MAKE_ID('U','S','E','R')
+
+
+// ------------------------------------------------------------
+#define DNA1 MAKE_ID('D','N','A','1')
+#define REND MAKE_ID('R','E','N','D')
+#define ENDB MAKE_ID('E','N','D','B')
+#define NAME MAKE_ID('N','A','M','E')
+#define SDNA MAKE_ID('S','D','N','A')
+#define TYPE MAKE_ID('T','Y','P','E')
+#define TLEN MAKE_ID('T','L','E','N')
+#define STRC MAKE_ID('S','T','R','C')
+
+
+// ------------------------------------------------------------
+#define SWITCH_INT(a) { \
+    char s_i, *p_i; \
+    p_i= (char *)&(a); \
+    s_i=p_i[0]; p_i[0]=p_i[3]; p_i[3]=s_i; \
+    s_i=p_i[1]; p_i[1]=p_i[2]; p_i[2]=s_i; }
+
+// ------------------------------------------------------------
+#define SWITCH_SHORT(a)	{ \
+    char s_i, *p_i; \
+	p_i= (char *)&(a); \
+	s_i=p_i[0]; p_i[0]=p_i[1]; p_i[1]=s_i; }
+
+// ------------------------------------------------------------
+#define SWITCH_LONGINT(a) { \
+    char s_i, *p_i; \
+    p_i= (char *)&(a);  \
+    s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \
+    s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \
+    s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \
+    s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; }
+
+#endif//__B_DEFINES_H__

Code/Physics/Bullet Source/BulletFileLoader/bFile.h

@@ -0,0 +1,165 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BFILE_H__
+#define __BFILE_H__
+
+#include "bCommon.h"
+#include "bChunk.h"
+#include <stdio.h>
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	enum bFileFlags
+	{
+		FD_INVALID   =0,
+		FD_OK        =1,
+		FD_VOID_IS_8 =2,
+		FD_ENDIAN_SWAP      =4,
+		FD_FILE_64   =8,
+		FD_BITS_VARIES    =16,
+		FD_VERSION_VARIES = 32,
+		FD_DOUBLE_PRECISION =64,
+		FD_BROKEN_DNA = 128
+	};
+
+	enum bFileVerboseMode
+	{
+		FD_VERBOSE_EXPORT_XML = 1,
+		FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS = 2,
+		FD_VERBOSE_DUMP_CHUNKS = 4,
+		FD_VERBOSE_DUMP_FILE_INFO=8,
+	};
+	// ----------------------------------------------------- //
+	class bFile
+	{
+	protected:
+		
+		char				m_headerString[7];
+
+		bool				mOwnsBuffer;
+		char*				mFileBuffer;
+		int					mFileLen;
+		int					mVersion;
+
+
+		bPtrMap				mLibPointers;
+
+		int					mDataStart;
+		bDNA*				mFileDNA;
+		bDNA*				mMemoryDNA;
+
+		btAlignedObjectArray<char*>	m_pointerFixupArray;
+		btAlignedObjectArray<char*>	m_pointerPtrFixupArray;
+		
+		btAlignedObjectArray<bChunkInd>	m_chunks;
+        btHashMap<btHashPtr, bChunkInd> m_chunkPtrPtrMap;
+
+        // 
+	
+		bPtrMap				mDataPointers;
+
+		
+		int					mFlags;
+
+		// ////////////////////////////////////////////////////////////////////////////
+
+			// buffer offset util
+		int getNextBlock(bChunkInd *dataChunk,  const char *dataPtr, const int flags);
+		void safeSwapPtr(char *dst, const char *src);
+
+		virtual	void parseHeader();
+		
+		virtual	void parseData() = 0;
+
+		void resolvePointersMismatch();
+		void resolvePointersChunk(const bChunkInd& dataChunk, int verboseMode);
+
+		int resolvePointersStructRecursive(char *strcPtr, int old_dna, int verboseMode, int recursion);
+		//void swapPtr(char *dst, char *src);
+
+		void parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers);
+		void getMatchingFileDNA(short* old, const char* lookupName, const char* lookupType, char *strcData, char *data, bool fixupPointers);
+		char* getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos);
+
+
+		void swap(char *head, class bChunkInd& ch, bool ignoreEndianFlag);
+		void swapData(char *data, short type, int arraySize, bool ignoreEndianFlag);
+		void swapStruct(int dna_nr, char *data, bool ignoreEndianFlag);
+		void swapLen(char *dataPtr);
+		void swapDNA(char* ptr);
+
+
+		char* readStruct(char *head, class bChunkInd& chunk);
+		char *getAsString(int code);
+
+		void	parseInternal(int verboseMode, char* memDna,int memDnaLength);
+
+	public:
+		bFile(const char *filename, const char headerString[7]);
+		
+		//todo: make memoryBuffer const char
+		//bFile( const char *memoryBuffer, int len);
+		bFile( char *memoryBuffer, int len, const char headerString[7]);
+		virtual ~bFile();
+
+		bDNA*				getFileDNA()
+		{
+			return mFileDNA;
+		}
+
+		virtual	void	addDataBlock(char* dataBlock) = 0;
+
+		int	getFlags() const
+		{
+			return mFlags;
+		}
+
+		bPtrMap&		getLibPointers()
+		{
+			return mLibPointers;
+		}
+		
+		void* findLibPointer(void *ptr);
+
+		bool ok();
+
+		virtual	void parse(int verboseMode) = 0;
+
+		virtual	int	write(const char* fileName, bool fixupPointers=false) = 0;
+
+		virtual	void	writeChunks(FILE* fp, bool fixupPointers );
+
+		virtual	void	writeDNA(FILE* fp) = 0;
+
+		void	updateOldPointers();
+		void	resolvePointers(int verboseMode);
+
+		void	dumpChunks(bDNA* dna);
+		
+		int		getVersion() const
+		{
+			return mVersion;
+		}
+		//pre-swap the endianness, so that data loaded on a target with different endianness doesn't need to be swapped
+		void preSwap();
+		void writeFile(const char* fileName);
+
+	};
+}
+
+
+#endif//__BFILE_H__

Code/Physics/Bullet Source/BulletFileLoader/btBulletFile.cpp

@@ -0,0 +1,423 @@
+/*
+bParse
+Copyright (c) 2006-2010 Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btBulletFile.h"
+#include "bDefines.h"
+#include "bDNA.h"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+
+// 32 && 64 bit versions
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+#ifdef _WIN64
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+#else
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+#endif //_WIN64
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+
+#endif //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+
+using namespace bParse;
+
+btBulletFile::btBulletFile()
+:bFile("", "BULLET ")
+{
+	mMemoryDNA = new bDNA(); //this memory gets released in the bFile::~bFile destructor,@todo not consistent with the rule 'who allocates it, has to deallocate it"
+
+	m_DnaCopy = 0;
+
+
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+#ifdef _WIN64
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
+#else//_WIN64
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
+#endif//_WIN64
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		m_DnaCopy = (char*) btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
+	}
+	else
+	{
+		m_DnaCopy =(char*) btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+}
+
+
+
+btBulletFile::btBulletFile(const char* fileName)
+:bFile(fileName, "BULLET ")
+{
+	m_DnaCopy = 0;
+}
+
+
+
+btBulletFile::btBulletFile(char *memoryBuffer, int len)
+:bFile(memoryBuffer,len, "BULLET ")
+{
+	m_DnaCopy = 0;
+}
+
+
+btBulletFile::~btBulletFile()
+{
+	if (m_DnaCopy)
+		btAlignedFree(m_DnaCopy);
+
+	
+	while (m_dataBlocks.size())
+	{
+		char* dataBlock = m_dataBlocks[m_dataBlocks.size()-1];
+		delete[] dataBlock;
+		m_dataBlocks.pop_back();
+	}
+
+}
+
+
+
+// ----------------------------------------------------- //
+void btBulletFile::parseData()
+{
+//	printf ("Building datablocks");
+//	printf ("Chunk size = %d",CHUNK_HEADER_LEN);
+//	printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));
+
+	const bool brokenDNA = (mFlags&FD_BROKEN_DNA)!=0;
+
+	//const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
+	
+
+	mDataStart = 12;
+
+	char *dataPtr = mFileBuffer+mDataStart;
+
+	bChunkInd dataChunk;
+	dataChunk.code = 0;
+
+
+	//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+	int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
+	
+	
+	if (mFlags &FD_ENDIAN_SWAP) 
+		swapLen(dataPtr);
+
+	//dataPtr += ChunkUtils::getOffset(mFlags);
+	char *dataPtrHead = 0;
+
+	while (dataChunk.code != DNA1)
+	{
+		if (!brokenDNA || (dataChunk.code != BT_QUANTIZED_BVH_CODE) )
+		{
+
+			// one behind
+			if (dataChunk.code == SDNA) break;
+			//if (dataChunk.code == DNA1) break;
+
+			// same as (BHEAD+DATA dependency)
+			dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+			if (dataChunk.dna_nr>=0)
+			{
+				char *id = readStruct(dataPtrHead, dataChunk);
+
+				// lookup maps
+				if (id)
+				{
+					m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
+					mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
+
+					m_chunks.push_back(dataChunk);
+					// block it
+					//bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
+					//if (listID)
+					//	listID->push_back((bStructHandle*)id);
+				}
+
+				if (dataChunk.code == BT_SOFTBODY_CODE)
+				{
+					m_softBodies.push_back((bStructHandle*) id);
+				}
+				
+				if (dataChunk.code == BT_RIGIDBODY_CODE)
+				{
+					m_rigidBodies.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_DYNAMICSWORLD_CODE)
+				{
+					m_dynamicsWorldInfo.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_CONSTRAINT_CODE)
+				{
+					m_constraints.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_QUANTIZED_BVH_CODE)
+				{
+					m_bvhs.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_TRIANLGE_INFO_MAP)
+				{
+					m_triangleInfoMaps.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_COLLISIONOBJECT_CODE)
+				{
+					m_collisionObjects.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_SHAPE_CODE)
+				{
+					m_collisionShapes.push_back((bStructHandle*) id);
+				}
+
+		//		if (dataChunk.code == GLOB)
+		//		{
+		//			m_glob = (bStructHandle*) id;
+		//		}
+			} else
+			{
+				printf("unknown chunk\n");
+
+				mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)dataPtrHead);
+			}
+		} else
+		{
+			printf("skipping BT_QUANTIZED_BVH_CODE due to broken DNA\n");
+		}
+
+		
+		dataPtr += seek;
+
+		seek =  getNextBlock(&dataChunk, dataPtr, mFlags);
+		if (mFlags &FD_ENDIAN_SWAP) 
+			swapLen(dataPtr);
+
+		if (seek < 0)
+			break;
+	}
+
+}
+
+void	btBulletFile::addDataBlock(char* dataBlock)
+{
+	m_dataBlocks.push_back(dataBlock);
+
+}
+
+
+
+
+void	btBulletFile::writeDNA(FILE* fp)
+{
+
+	bChunkInd dataChunk;
+	dataChunk.code = DNA1;
+	dataChunk.dna_nr = 0;
+	dataChunk.nr = 1;
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES	
+	if (VOID_IS_8)
+	{
+#ifdef _WIN64
+		dataChunk.len = sBulletDNAlen64;
+		dataChunk.oldPtr = sBulletDNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
+#else
+		btAssert(0);
+#endif
+	}
+	else
+	{
+#ifndef _WIN64
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+#else//_WIN64
+		btAssert(0);
+#endif//_WIN64
+	}
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		dataChunk.len = sBulletDNAlen64;
+		dataChunk.oldPtr = sBulletDNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
+	}
+	else
+	{
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+}
+
+
+void	btBulletFile::parse(int verboseMode)
+{
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+#ifdef _WIN64
+		
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		parseInternal(verboseMode,(char*)sBulletDNAstr64,sBulletDNAlen64);
+#else
+		btAssert(0);
+#endif
+	}
+	else
+	{
+#ifndef _WIN64
+
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
+#else
+		btAssert(0);
+#endif
+	}
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen64);
+	}
+	else
+	{
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	
+	//the parsing will convert to cpu endian
+	mFlags &=~FD_ENDIAN_SWAP;
+
+	int littleEndian= 1;
+	littleEndian= ((char*)&littleEndian)[0];
+	
+	mFileBuffer[8] = littleEndian?'v':'V';
+	
+}
+
+// experimental
+int		btBulletFile::write(const char* fileName, bool fixupPointers)
+{
+	FILE *fp = fopen(fileName, "wb");
+	if (fp)
+	{
+		char header[SIZEOFBLENDERHEADER] ;
+		memcpy(header, m_headerString, 7);
+		int endian= 1;
+		endian= ((char*)&endian)[0];
+
+		if (endian)
+		{
+			header[7] = '_';
+		} else
+		{
+			header[7] = '-';
+		}
+		if (VOID_IS_8)
+		{
+			header[8]='V';
+		} else
+		{
+			header[8]='v';
+		}
+
+		header[9] = '2';
+		header[10] = '7';
+		header[11] = '5';
+		
+		fwrite(header,SIZEOFBLENDERHEADER,1,fp);
+
+		writeChunks(fp, fixupPointers);
+
+		writeDNA(fp);
+
+		fclose(fp);
+		
+	} else
+	{
+		printf("Error: cannot open file %s for writing\n",fileName);
+		return 0;
+	}
+	return 1;
+}
+
+
+
+void	btBulletFile::addStruct(const	char* structType,void* data, int len, void* oldPtr, int code)
+{
+	
+	bParse::bChunkInd dataChunk;
+	dataChunk.code = code;
+	dataChunk.nr = 1;
+	dataChunk.len = len;
+	dataChunk.dna_nr = mMemoryDNA->getReverseType(structType);
+	dataChunk.oldPtr = oldPtr;
+
+	///Perform structure size validation
+	short* structInfo= mMemoryDNA->getStruct(dataChunk.dna_nr);
+	int elemBytes;
+	elemBytes= mMemoryDNA->getLength(structInfo[0]);
+//	int elemBytes = mMemoryDNA->getElementSize(structInfo[0],structInfo[1]);
+	assert(len==elemBytes);
+
+	mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)data);
+	m_chunks.push_back(dataChunk);
+}

Code/Physics/Bullet Source/BulletFileLoader/btBulletFile.h

@@ -0,0 +1,83 @@
+/*
+bParse
+Copyright (c) 2006-2010 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BULLET_FILE_H
+#define BT_BULLET_FILE_H
+
+
+#include "bFile.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "bDefines.h"
+
+#include "LinearMath/btSerializer.h"
+
+
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	class btBulletFile : public bFile
+	{
+		
+
+	protected:
+	
+		char*	m_DnaCopy;
+				
+	public:
+
+		btAlignedObjectArray<bStructHandle*>	m_softBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_rigidBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionObjects;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionShapes;
+
+		btAlignedObjectArray<bStructHandle*>	m_constraints;
+
+		btAlignedObjectArray<bStructHandle*>	m_bvhs;
+
+		btAlignedObjectArray<bStructHandle*>	m_triangleInfoMaps;
+
+		btAlignedObjectArray<bStructHandle*>	m_dynamicsWorldInfo;
+
+		btAlignedObjectArray<char*>				m_dataBlocks;
+		btBulletFile();
+
+		btBulletFile(const char* fileName);
+
+		btBulletFile(char *memoryBuffer, int len);
+
+		virtual ~btBulletFile();
+
+		virtual	void	addDataBlock(char* dataBlock);
+	
+
+		// experimental
+		virtual int		write(const char* fileName, bool fixupPointers=false);
+
+		virtual	void	parse(int verboseMode);
+
+		virtual	void parseData();
+
+		virtual	void	writeDNA(FILE* fp);
+
+		void	addStruct(const char* structType,void* data, int len, void* oldPtr, int code);
+
+	};
+};
+
+#endif //BT_BULLET_FILE_H

Code/Physics/Bullet Source/BulletFileLoader/premake4.lua

@@ -0,0 +1,12 @@
+	project "BulletFileLoader"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Code/Physics/Bullet Source/BulletWorldImporter/CMakeLists.txt

@@ -0,0 +1,40 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletFileLoader
+)
+
+ADD_LIBRARY(
+BulletWorldImporter 
+btBulletWorldImporter.cpp 
+btBulletWorldImporter.h 
+btWorldImporter.cpp 
+btWorldImporter.h 
+)
+
+SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES VERSION ${BULLET_VERSION})
+SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletWorldImporter BulletDynamics BulletCollision BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+IF (INSTALL_EXTRA_LIBS)
+	IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+		#FILES_MATCHING requires CMake 2.6
+		IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+			IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletWorldImporter DESTINATION .)
+			ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletWorldImporter DESTINATION lib${LIB_SUFFIX})
+				INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+			ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+		ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+		IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+			SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES FRAMEWORK true)
+			SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES PUBLIC_HEADER "btBulletWorldImporter.h")
+		ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+	ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Code/Physics/Bullet Source/BulletWorldImporter/btBulletWorldImporter.cpp

@@ -0,0 +1,362 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btBulletWorldImporter.h"
+#include "../BulletFileLoader/btBulletFile.h"
+
+#include "btBulletDynamicsCommon.h"
+#include "BulletCollision/Gimpact/btGImpactShape.h"
+
+
+
+//#define USE_INTERNAL_EDGE_UTILITY
+#ifdef USE_INTERNAL_EDGE_UTILITY
+#include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h"
+#endif //USE_INTERNAL_EDGE_UTILITY
+
+btBulletWorldImporter::btBulletWorldImporter(btDynamicsWorld* world)
+	:btWorldImporter(world)
+{
+}
+
+btBulletWorldImporter::~btBulletWorldImporter()
+{
+}
+
+
+bool	btBulletWorldImporter::loadFile( const char* fileName, const char* preSwapFilenameOut)
+{
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(fileName);
+
+	
+	bool result = loadFileFromMemory(bulletFile2);
+	//now you could save the file in 'native' format using
+	//bulletFile2->writeFile("native.bullet");
+	if (result)
+	{
+		if (preSwapFilenameOut)
+		{
+			bulletFile2->preSwap();
+			bulletFile2->writeFile(preSwapFilenameOut);
+		}
+		
+	}
+	delete bulletFile2;
+	
+	return result;
+
+}
+
+
+
+bool	btBulletWorldImporter::loadFileFromMemory( char* memoryBuffer, int len)
+{
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(memoryBuffer,len);
+
+	bool result = loadFileFromMemory(bulletFile2);
+
+	delete bulletFile2;
+
+	return result;
+}
+
+
+
+
+bool	btBulletWorldImporter::loadFileFromMemory(  bParse::btBulletFile* bulletFile2)
+{
+	bool ok = (bulletFile2->getFlags()& bParse::FD_OK)!=0;
+	
+	if (ok)
+		bulletFile2->parse(m_verboseMode);
+	else 
+		return false;
+	
+	if (m_verboseMode & bParse::FD_VERBOSE_DUMP_CHUNKS)
+	{
+		bulletFile2->dumpChunks(bulletFile2->getFileDNA());
+	}
+
+	return convertAllObjects(bulletFile2);
+
+}
+
+bool	btBulletWorldImporter::convertAllObjects(  bParse::btBulletFile* bulletFile2)
+{
+
+	m_shapeMap.clear();
+	m_bodyMap.clear();
+
+	int i;
+	
+	for (i=0;i<bulletFile2->m_bvhs.size();i++)
+	{
+		btOptimizedBvh* bvh = createOptimizedBvh();
+
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btQuantizedBvhDoubleData* bvhData = (btQuantizedBvhDoubleData*)bulletFile2->m_bvhs[i];
+			bvh->deSerializeDouble(*bvhData);
+		} else
+		{
+			btQuantizedBvhFloatData* bvhData = (btQuantizedBvhFloatData*)bulletFile2->m_bvhs[i];
+			bvh->deSerializeFloat(*bvhData);
+		}
+		m_bvhMap.insert(bulletFile2->m_bvhs[i],bvh);
+	}
+
+
+
+	
+
+	for (i=0;i<bulletFile2->m_collisionShapes.size();i++)
+	{
+		btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];
+		btCollisionShape* shape = convertCollisionShape(shapeData);
+		if (shape)
+		{
+	//		printf("shapeMap.insert(%x,%x)\n",shapeData,shape);
+			m_shapeMap.insert(shapeData,shape);
+		}
+
+		if (shape&& shapeData->m_name)
+		{
+			char* newname = duplicateName(shapeData->m_name);
+			m_objectNameMap.insert(shape,newname);
+			m_nameShapeMap.insert(newname,shape);
+		}
+	}
+
+	
+
+
+	
+	for (int i=0;i<bulletFile2->m_dynamicsWorldInfo.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btDynamicsWorldDoubleData* solverInfoData = (btDynamicsWorldDoubleData*)bulletFile2->m_dynamicsWorldInfo[i];
+			btContactSolverInfo solverInfo;
+
+			btVector3 gravity;
+			gravity.deSerializeDouble(solverInfoData->m_gravity);
+
+			solverInfo.m_tau = btScalar(solverInfoData->m_solverInfo.m_tau);
+			solverInfo.m_damping = btScalar(solverInfoData->m_solverInfo.m_damping);
+			solverInfo.m_friction = btScalar(solverInfoData->m_solverInfo.m_friction);
+			solverInfo.m_timeStep = btScalar(solverInfoData->m_solverInfo.m_timeStep);
+
+			solverInfo.m_restitution = btScalar(solverInfoData->m_solverInfo.m_restitution);
+			solverInfo.m_maxErrorReduction = btScalar(solverInfoData->m_solverInfo.m_maxErrorReduction);
+			solverInfo.m_sor = btScalar(solverInfoData->m_solverInfo.m_sor);
+			solverInfo.m_erp = btScalar(solverInfoData->m_solverInfo.m_erp);
+
+			solverInfo.m_erp2 = btScalar(solverInfoData->m_solverInfo.m_erp2);
+			solverInfo.m_globalCfm = btScalar(solverInfoData->m_solverInfo.m_globalCfm);
+			solverInfo.m_splitImpulsePenetrationThreshold = btScalar(solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold);
+			solverInfo.m_splitImpulseTurnErp = btScalar(solverInfoData->m_solverInfo.m_splitImpulseTurnErp);
+		
+			solverInfo.m_linearSlop = btScalar(solverInfoData->m_solverInfo.m_linearSlop);
+			solverInfo.m_warmstartingFactor = btScalar(solverInfoData->m_solverInfo.m_warmstartingFactor);
+			solverInfo.m_maxGyroscopicForce = btScalar(solverInfoData->m_solverInfo.m_maxGyroscopicForce);
+			solverInfo.m_singleAxisRollingFrictionThreshold = btScalar(solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold);
+		
+			solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
+			solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
+			solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
+			solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
+		
+			solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
+
+			setDynamicsWorldInfo(gravity,solverInfo);
+		} else
+		{
+			btDynamicsWorldFloatData* solverInfoData = (btDynamicsWorldFloatData*)bulletFile2->m_dynamicsWorldInfo[i];
+			btContactSolverInfo solverInfo;
+
+			btVector3 gravity;
+			gravity.deSerializeFloat(solverInfoData->m_gravity);
+
+			solverInfo.m_tau = solverInfoData->m_solverInfo.m_tau;
+			solverInfo.m_damping = solverInfoData->m_solverInfo.m_damping;
+			solverInfo.m_friction = solverInfoData->m_solverInfo.m_friction;
+			solverInfo.m_timeStep = solverInfoData->m_solverInfo.m_timeStep;
+
+			solverInfo.m_restitution = solverInfoData->m_solverInfo.m_restitution;
+			solverInfo.m_maxErrorReduction = solverInfoData->m_solverInfo.m_maxErrorReduction;
+			solverInfo.m_sor = solverInfoData->m_solverInfo.m_sor;
+			solverInfo.m_erp = solverInfoData->m_solverInfo.m_erp;
+
+			solverInfo.m_erp2 = solverInfoData->m_solverInfo.m_erp2;
+			solverInfo.m_globalCfm = solverInfoData->m_solverInfo.m_globalCfm;
+			solverInfo.m_splitImpulsePenetrationThreshold = solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold;
+			solverInfo.m_splitImpulseTurnErp = solverInfoData->m_solverInfo.m_splitImpulseTurnErp;
+		
+			solverInfo.m_linearSlop = solverInfoData->m_solverInfo.m_linearSlop;
+			solverInfo.m_warmstartingFactor = solverInfoData->m_solverInfo.m_warmstartingFactor;
+			solverInfo.m_maxGyroscopicForce = solverInfoData->m_solverInfo.m_maxGyroscopicForce;
+			solverInfo.m_singleAxisRollingFrictionThreshold = solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold;
+		
+			solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
+			solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
+			solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
+			solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
+		
+			solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
+
+			setDynamicsWorldInfo(gravity,solverInfo);
+		}
+	}
+
+
+	for (i=0;i<bulletFile2->m_rigidBodies.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btRigidBodyDoubleData* colObjData = (btRigidBodyDoubleData*)bulletFile2->m_rigidBodies[i];
+			convertRigidBodyDouble(colObjData);
+		} else
+		{
+			btRigidBodyFloatData* colObjData = (btRigidBodyFloatData*)bulletFile2->m_rigidBodies[i];
+			convertRigidBodyFloat(colObjData);
+		}
+
+		
+	}
+
+	for (i=0;i<bulletFile2->m_collisionObjects.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btCollisionObjectDoubleData* colObjData = (btCollisionObjectDoubleData*)bulletFile2->m_collisionObjects[i];
+			btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
+			if (shapePtr && *shapePtr)
+			{
+				btTransform startTransform;
+				colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
+				startTransform.deSerializeDouble(colObjData->m_worldTransform);
+				
+				btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+				btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
+				body->setFriction(btScalar(colObjData->m_friction));
+				body->setRestitution(btScalar(colObjData->m_restitution));
+				
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+				{
+					btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
+					if (trimesh->getTriangleInfoMap())
+					{
+						body->setCollisionFlags(body->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				}
+#endif //USE_INTERNAL_EDGE_UTILITY
+				m_bodyMap.insert(colObjData,body);
+			} else
+			{
+				printf("error: no shape found\n");
+			}
+	
+		} else
+		{
+			btCollisionObjectFloatData* colObjData = (btCollisionObjectFloatData*)bulletFile2->m_collisionObjects[i];
+			btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
+			if (shapePtr && *shapePtr)
+			{
+				btTransform startTransform;
+				colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
+				startTransform.deSerializeFloat(colObjData->m_worldTransform);
+				
+				btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+				btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
+
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+				{
+					btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
+					if (trimesh->getTriangleInfoMap())
+					{
+						body->setCollisionFlags(body->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				}
+#endif //USE_INTERNAL_EDGE_UTILITY
+				m_bodyMap.insert(colObjData,body);
+			} else
+			{
+				printf("error: no shape found\n");
+			}
+		}
+		
+	}
+
+	
+	for (i=0;i<bulletFile2->m_constraints.size();i++)
+	{
+		btTypedConstraintData2* constraintData = (btTypedConstraintData2*)bulletFile2->m_constraints[i];
+		btTypedConstraintFloatData* singleC = (btTypedConstraintFloatData*)bulletFile2->m_constraints[i];
+		btTypedConstraintDoubleData* doubleC = (btTypedConstraintDoubleData*)bulletFile2->m_constraints[i];
+
+		btCollisionObject** colAptr = m_bodyMap.find(constraintData->m_rbA);
+		btCollisionObject** colBptr = m_bodyMap.find(constraintData->m_rbB);
+
+		btRigidBody* rbA = 0;
+		btRigidBody* rbB = 0;
+
+		if (colAptr)
+		{
+			rbA = btRigidBody::upcast(*colAptr);
+			if (!rbA)
+				rbA = &getFixedBody();
+		}
+		if (colBptr)
+		{
+			rbB = btRigidBody::upcast(*colBptr);
+			if (!rbB)
+				rbB = &getFixedBody();
+		}
+		if (!rbA && !rbB)
+			continue;
+				
+		bool isDoublePrecisionData = (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)!=0;
+		
+		if (isDoublePrecisionData)
+		{
+			if (bulletFile2->getVersion()>=282)
+			{
+				btTypedConstraintDoubleData* dc = (btTypedConstraintDoubleData*)constraintData;
+				convertConstraintDouble(dc, rbA,rbB, bulletFile2->getVersion());
+			} else
+			{
+				//double-precision constraints were messed up until 2.82, try to recover data...
+				
+				btTypedConstraintData* oldData = (btTypedConstraintData*)constraintData;
+				
+				convertConstraintBackwardsCompatible281(oldData, rbA,rbB, bulletFile2->getVersion());
+
+			}
+		}
+		else
+		{
+			btTypedConstraintFloatData* dc = (btTypedConstraintFloatData*)constraintData;
+			convertConstraintFloat(dc, rbA,rbB, bulletFile2->getVersion());
+		}
+		
+
+	}
+
+	return true;
+}
+

Code/Physics/Bullet Source/BulletWorldImporter/btBulletWorldImporter.h

@@ -0,0 +1,68 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef BULLET_WORLD_IMPORTER_H
+#define BULLET_WORLD_IMPORTER_H
+
+
+#include "btWorldImporter.h"
+
+
+class btBulletFile;
+
+
+
+
+namespace bParse
+{
+	class btBulletFile;
+	
+};
+
+
+
+///The btBulletWorldImporter is a starting point to import .bullet files.
+///note that not all data is converted yet. You are expected to override or modify this class.
+///See Bullet/Demos/SerializeDemo for a derived class that extract btSoftBody objects too.
+class btBulletWorldImporter : public btWorldImporter
+{
+
+
+public:
+	
+	btBulletWorldImporter(btDynamicsWorld* world=0);
+
+	virtual ~btBulletWorldImporter();
+
+	///if you pass a valid preSwapFilenameOut, it will save a new file with a different endianness 
+	///this pre-swapped file can be loaded without swapping on a target platform of different endianness
+	bool	loadFile(const char* fileName, const char* preSwapFilenameOut=0);
+
+	///the memoryBuffer might be modified (for example if endian swaps are necessary)
+	bool	loadFileFromMemory(char *memoryBuffer, int len);
+
+	bool	loadFileFromMemory(bParse::btBulletFile* file);
+
+	//call make sure bulletFile2 has been parsed, either using btBulletFile::parse or btBulletWorldImporter::loadFileFromMemory
+	virtual	bool	convertAllObjects(bParse::btBulletFile* file);
+
+	
+
+
+};
+
+#endif //BULLET_WORLD_IMPORTER_H
+

Code/Physics/Bullet Source/BulletWorldImporter/btWorldImporter.h

@@ -0,0 +1,212 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef BT_WORLD_IMPORTER_H
+#define BT_WORLD_IMPORTER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+class btCollisionShape;
+class btCollisionObject;
+class btRigidBody;
+class btTypedConstraint;
+class btDynamicsWorld;
+struct ConstraintInput;
+class btRigidBodyColladaInfo;
+struct btCollisionShapeData;
+class btTriangleIndexVertexArray;
+class btStridingMeshInterface;
+struct btStridingMeshInterfaceData;
+class btGImpactMeshShape;
+class btOptimizedBvh;
+struct btTriangleInfoMap;
+class btBvhTriangleMeshShape;
+class btPoint2PointConstraint;
+class btHingeConstraint;
+class btConeTwistConstraint;
+class btGeneric6DofConstraint;
+class btGeneric6DofSpringConstraint;
+class btSliderConstraint;
+class btGearConstraint;
+struct btContactSolverInfo;
+struct btTypedConstraintData;
+struct btTypedConstraintFloatData;
+struct btTypedConstraintDoubleData;
+
+struct btRigidBodyDoubleData;
+struct btRigidBodyFloatData;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btRigidBodyData btRigidBodyDoubleData
+#else
+#define btRigidBodyData btRigidBodyFloatData
+#endif//BT_USE_DOUBLE_PRECISION
+
+
+class btWorldImporter
+{
+protected:
+	btDynamicsWorld* m_dynamicsWorld;
+	
+	int m_verboseMode;
+
+	btAlignedObjectArray<btCollisionShape*>  m_allocatedCollisionShapes;
+	btAlignedObjectArray<btCollisionObject*> m_allocatedRigidBodies;
+	btAlignedObjectArray<btTypedConstraint*> m_allocatedConstraints;
+	btAlignedObjectArray<btOptimizedBvh*>	 m_allocatedBvhs;
+	btAlignedObjectArray<btTriangleInfoMap*> m_allocatedTriangleInfoMaps;
+	btAlignedObjectArray<btTriangleIndexVertexArray*> m_allocatedTriangleIndexArrays;
+	btAlignedObjectArray<btStridingMeshInterfaceData*> m_allocatedbtStridingMeshInterfaceDatas;
+
+	btAlignedObjectArray<char*>				m_allocatedNames;
+
+	btAlignedObjectArray<int*>				m_indexArrays;
+	btAlignedObjectArray<short int*>		m_shortIndexArrays;
+	btAlignedObjectArray<unsigned char*>	m_charIndexArrays;
+
+	btAlignedObjectArray<btVector3FloatData*>	m_floatVertexArrays;
+	btAlignedObjectArray<btVector3DoubleData*>	m_doubleVertexArrays;
+
+
+	btHashMap<btHashPtr,btOptimizedBvh*>	m_bvhMap;
+	btHashMap<btHashPtr,btTriangleInfoMap*>	m_timMap;
+	
+	btHashMap<btHashString,btCollisionShape*>	m_nameShapeMap;
+	btHashMap<btHashString,btRigidBody*>	m_nameBodyMap;
+	btHashMap<btHashString,btTypedConstraint*>	m_nameConstraintMap;
+	btHashMap<btHashPtr,const char*>	m_objectNameMap;
+
+	btHashMap<btHashPtr,btCollisionShape*>	m_shapeMap;
+	btHashMap<btHashPtr,btCollisionObject*>	m_bodyMap;
+
+
+	//methods
+
+	static btRigidBody& getFixedBody();
+
+	char*	duplicateName(const char* name);
+
+	btCollisionShape* convertCollisionShape(  btCollisionShapeData* shapeData  );
+	
+	void	convertConstraintBackwardsCompatible281(btTypedConstraintData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertConstraintFloat(btTypedConstraintFloatData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertConstraintDouble(btTypedConstraintDoubleData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertRigidBodyFloat(btRigidBodyFloatData* colObjData);
+	void	convertRigidBodyDouble( btRigidBodyDoubleData* colObjData);
+
+public:
+	
+	btWorldImporter(btDynamicsWorld* world);
+	
+	virtual ~btWorldImporter();
+
+		///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load.
+	///make sure you don't use the dynamics world containing objects after you call this method
+	virtual void deleteAllData();
+
+	void	setVerboseMode(int verboseMode)
+	{
+		m_verboseMode = verboseMode;
+	}
+
+	int getVerboseMode() const
+	{
+		return m_verboseMode;
+	}
+
+		// query for data
+	int	getNumCollisionShapes() const;
+	btCollisionShape* getCollisionShapeByIndex(int index);
+	int getNumRigidBodies() const;
+	btCollisionObject* getRigidBodyByIndex(int index) const;
+	int getNumConstraints() const;
+	btTypedConstraint* getConstraintByIndex(int index) const;
+	int getNumBvhs() const;
+	btOptimizedBvh*  getBvhByIndex(int index) const;
+	int getNumTriangleInfoMaps() const;
+	btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const;
+	
+	// queris involving named objects
+	btCollisionShape* getCollisionShapeByName(const char* name);
+	btRigidBody* getRigidBodyByName(const char* name);
+	btTypedConstraint* getConstraintByName(const char* name);
+	const char*	getNameForPointer(const void* ptr) const;
+
+	///those virtuals are called by load and can be overridden by the user
+
+	virtual void	setDynamicsWorldInfo(const btVector3& gravity, const btContactSolverInfo& solverInfo);
+
+	//bodies
+	virtual btRigidBody*  createRigidBody(bool isDynamic, 	btScalar mass, 	const btTransform& startTransform,	btCollisionShape* shape,const char* bodyName);
+	virtual btCollisionObject*  createCollisionObject(	const btTransform& startTransform,	btCollisionShape* shape,const char* bodyName);
+
+	///shapes
+
+	virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal,btScalar planeConstant);
+	virtual btCollisionShape* createBoxShape(const btVector3& halfExtents);
+	virtual btCollisionShape* createSphereShape(btScalar radius);
+	virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height);
+	
+	virtual btCollisionShape* createCylinderShapeX(btScalar radius,btScalar height);
+	virtual btCollisionShape* createCylinderShapeY(btScalar radius,btScalar height);
+	virtual btCollisionShape* createCylinderShapeZ(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeX(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeY(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeZ(btScalar radius,btScalar height);
+	virtual class btTriangleIndexVertexArray*	createTriangleMeshContainer();
+	virtual	btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh);
+	virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh);
+	virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh);
+	virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData);
+
+	virtual class btConvexHullShape* createConvexHullShape();
+	virtual class btCompoundShape* createCompoundShape();
+	virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape,const btVector3& localScalingbtBvhTriangleMeshShape);
+
+	virtual class btMultiSphereShape* createMultiSphereShape(const btVector3* positions,const btScalar* radi,int numSpheres);
+
+	virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData);
+
+	///acceleration and connectivity structures
+	virtual btOptimizedBvh*	createOptimizedBvh();
+	virtual btTriangleInfoMap* createTriangleInfoMap();
+
+	///constraints
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB);
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA=false);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA=false);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB,const btTransform& rbAFrame, const btTransform& rbBFrame);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);
+	virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+    virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
+	virtual btGeneric6DofSpringConstraint* createGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+	virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+    virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btGearConstraint* createGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA,const btVector3& axisInB, btScalar ratio);
+	
+
+
+
+};
+
+
+#endif //BT_WORLD_IMPORTER_H

Code/Physics/Bullet Source/BulletWorldImporter/premake4.lua

@@ -0,0 +1,13 @@
+	project "BulletWorldImporter"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../BulletFileLoader",
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Code/Physics/GamePhysics/GamePhysics.vcxproj

@@ -97,7 +97,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debug.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debug.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletFileLoader_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletWorldImporter_Debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -112,7 +112,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debugx64.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debugx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debugx64.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletWorldImporter_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletFileLoader_Debugx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -131,7 +131,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollision.lib;$(SolutionDir)Physics/lib/release/BulletDynamics.lib;$(SolutionDir)Physics/lib/release/LinearMath.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollision.lib;$(SolutionDir)Physics/lib/release/BulletDynamics.lib;$(SolutionDir)Physics/lib/release/LinearMath.lib;$(SolutionDir)Physics/lib/release/BulletFileLoader.lib;$(SolutionDir)Physics/lib/release/BulletWorldImporter.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -150,7 +150,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollisionx64.lib;$(SolutionDir)Physics/lib/release/BulletDynamicsx64.lib;$(SolutionDir)Physics/lib/release/LinearMathx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollisionx64.lib;$(SolutionDir)Physics/lib/release/BulletDynamicsx64.lib;$(SolutionDir)Physics/lib/release/LinearMathx64.lib;$(SolutionDir)Physics/lib/release/BulletWorldImporterx64.lib;$(SolutionDir)Physics/lib/release/BulletFileLoaderx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>

Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

@@ -1,6 +1,9 @@
 #include "PhysicsAPI_Impl.h"
 #include "OysterPhysics3D.h"
 #include "SimpleRigidBody.h"
+#include <BulletWorldImporter\btBulletWorldImporter.h>
+
+#include <codecvt>
 
 using namespace ::Oyster;
 using namespace ::Oyster::Physics;
@@ -92,8 +95,8 @@ ICustomBody* API_Impl::AddCollisionSphere(float radius, ::Oyster::Math::Float4 r
 
 	state.centerPos = position;
 	state.reach = Float3(radius, radius, radius);
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 
@@ -131,8 +134,8 @@ ICustomBody* API_Impl::AddCollisionBox(Float3 halfSize, ::Oyster::Math::Float4 r
 
 	state.centerPos = position;
 	state.reach = halfSize;
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 
@@ -170,8 +173,8 @@ ICustomBody* API_Impl::AddCollisionCylinder(::Oyster::Math::Float3 halfSize, ::O
 
 	state.centerPos = position;
 	state.reach = halfSize;
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 
@@ -211,8 +214,55 @@ ICustomBody* API_Impl::AddCharacter(::Oyster::Math::Float height, ::Oyster::Math
 
 	state.centerPos = position;
 	state.reach = Float3(radius, height, radius);
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
+	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
+	state.mass = mass;
+
+	body->SetState(state);
+
+	return body;
+}
+
+ICustomBody* API_Impl::AddTriangleMesh(const std::wstring fileName, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction)
+{
+	SimpleRigidBody* body = new SimpleRigidBody;
+	SimpleRigidBody::State state;
+
+	btBulletWorldImporter bulletFile;
+
+	typedef std::codecvt_utf8<wchar_t> convert_typeX;
+	std::wstring_convert<convert_typeX, wchar_t> converterX;
+
+	std::string bulletPath = converterX.to_bytes(fileName);
+
+	// Add collision shape
+	bulletFile.loadFile(bulletPath.c_str());
+	btCollisionShape* collisionShape = bulletFile.getCollisionShapeByIndex(0);
+	body->SetCollisionShape(collisionShape);
+
+	// Add motion state
+	btDefaultMotionState* motionState = new btDefaultMotionState(btTransform(btQuaternion(rotation.x, rotation.y, rotation.z, rotation.w),btVector3(position.x, position.y, position.z)));
+	body->SetMotionState(motionState);
+
+	// Add rigid body
+	btVector3 fallInertia(0, 0, 0);
+	collisionShape->calculateLocalInertia(mass, fallInertia);
+	btRigidBody::btRigidBodyConstructionInfo rigidBodyCI(mass, motionState, collisionShape, fallInertia);
+    btRigidBody* rigidBody = new btRigidBody(rigidBodyCI);
+	rigidBody->setFriction(staticFriction);
+	rigidBody->setRestitution(restitution);
+	rigidBody->setUserPointer(body);
+	body->SetRigidBody(rigidBody);
+
+	// Add rigid body to world
+	this->dynamicsWorld->addRigidBody(rigidBody);
+	this->customBodies.push_back(body);
+
+	state.centerPos = position;
+	state.reach = Float3(0, 0, 0);
+	state.dynamicFrictionCoeff = dynamicFriction;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 

Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.h

@@ -66,6 +66,8 @@ namespace Oyster
 
 			ICustomBody* AddCharacter(::Oyster::Math::Float height, ::Oyster::Math::Float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
 
+			ICustomBody* AddTriangleMesh(const std::wstring fileName, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
+
 			void SetTimeStep(float timeStep);
 
 			void UpdateWorld();

Code/Physics/GamePhysics/Implementation/SimpleRigidBody.cpp

@@ -300,11 +300,13 @@ Float4x4 SimpleRigidBody::GetView( const ::Oyster::Math::Float3 &offset ) const
 
 Float3 SimpleRigidBody::GetGravity() const
 {
-	return (Float3)this->rigidBody->getGravity();
+	btVector3 gravity = this->rigidBody->getGravity();
+	return Float3(gravity.x(), gravity.y(), gravity.z());
 }
 Float3 SimpleRigidBody::GetLinearVelocity() const
 {
-	return (Float3)this->rigidBody->getLinearVelocity();
+	btVector3 linearVelocity = this->rigidBody->getLinearVelocity();
+	return Float3(linearVelocity.x(), linearVelocity.y(), linearVelocity.z());
 }
 
 

Code/Physics/GamePhysics/PhysicsAPI.h

@@ -89,6 +89,8 @@ namespace Oyster
 
 			virtual ICustomBody* AddCharacter(::Oyster::Math::Float height, ::Oyster::Math::Float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
 
+			virtual ICustomBody* AddTriangleMesh(const std::wstring fileName, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
+
 			virtual void SetTimeStep(float timeStep) = 0;
 
 			virtual void UpdateWorld() = 0;