Merge remote-tracking branch 'origin/GameLogic' into Camera-merge-attempt

Conflicts:
	Code/Game/DanBiasGame/GameClientState/GameState.cpp
	Code/Game/DanBiasGame/GameClientState/GameState.h

Code/DanBias.sln

@@ -39,20 +39,26 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GameProtocols", "Game\GameP
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DanBiasServerLauncher", "Game\DanBiasServerLauncher\DanBiasServerLauncher.vcxproj", "{060B1890-CBF3-4808-BA99-A4776222093B}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Physics lab", "Physics lab\Physics lab.vcxproj", "{5128BD77-6472-4C4A-BE6F-724AD0E589C2}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GameServer", "Game\GameServer\GameServer.vcxproj", "{143BD516-20A1-4890-A3E4-F8BFD02220E7}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "aDanBiasGameLauncher", "Game\aDanBiasGameLauncher\aDanBiasGameLauncher.vcxproj", "{666FEA52-975F-41CD-B224-B19AF3C0ABBA}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Physics", "Physics", "{0D86E569-9C74-47F0-BDB2-390C0C9A084B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Mixed Platforms = Debug|Mixed Platforms
 		Debug|Win32 = Debug|Win32
 		Debug|x64 = Debug|x64
+		MinSizeRel|Mixed Platforms = MinSizeRel|Mixed Platforms
+		MinSizeRel|Win32 = MinSizeRel|Win32
+		MinSizeRel|x64 = MinSizeRel|x64
 		Release|Mixed Platforms = Release|Mixed Platforms
 		Release|Win32 = Release|Win32
 		Release|x64 = Release|x64
+		RelWithDebInfo|Mixed Platforms = RelWithDebInfo|Mixed Platforms
+		RelWithDebInfo|Win32 = RelWithDebInfo|Win32
+		RelWithDebInfo|x64 = RelWithDebInfo|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
@@ -61,240 +67,438 @@ Global
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Debug|Win32.Build.0 = Debug|Win32
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Debug|x64.ActiveCfg = Debug|x64
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Debug|x64.Build.0 = Debug|x64
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.MinSizeRel|x64.Build.0 = Release|x64
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Release|Win32.ActiveCfg = Release|Win32
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Release|Win32.Build.0 = Release|Win32
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Release|x64.ActiveCfg = Release|x64
 		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.Release|x64.Build.0 = Release|x64
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{0EC83E64-230E-48EF-B08C-6AC9651B4F82}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Debug|Win32.ActiveCfg = Debug|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Debug|Win32.Build.0 = Debug|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Debug|x64.ActiveCfg = Debug|x64
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Debug|x64.Build.0 = Debug|x64
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.MinSizeRel|x64.Build.0 = Release|x64
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Release|Win32.ActiveCfg = Release|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Release|Win32.Build.0 = Release|Win32
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Release|x64.ActiveCfg = Release|x64
 		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.Release|x64.Build.0 = Release|x64
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{F10CBC03-9809-4CBA-95D8-327C287B18EE}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Debug|Win32.ActiveCfg = Debug|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Debug|Win32.Build.0 = Debug|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Debug|x64.ActiveCfg = Debug|x64
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Debug|x64.Build.0 = Debug|x64
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.MinSizeRel|x64.Build.0 = Release|x64
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Release|Win32.ActiveCfg = Release|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Release|Win32.Build.0 = Release|Win32
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Release|x64.ActiveCfg = Release|x64
 		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.Release|x64.Build.0 = Release|x64
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{4285BD3F-3C6C-4670-B7AF-A29AFEF5F6A8}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Debug|Win32.ActiveCfg = Debug|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Debug|Win32.Build.0 = Debug|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Debug|x64.ActiveCfg = Debug|x64
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Debug|x64.Build.0 = Debug|x64
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.MinSizeRel|x64.Build.0 = Release|x64
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Release|Win32.ActiveCfg = Release|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Release|Win32.Build.0 = Release|Win32
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Release|x64.ActiveCfg = Release|x64
 		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.Release|x64.Build.0 = Release|x64
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{34D6295A-00DD-4B1A-8258-97DA2818EC26}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Debug|Win32.ActiveCfg = Debug|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Debug|Win32.Build.0 = Debug|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Debug|x64.ActiveCfg = Debug|x64
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Debug|x64.Build.0 = Debug|x64
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.MinSizeRel|x64.Build.0 = Release|x64
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Release|Win32.ActiveCfg = Release|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Release|Win32.Build.0 = Release|Win32
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Release|x64.ActiveCfg = Release|x64
 		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.Release|x64.Build.0 = Release|x64
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{35AEA3C0-E0A7-4E1E-88CD-514AA5A442B1}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Debug|Win32.ActiveCfg = Debug|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Debug|Win32.Build.0 = Debug|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Debug|x64.ActiveCfg = Debug|x64
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Debug|x64.Build.0 = Debug|x64
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.MinSizeRel|x64.Build.0 = Release|x64
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Release|Win32.ActiveCfg = Release|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Release|Win32.Build.0 = Release|Win32
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Release|x64.ActiveCfg = Release|x64
 		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.Release|x64.Build.0 = Release|x64
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{7E3990D2-3D94-465C-B58D-64A74B3ECF9B}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Debug|Win32.ActiveCfg = Debug|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Debug|Win32.Build.0 = Debug|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Debug|x64.ActiveCfg = Debug|x64
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Debug|x64.Build.0 = Debug|x64
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.MinSizeRel|x64.Build.0 = Release|x64
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Release|Win32.ActiveCfg = Release|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Release|Win32.Build.0 = Release|Win32
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Release|x64.ActiveCfg = Release|x64
 		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.Release|x64.Build.0 = Release|x64
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{2EC4DDED-8F75-4C86-A10B-E1E8EB29F3EE}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Debug|Win32.ActiveCfg = Debug|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Debug|Win32.Build.0 = Debug|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Debug|x64.ActiveCfg = Debug|x64
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Debug|x64.Build.0 = Debug|x64
+		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.MinSizeRel|x64.ActiveCfg = Release|x64
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Release|Win32.ActiveCfg = Release|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Release|Win32.Build.0 = Release|Win32
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Release|x64.ActiveCfg = Release|x64
 		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.Release|x64.Build.0 = Release|x64
+		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{838B25C2-D19E-49FE-8CB0-9A977CA3C7E8}.RelWithDebInfo|x64.ActiveCfg = Release|x64
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Debug|Win32.ActiveCfg = Debug|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Debug|Win32.Build.0 = Debug|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Debug|x64.ActiveCfg = Debug|x64
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Debug|x64.Build.0 = Debug|x64
+		{6A066806-F43F-4B31-A4E3-57179674F460}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{6A066806-F43F-4B31-A4E3-57179674F460}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{6A066806-F43F-4B31-A4E3-57179674F460}.MinSizeRel|x64.ActiveCfg = Release|x64
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Release|Win32.ActiveCfg = Release|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Release|Win32.Build.0 = Release|Win32
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Release|x64.ActiveCfg = Release|x64
 		{6A066806-F43F-4B31-A4E3-57179674F460}.Release|x64.Build.0 = Release|x64
+		{6A066806-F43F-4B31-A4E3-57179674F460}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{6A066806-F43F-4B31-A4E3-57179674F460}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{6A066806-F43F-4B31-A4E3-57179674F460}.RelWithDebInfo|x64.ActiveCfg = Release|x64
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Debug|Win32.ActiveCfg = Debug|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Debug|Win32.Build.0 = Debug|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Debug|x64.ActiveCfg = Debug|x64
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Debug|x64.Build.0 = Debug|x64
+		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.MinSizeRel|x64.ActiveCfg = Release|x64
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Release|Win32.ActiveCfg = Release|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Release|Win32.Build.0 = Release|Win32
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Release|x64.ActiveCfg = Release|x64
 		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.Release|x64.Build.0 = Release|x64
+		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{C5AA09D0-6594-4CD3-BD92-1D380C7B3B50}.RelWithDebInfo|x64.ActiveCfg = Release|x64
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Debug|Win32.ActiveCfg = Debug|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Debug|Win32.Build.0 = Debug|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Debug|x64.ActiveCfg = Debug|x64
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Debug|x64.Build.0 = Debug|x64
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.MinSizeRel|x64.Build.0 = Release|x64
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Release|Win32.ActiveCfg = Release|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Release|Win32.Build.0 = Release|Win32
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Release|x64.ActiveCfg = Release|x64
 		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.Release|x64.Build.0 = Release|x64
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{104FA3E9-94D9-4E1D-A941-28A03BC8A095}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Debug|Win32.ActiveCfg = Debug|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Debug|Win32.Build.0 = Debug|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Debug|x64.ActiveCfg = Debug|x64
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Debug|x64.Build.0 = Debug|x64
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.MinSizeRel|x64.Build.0 = Release|x64
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Release|Win32.ActiveCfg = Release|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Release|Win32.Build.0 = Release|Win32
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Release|x64.ActiveCfg = Release|x64
 		{2A1BC987-AF42-4500-802D-89CD32FC1309}.Release|x64.Build.0 = Release|x64
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{2A1BC987-AF42-4500-802D-89CD32FC1309}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Debug|Win32.ActiveCfg = Debug|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Debug|Win32.Build.0 = Debug|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Debug|x64.ActiveCfg = Debug|x64
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Debug|x64.Build.0 = Debug|x64
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.MinSizeRel|x64.Build.0 = Release|x64
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|Win32.ActiveCfg = Release|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|Win32.Build.0 = Release|Win32
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|x64.ActiveCfg = Release|x64
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|x64.Build.0 = Release|x64
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Win32.ActiveCfg = Debug|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Win32.Build.0 = Debug|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|x64.ActiveCfg = Debug|x64
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|x64.Build.0 = Debug|x64
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.MinSizeRel|x64.Build.0 = Release|x64
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Release|Win32.ActiveCfg = Release|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Release|Win32.Build.0 = Release|Win32
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Release|x64.ActiveCfg = Release|x64
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Release|x64.Build.0 = Release|x64
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Debug|Win32.ActiveCfg = Debug|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Debug|Win32.Build.0 = Debug|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Debug|x64.ActiveCfg = Debug|x64
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Debug|x64.Build.0 = Debug|x64
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.MinSizeRel|x64.Build.0 = Release|x64
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Release|Win32.ActiveCfg = Release|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Release|Win32.Build.0 = Release|Win32
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Release|x64.ActiveCfg = Release|x64
 		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.Release|x64.Build.0 = Release|x64
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{460D625F-2AC9-4559-B809-0BA89CEAEDF4}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Debug|Win32.ActiveCfg = Debug|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Debug|Win32.Build.0 = Debug|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Debug|x64.ActiveCfg = Debug|x64
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Debug|x64.Build.0 = Debug|x64
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.MinSizeRel|x64.Build.0 = Release|x64
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Release|Win32.ActiveCfg = Release|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Release|Win32.Build.0 = Release|Win32
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Release|x64.ActiveCfg = Release|x64
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.Release|x64.Build.0 = Release|x64
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Debug|Win32.ActiveCfg = Debug|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Debug|Win32.Build.0 = Debug|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Debug|x64.ActiveCfg = Debug|x64
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Debug|x64.Build.0 = Debug|x64
+		{060B1890-CBF3-4808-BA99-A4776222093B}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{060B1890-CBF3-4808-BA99-A4776222093B}.MinSizeRel|x64.Build.0 = Release|x64
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Release|Win32.ActiveCfg = Release|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Release|Win32.Build.0 = Release|Win32
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Release|x64.ActiveCfg = Release|x64
 		{060B1890-CBF3-4808-BA99-A4776222093B}.Release|x64.Build.0 = Release|x64
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Debug|Win32.Build.0 = Debug|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Win32.Build.0 = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Debug|x64.ActiveCfg = Debug|x64
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|x64.ActiveCfg = Release|x64
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Debug|x64.Build.0 = Debug|x64
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|x64.Build.0 = Release|x64
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|Mixed Platforms.ActiveCfg = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|Mixed Platforms.Build.0 = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|Win32.ActiveCfg = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|Win32.Build.0 = Release|Win32
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|x64.ActiveCfg = Release|x64
-		{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|x64.Build.0 = Release|x64
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Win32.ActiveCfg = Debug|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Win32.Build.0 = Debug|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|x64.ActiveCfg = Debug|x64
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|x64.Build.0 = Debug|x64
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.MinSizeRel|x64.Build.0 = Release|x64
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Win32.ActiveCfg = Release|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Win32.Build.0 = Release|Win32
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|x64.ActiveCfg = Release|x64
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|x64.Build.0 = Release|x64
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{143BD516-20A1-4890-A3E4-F8BFD02220E7}.RelWithDebInfo|x64.Build.0 = Release|x64
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Win32.ActiveCfg = Debug|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Win32.Build.0 = Debug|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|x64.ActiveCfg = Debug|x64
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|x64.Build.0 = Debug|x64
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.MinSizeRel|Win32.ActiveCfg = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.MinSizeRel|Win32.Build.0 = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.MinSizeRel|x64.ActiveCfg = Release|x64
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.MinSizeRel|x64.Build.0 = Release|x64
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Release|Mixed Platforms.ActiveCfg = Release|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Release|Win32.ActiveCfg = Release|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Release|Win32.Build.0 = Release|Win32
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Release|x64.ActiveCfg = Release|x64
 		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Release|x64.Build.0 = Release|x64
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.RelWithDebInfo|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Code/Game/DanBiasGame/DanBiasGame.vcxproj

@@ -207,6 +207,10 @@
     <ClCompile Include="GameClientState\GameClientState.cpp" />
     <ClCompile Include="GameClientState\GameState.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\LobbyState.cpp" />
     <ClCompile Include="GameClientState\C_Object.cpp" />
     <ClCompile Include="GameClientState\LoginState.cpp" />
@@ -223,6 +227,11 @@
     <ClInclude Include="GameClientState\GameClientState.h" />
     <ClInclude Include="GameClientState\GameState.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\LoginState.h" />
     <ClInclude Include="Include\DanBiasGame.h" />
     <ClInclude Include="GameClientState\LobbyState.h" />

Code/Game/DanBiasGame/DanBiasGame_Impl.cpp

@@ -56,6 +56,7 @@ namespace DanBias
 	{
 
 		WindowShell::CreateConsoleWindow();
+		//if(! m_data->window->CreateWin(WindowShell::WINDOW_INIT_DESC(L"Window", cPOINT(1600, 900), cPOINT())))
 		if(! m_data->window->CreateWin(WindowShell::WINDOW_INIT_DESC()))
 			return DanBiasClientReturn_Error;
 
@@ -114,6 +115,10 @@ namespace DanBias
 	{
 		if(Oyster::Graphics::API::Init(m_data->window->GetHWND(), false, false, Oyster::Math::Float2( 1024, 768)) != Oyster::Graphics::API::Sucsess)
 			return E_FAIL;
+		Oyster::Graphics::API::Option p;
+		p.modelPath = L"..\\Content\\Models\\";
+		p.texturePath = L"..\\Content\\Textures\\";
+		Oyster::Graphics::API::SetOptions(p);
 		return S_OK;
 	}
 
@@ -147,6 +152,7 @@ namespace DanBias
 
 		if(state != Client::GameClientState::ClientState_Same)
 		{
+			bool stateVal = false;
 			m_data->recieverObj->gameClientState->Release();
 			delete m_data->recieverObj->gameClientState;
 			m_data->recieverObj->gameClientState = NULL;
@@ -155,23 +161,27 @@ namespace DanBias
 			{
 			case Client::GameClientState::ClientState_LobbyCreated:
 				m_data->serverOwner = true;
+				stateVal = true;
 			case Client::GameClientState::ClientState_Lobby:
 				m_data->recieverObj->gameClientState = new Client::LobbyState();
+				stateVal = true;
 				break;
 			case Client::GameClientState::ClientState_Game:
-				if(m_data->serverOwner)
+				
-					DanBias::GameServerAPI::GameStart();
-				m_data->recieverObj->gameClientState = new Client::GameState();
-				if(m_data->serverOwner)
-					((Client::GameState*)m_data->recieverObj->gameClientState)->setClientId(0);
-				else
-					((Client::GameState*)m_data->recieverObj->gameClientState)->setClientId(1);
 				break;
 			default:
 				return E_FAIL;
 				break;
 			}
-			m_data->recieverObj->gameClientState->Init(m_data->recieverObj); // send game client
+
+			if(stateVal)
+			{
+				m_data->recieverObj->gameClientState->Init(m_data->recieverObj); // send game client
+			}
+			else
+			{
+
+			}
 				 
 		}
 		return S_OK;
@@ -179,15 +189,7 @@ namespace DanBias
 
 	HRESULT DanBiasGame::Render(float deltaTime)
 	{
-		int isPressed = 0;
-		if(m_data->inputObj->IsKeyPressed(DIK_A))
-		{
-			isPressed = 1;
-		}
 		
-		wchar_t title[255];
-		swprintf(title, sizeof(title), L"| Pressing A:  %d | \n", (int)(isPressed));
-		SetWindowText(m_data->window->GetHWND(), title);
 	
 		m_data->recieverObj->gameClientState->Render();
 
@@ -202,9 +204,11 @@ namespace DanBias
 		delete m_data->recieverObj;
 		delete m_data->inputObj;
 		delete m_data;
-		
 
 		Oyster::Graphics::API::Clean();
+
+		GameServerAPI::ServerStop();
+
 		return S_OK;
 	}	
 

Code/Game/DanBiasGame/GameClientRecieverFunc.h

@@ -4,6 +4,8 @@
 //WTF!? No headers included???
 #include "../DanBiasGame/Include/DanBiasGame.h"
 #include "../GameProtocols/GeneralProtocols.h"
+#include "..\GameProtocols\Protocols.h"
+#include <Utilities.h>
 
 namespace DanBias
 {
@@ -14,9 +16,15 @@ namespace DanBias
 
 		// receiver function for server messages 
 		// parsing protocols and sending it to the gameState
-		void NetworkCallback(Oyster::Network::CustomNetProtocol& p) override
+		//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:
@@ -60,20 +68,20 @@ namespace DanBias
 
 			case protocol_Gameplay_ObjectCreate:
 				{
-					Client::GameClientState::NewObj* protocolData = new Client::GameClientState::NewObj;
+					Client::GameClientState::NewObj protocolData;// = new Client::GameClientState::NewObj;
-					protocolData->object_ID = p[1].value.netInt;
+					protocolData.object_ID = p[1].value.netInt;
-					protocolData->path = p[2].value.netCharPtr;
+					protocolData.path = p[2].value.netCharPtr;
 					for(int i = 0; i< 16; i++)
 					{
-						protocolData->worldPos[i] = p[i+3].value.netFloat;
+						protocolData.worldPos[i] = p[i+3].value.netFloat;
 					}
 
 					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(protocolData);
+						((Client::GameState*)gameClientState)->Protocol(&protocolData);
 
-					delete p[2].value.netCharPtr; //delete char array
+					//delete p[2].value.netCharPtr; //delete char array
-					delete protocolData;
+					//delete protocolData;
-					protocolData = NULL;
+					//protocolData = NULL;
 				}
 				break;
 			case protocol_Gameplay_ObjectDisabled:
@@ -102,16 +110,42 @@ namespace DanBias
 						((Client::GameState*)gameClientState)->Protocol(&protocolData);
 				}
 				break;
-			case protocol_Lobby_Start:
+			case protocol_Lobby_Create:
 				{
-					/*
 					if(dynamic_cast<Client::LobbyState*>(gameClientState))
 					{
+						GameLogic::Protocol_LobbyCreateGame tp();
+						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(m_data->recieverObj);
+						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;
 

Code/Game/DanBiasGame/GameClientState/C_Object.cpp

@@ -1,4 +1,74 @@
 #include "C_Object.h"
 using namespace DanBias::Client;
+void C_Object::Init(ModelInitData modelInit)
+{
+	position = modelInit.position;
+	rotation = modelInit.rotation;
+	scale = modelInit.scale;
+	updateWorld();
+}
+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::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;
+}
+void C_Object::setWorld(Oyster::Math::Float4x4 world)
+{
 
-
+}
+Oyster::Math::Float4x4 C_Object::getWorld() const
+{
+	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
+{
+	return this->position;
+}
+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
+{
+	return this->rotation;
+}
+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
+{
+	return this->scale;
+}
+//int C_Object::GetId() const
+//{
+//	return 
+//}

Code/Game/DanBiasGame/GameClientState/C_Object.h

@@ -10,18 +10,35 @@ namespace DanBias
 		{
 			int id;
 			std::wstring modelPath;
-			Oyster::Math::Float4x4 world; 
+			Oyster::Math::Float3 position; 
+			Oyster::Math::Quaternion rotation; 
+			Oyster::Math::Float3 scale; 
 			bool visible; 
 		};
 
 class C_Object
 {
 private:
-	
+	Oyster::Math::Float4x4 world; 
+	Oyster::Math::Float3 position; 
+	Oyster::Math::Quaternion rotation; 
+	Oyster::Math::Float3 scale; 
+	void updateWorld();
 public:
 
-	virtual void Init(ModelInitData modelInit) = 0;
+	virtual void Init(ModelInitData modelInit);
-	virtual void setPos(Oyster::Math::Float4x4 world) = 0;
+	
+	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;
 
 	virtual void Render() = 0;
 	virtual void Release() = 0;

Code/Game/DanBiasGame/GameClientState/C_obj/C_DynamicObj.cpp

@@ -21,17 +21,14 @@ C_DynamicObj::~C_DynamicObj(void)
 }
 void C_DynamicObj::Init(ModelInitData modelInit)
 {
+	C_Object::Init(modelInit);
 	// load models
 	privData = new myData();
 	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
 	privData->model->Visible = modelInit.visible;
+	privData->model->WorldMatrix = getWorld();
 	privData->ID = modelInit.id;
 }
-void C_DynamicObj::setPos(Oyster::Math::Float4x4 world)
-{
-	privData->model->WorldMatrix  = world;
-}
 
 void C_DynamicObj::Render()
 {

Code/Game/DanBiasGame/GameClientState/C_obj/C_DynamicObj.h

@@ -14,7 +14,6 @@ public:
 	C_DynamicObj(void);
 	virtual ~C_DynamicObj(void);
 	void Init(ModelInitData modelInit);
-	void setPos(Oyster::Math::Float4x4 world);
 
 	void Render();
 	void Release();

Code/Game/DanBiasGame/GameClientState/C_obj/C_Player.cpp

@@ -13,6 +13,7 @@ struct  C_Player::myData
 }privData;
 
 C_Player::C_Player(void)
+	:C_DynamicObj()
 {
 }
 
@@ -24,18 +25,16 @@ C_Player::~C_Player(void)
 
 void C_Player::Init(ModelInitData modelInit)
 {
+	C_Object::Init(modelInit);
 	// load models
 	privData = new myData();
 	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
 	privData->model->Visible = modelInit.visible;
+	privData->model->WorldMatrix = getWorld();
 	privData->ID = modelInit.id;
 	privData->lookDir = Oyster::Math3D::Float4 (0,0,1,0);
 }
-void C_Player::setPos(Oyster::Math::Float4x4 world)
+
-{
-	privData->model->WorldMatrix  = world;
-}
 
 void C_Player::Render()
 {

Code/Game/DanBiasGame/GameClientState/C_obj/C_Player.h

@@ -1,21 +1,20 @@
 #ifndef DANBIAS_CLIENT_CPLAYER_H
 #define DANBIAS_CLIENT_CPLAYER_H
-#include "../C_Object.h"
+#include "C_DynamicObj.h"
 namespace DanBias
 {
 	namespace Client
 	{
-class C_Player : public C_Object
+class C_Player : public C_DynamicObj
 {
 private:
 	struct myData;
 	myData* privData;
-	//Oyster::Graphics:: LIght
+
 public:
 	C_Player(void);
-	~C_Player(void);
+	virtual ~C_Player(void);
 	void Init(ModelInitData modelInit);
-	void setPos(Oyster::Math::Float4x4 world);
 
 	void Render();
 	void Release();

Code/Game/DanBiasGame/GameClientState/C_obj/C_StaticObj.cpp

@@ -8,9 +8,7 @@ struct  C_StaticObj::myData
 	myData(){}
 	Oyster::Graphics::Model::Model *model;
 	int ID;
-	// light
+
-	// sound
-	// effect
 }privData;
 C_StaticObj::C_StaticObj(void)
 {
@@ -23,18 +21,16 @@ C_StaticObj::~C_StaticObj(void)
 }
 void C_StaticObj::Init(ModelInitData modelInit)
 {
+	C_Object::Init(modelInit);
 	// load models
 	privData = new myData();
 	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
 	privData->model->Visible = modelInit.visible;
+	privData->model->WorldMatrix = getWorld();
 	privData->ID = modelInit.id;
 
 }
-void C_StaticObj::setPos(Oyster::Math::Float4x4 world)
+
-{
-	privData->model->WorldMatrix  = world;
-}
 
 void C_StaticObj::Render()
 {

Code/Game/DanBiasGame/GameClientState/C_obj/C_StaticObj.h

@@ -14,7 +14,6 @@ public:
 	C_StaticObj(void);
 	virtual ~C_StaticObj(void);
 	void Init(ModelInitData modelInit);
-	void setPos(Oyster::Math::Float4x4 world);
 
 	void Render();
 	void Release();

Code/Game/DanBiasGame/GameClientState/C_obj/C_UIobject.cpp

@@ -19,11 +19,12 @@ C_UIobject::~C_UIobject(void)
 }
 void C_UIobject::Init(ModelInitData modelInit)
 {
+	C_Object::Init(modelInit);
 	// load models
 	privData = new myData();
 	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
 	privData->model->Visible = modelInit.visible;
+	privData->model->WorldMatrix = getWorld();
 	privData->ID = modelInit.id;
 
 }

Code/Game/DanBiasGame/GameClientState/Camera.cpp

@@ -2,7 +2,7 @@
 
 Camera::Camera()
 {
-	this->m_position = Oyster::Math::Float3(0, 50, 0);
+	this->m_position = Oyster::Math::Float3(0, 600, 0);
 	this->mRight = Oyster::Math::Float3(1, 0, 0);
 	this->mUp = Oyster::Math::Float3(0, 1, 0);
 	this->mLook = Oyster::Math::Float3(0, 0, 1);

Code/Game/DanBiasGame/GameClientState/GameState.cpp

@@ -1,7 +1,5 @@
 #include "GameState.h"
 #include "DllInterfaces/GFXAPI.h"
-#include "C_obj/C_Player.h"
-#include "C_obj/C_DynamicObj.h"
 #include <Protocols.h>
 #include "NetworkClient.h"
 //#include "Camera.h"
@@ -9,13 +7,12 @@
 
 using namespace DanBias::Client;
 using namespace ::Oyster::Math3D;
+using namespace Oyster::Math;
 
 struct  GameState::myData
 {
 	myData(){}
-	//Oyster::Math3D::Float4x4 view;
+	//std::vector<C_Object*> object;
-	//Oyster::Math3D::Float4x4 proj; 
-	std::vector<C_Object*> object;
 	int modelCount;
 	Oyster::Network::NetworkClient* nwClient;
 	gameStateState state;
@@ -32,7 +29,8 @@ GameState::GameState(void)
 
 GameState::~GameState(void)
 {
-
+	delete this->camera;
+	delete this->privData;
 }
 bool GameState::Init(Oyster::Network::NetworkClient* nwClient)
 {
@@ -43,172 +41,238 @@ bool GameState::Init(Oyster::Network::NetworkClient* nwClient)
 	privData->nwClient = nwClient;	
 	privData->state = LoadGame();
 	//pitch = 0;
+
+	//tELL SERver ready
+	nwClient->Send(GameLogic::Protocol_General_Status(GameLogic::Protocol_General_Status::States_ready));
+
 	return true;
 }
 GameState::gameStateState GameState::LoadGame() 
 {
 	Oyster::Graphics::Definitions::Pointlight plight;
-	plight.Pos = Oyster::Math::Float3(315, 0 ,5);
+	plight.Pos = Float3(315, 0 ,5);
-	plight.Color = Oyster::Math::Float3(0.9,0.7,0.2);
+	plight.Color = Float3(0.9f,0.7f,0.2f);
 	plight.Radius = 100;
-	plight.Bright = 0.9;
+	plight.Bright = 0.9f;
 	Oyster::Graphics::API::AddLight(plight);
-	plight.Pos = Oyster::Math::Float3(10,350,5);
+	plight.Pos = Float3(10,350,5);
-	plight.Color = Oyster::Math::Float3(0.9,0.7,0.3);
+	plight.Color = Float3(0.9f,0.7f,0.3f);
 	plight.Radius = 200;
-	plight.Bright = 0.7;
+	plight.Bright = 0.7f;
 	Oyster::Graphics::API::AddLight(plight);
-	plight.Pos = Oyster::Math::Float3(350,350,5);
+	plight.Pos = Float3(350,350,5);
-	plight.Color = Oyster::Math::Float3(0.9,0.7,0.3);
+	plight.Color = Float3(0.9f,0.7f,0.3f);
 	plight.Radius = 200;
-	plight.Bright = 0.7;
+	plight.Bright = 0.7f;
 	Oyster::Graphics::API::AddLight(plight);
-	plight.Pos = Oyster::Math::Float3(10,350,350);
+	plight.Pos = Float3(10,350,350);
-	plight.Color = Oyster::Math::Float3(0.9,0.7,0.3);
+	plight.Color = Float3(0.9f,0.7f,0.3f);
 	plight.Radius = 200;
-	plight.Bright = 0.7;
+	plight.Bright = 0.7f;
 	Oyster::Graphics::API::AddLight(plight);
-	plight.Pos = Oyster::Math::Float3(10,-15,5);
+	plight.Pos = Float3(10,-15,5);
-	plight.Color = Oyster::Math::Float3(0,0,1);
+	plight.Color = Float3(0,0,1);
 	plight.Radius = 50;
 	plight.Bright = 2;
 
 	Oyster::Graphics::API::AddLight(plight);
-	LoadModels(L"map");
+	// use level loader
-	InitCamera(Oyster::Math::Float3(0,0,20.0f));
+	//LoadModels("3bana.bias");
+	// hardcoded objects
+	LoadModels();
+	Float3 startPos = Float3(0,0,20.0f);
+	InitCamera(startPos);
 	return gameStateState_playing;
 }
-bool GameState::LoadModels(std::wstring mapFile)
+bool GameState::LoadModels()
 {
 	// open file
 	// read file 
 	// init models
-	int nrOfBoxex = 20;
+	int nrOfBoxex = 5;
-	privData->modelCount = 3+nrOfBoxex;
+	int id = 100; 
-	myId += privData->modelCount;
+
-	int id = 0; 
 	// add world model
 	ModelInitData modelData;
-	Oyster::Math3D::Float4x4 translate;
+
-	C_Object* obj;
+	modelData.position = Oyster::Math::Float3(0,0,0);
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(0,0,0));
+	modelData.rotation = Oyster::Math::Quaternion::identity;
-	modelData.world = translate  ;//modelData.world * translate 
+	modelData.scale =  Oyster::Math::Float3(2,2,2);
+
 	modelData.modelPath = L"world_earth.dan";
 	modelData.id = id++;
 
-	obj = new C_Player();
+	this->staticObjects.Push(new C_StaticObj());
-	privData->object.push_back(obj);
+	this->staticObjects[this->staticObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
+
 
 	// add box model
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(0,0,0);
+	modelData.rotation = Oyster::Math::Quaternion::identity;
+	modelData.scale =  Oyster::Math::Float3(1,1,1);
 	modelData.modelPath = L"crate_colonists.dan";
 
-	
+
 	for(int i =0; i< nrOfBoxex; i ++)
 	{
-		translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(4,320,0));
+		modelData.position = Oyster::Math::Float3(4,320,0);
-		modelData.world = modelData.world * translate;
 		modelData.id = id++;
 
-		obj = new C_Player();
+		this->dynamicObjects.Push(new C_DynamicObj());
-		privData->object.push_back(obj);
+		this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-		privData->object[privData->object.size() -1 ]->Init(modelData);
-		modelData.world = Oyster::Math3D::Float4x4::identity;
 	}
 
-	// add crystal model 
-	modelData.world = Oyster::Math3D::Float4x4::identity;
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(10, 301, 0));
 
-	modelData.world = modelData.world * translate;
+	// add crystal model 
-	modelData.visible = true;
+	modelData.position = Oyster::Math::Float3(10, 301, 0);
 	modelData.modelPath = L"crystalformation_b.dan";
 	modelData.id = id++;
 	// load models
-	obj =  new C_Player();
+	this->dynamicObjects.Push(new C_DynamicObj());
-	privData->object.push_back(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
 
 	// add house model 
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(-50, 290, 0);
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-50, 290, 0));
+	//Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0));
-	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0));
+
-	
-	modelData.world = modelData.world * translate * rot;
 	modelData.visible = true;
 	modelData.modelPath = L"building_corporation.dan";
 	modelData.id = id++;
 	// load models
-	obj =  new C_Player();
+	this->dynamicObjects.Push(new C_DynamicObj());
-	privData->object.push_back(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
 
 
 	// add player model
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(0, 320, 0);
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(0, 320, 0));
-
-	modelData.world = modelData.world * translate;
-	modelData.visible = true;
 	modelData.modelPath = L"char_still_sizeref.dan";
 	modelData.id = id++;
 	// load models
-	obj =  new C_Player();
+	this->dynamicObjects.Push(new C_DynamicObj());
-	privData->object.push_back(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
 
 	// add player model 2
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(50, 320, 0);
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(50, 320, 0));
-
-	modelData.world = modelData.world * translate;
-	modelData.visible = true;
 	modelData.modelPath = L"char_still_sizeref.dan";
 	modelData.id = id++;
 	// load models
-	obj =  new C_Player();
+	this->dynamicObjects.Push(new C_DynamicObj());
-	privData->object.push_back(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
 
 	// add jumppad
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(4, 300.3, 0);
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(4, 300.3, 0));
-	//Oyster::Math3D::RotationMatrix_AxisZ()
-	modelData.world = modelData.world * translate;
-	modelData.visible = true;
 	modelData.modelPath = L"jumppad_round.dan";
 	modelData.id = id++;
 	// load models
-	obj =  new C_Player();
+	this->dynamicObjects.Push(new C_DynamicObj());
-	privData->object.push_back(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
 
 	// add sky sphere
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(0,0,0);
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(0, 0, 0));
+	modelData.scale =  Oyster::Math::Float3(800,800,800);
-	//Oyster::Math3D::RotationMatrix_AxisZ()
-	modelData.world = modelData.world * translate;
-	modelData.world.v[0].x = 800;
-	modelData.world.v[1].y = 800;
-	modelData.world.v[2].z = 800;
-	modelData.visible = true;
 	modelData.modelPath = L"skysphere.dan";
 	modelData.id = id++;
 	// load models
-	obj =  new C_Player();
+	this->dynamicObjects.Push(new C_DynamicObj());
-	privData->object.push_back(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
-
 	return true;
 }
-bool GameState::InitCamera( Oyster::Math::Float3 startPos )
+bool GameState::LoadModels(std::string mapFile)
+{
+	GameLogic::LevelLoader levelLoader;
+	std::vector<Utility::DynamicMemory::SmartPointer<GameLogic::ObjectTypeHeader>> objects; 
+	objects = levelLoader.LoadLevel(mapFile);
+
+	int objCount = objects.size();
+	int modelId = 0;
+	ModelInitData modelData;
+	for (int i = 0; i < objCount; i++)
+	{
+		GameLogic::ObjectTypeHeader* obj = objects.at(i);
+
+		switch (obj->typeID)
+		{
+		case GameLogic::ObjectType::ObjectType_LevelMetaData:
+
+			break;
+		case GameLogic::ObjectType::ObjectType_Static:
+			{
+				GameLogic::ObjectHeader* staticObjData = ((GameLogic::ObjectHeader*)obj);
+
+				modelData.modelPath.assign(staticObjData->ModelFile.begin(), staticObjData->ModelFile.end());
+				modelData.visible = true;
+				//modelData.position = ;
+				//modelData.rotation = Oyster::Math::Quaternion(Oyster::Math::Float3(2,2,-2), 1);
+				//modelData.scale =  Oyster::Math::Float3(2,2,2);
+				modelData.id = modelId++;
+
+				this->staticObjects.Push(new C_StaticObj());
+				this->staticObjects[this->staticObjects.Size() -1 ]->Init(modelData);
+			}
+		break;
+		case GameLogic::ObjectType::ObjectType_Dynamic:
+			{
+				GameLogic::ObjectHeader* dynamicObjData = ((GameLogic::ObjectHeader*)obj);
+				//modelData.position = ;
+				//modelData.rotation = Oyster::Math::Quaternion(Oyster::Math::Float3(2,2,-2), 1);
+				//modelData.scale =  Oyster::Math::Float3(2,2,2);
+				modelData.modelPath.assign(dynamicObjData->ModelFile.begin(), dynamicObjData->ModelFile.end());
+				modelData.visible = true;
+				modelData.id = modelId++;
+
+				this->dynamicObjects.Push(new C_DynamicObj());
+				this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
+			}
+			break;
+		case  GameLogic::ObjectType::ObjectType_Light:
+			{
+				GameLogic::BasicLight* lightData = ((GameLogic::BasicLight*)obj);
+
+				if(lightData->lightType == GameLogic::LightType_PointLight)
+				{
+					Oyster::Graphics::Definitions::Pointlight plight;
+					plight.Pos = ((GameLogic::PointLight*)lightData)->position;
+					plight.Color = lightData->diffuseColor;
+					plight.Radius = 100;
+					plight.Bright = 0.9f;
+					Oyster::Graphics::API::AddLight(plight);
+				}
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	myId += modelId++;
+	// add player model
+	//modelData.position = ;
+	//modelData.rotation = Oyster::Math::Quaternion(Oyster::Math::Float3(2,2,-2), 1);
+	//modelData.scale =  Oyster::Math::Float3(2,2,2);
+
+
+	modelData.visible = true;
+	modelData.modelPath = L"char_still_sizeref.dan";
+	modelData.id = myId;
+	// load models
+	this->dynamicObjects.Push(new C_DynamicObj());
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
+
+	/*C_Player* obj =  new C_Player();
+	privData->object.push_back(obj);
+	privData->object[privData->object.size() -1 ]->Init(modelData);
+	*/
+	return true;
+	
+}
+bool GameState::InitCamera( Float3 startPos )
 {
 	camera.SetHeadOffset( Float3(0.0f, 1.0f, -2.0f) );
+	//Float3 dir = Float3(0,0,1);
+	//Float3 up = Float3(0,1,0);
+	//Float3 pos = Float3(0, 0, 20);
 
-	//Oyster::Math::Float3 dir = Oyster::Math::Float3(0,0,1);
+	//camera->LookAt(pos, dir, up);
-	//Oyster::Math::Float3 up =Oyster::Math::Float3(0,1,0);
+	//camera->SetLens(3.14f/2, 1024/768, 1, 1000);
-	//Oyster::Math::Float3 pos = Oyster::Math::Float3(0, 0, 20);
 
 	camera.SetPerspectiveProjection( Oyster::Math::pi/2.0f, 1024.0f/768.0f, 1.0f, 1000.0f );
 	Oyster::Graphics::API::SetProjection( Float4x4(camera.GetProjectionMatrix()) ); // TODO: remove copy wrapper when no longer needed
@@ -217,27 +281,70 @@ bool GameState::InitCamera( Oyster::Math::Float3 startPos )
 	//camera->SetLens(3.14f/2, 1024/768, 1, 1000);
 
 	//privData->proj = Oyster::Math3D::ProjectionMatrix_Perspective(Oyster::Math::pi/4,1024.0f/768.0f,.1f,1000);
-	//privData->proj = Oyster::Math3D::ProjectionMatrix_Orthographic(1024, 768, 1, 1000);
-	//Oyster::Graphics::API::SetProjection( privData->proj );
 
 	//camera->UpdateViewMatrix();
 	//privData->view = camera->View();
 	//privData->view = Oyster::Math3D::ViewMatrix_LookAtDirection(Oyster::Math::Float3(0,0,-1),Oyster::Math::Float3(0,1,0),startPos);
 	//privData->view = Oyster::Math3D::OrientationMatrix_LookAtDirection(Oyster::Math::Float3(0,0,-1),Oyster::Math::Float3(0,1,0),startPos);
+	//Oyster::Graphics::API::SetProjection(camera->Proj());
+	
 	//privData->view = Oyster::Math3D::InverseOrientationMatrix(privData->view);
 	return true;
 }
 
-void GameState::setClientId(int id)
+void GameState::InitiatePlayer(int id, std::wstring modelName, Oyster::Math::Float4x4 world)
 {
 	myId = id;
+
+	ModelInitData modelData;
+	C_Object* obj;
+	modelData.visible = true;
+	//modelData.world = world;
+	modelData.position = Oyster::Math::Float3(world[12], world[13], world[14]);
+	modelData.rotation = Oyster::Math::Quaternion(Oyster::Math::Float3(2,2,-2), 1);
+	modelData.scale =  Oyster::Math::Float3(2,2,2);
+	modelData.modelPath = modelName;
+	modelData.id = myId;
+	
+	obj =  new C_Player();
+	this->dynamicObjects.Push(obj);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
+
+	
+	Oyster::Math::Float3 right = Oyster::Math::Float3(world[0], world[1], world[2]);
+	Oyster::Math::Float3 up = Oyster::Math::Float3(world[4], world[5], world[6]);
+	Oyster::Math::Float3 objForward = (Oyster::Math::Float3(world[8], world[9], world[10]));
+	Oyster::Math::Float3 pos = Oyster::Math::Float3(world[12], world[13], world[14]);
+
+	Oyster::Math::Float3 cameraLook = camera->GetLook();
+	Oyster::Math::Float3 cameraUp = camera->GetUp();
+				
+			
+
+	/*Oyster::Math::Float3 newUp = cameraUp.Dot(up);
+	up *= newUp;
+	up.Normalize();
+	Oyster::Math::Float3 newLook = up.Cross(right);
+	newLook.Normalize();*/
+
+	camera->setRight(right);
+	camera->setUp(up);
+	camera->setLook(objForward);
+				
+	up *= 2;
+	objForward *= -3;
+	Oyster::Math::Float3 cameraPos = up + pos + objForward;
+	camera->SetPosition(cameraPos);
+
+	camera->UpdateViewMatrix();
+	
 }
 
 GameClientState::ClientState GameState::Update(float deltaTime, InputClass* KeyInput)
 {
 	switch (privData->state)
 	{
-	case gameStateState_loading:
+	case gameStateState_loading:	//Will this ever happen in this scope??
 		{
 			// load map
 			// wait for all players
@@ -278,21 +385,26 @@ bool GameState::Render()
 	//Oyster::Graphics::API::SetProjection(privData->proj);
 
 	Oyster::Graphics::API::NewFrame();
-	for (unsigned int i = 0; i < privData->object.size(); i++)
+	for (unsigned int i = 0; i < staticObjects.Size(); i++)
 	{
-		privData->object[i]->Render();
+		staticObjects[i]->Render();
 	}
+	for (unsigned int i = 0; i < dynamicObjects.Size(); i++)
+	{
+		dynamicObjects[i]->Render();
+	}
+
 	Oyster::Graphics::API::EndFrame();
 	return true;
 }
 bool GameState::Release()
 {
-	for (unsigned int i = 0; i < privData->object.size(); i++)
+	/*for (unsigned int i = 0; i < privData->object.size(); i++)
 	{
-		privData->object[i]->Release();
+	privData->object[i]->Release();
-		delete privData->object[i];
+	delete privData->object[i];
-		privData->object[i] = NULL;
+	privData->object[i] = NULL;
-	}
+	}*/
 
 	delete privData;  
 	privData = NULL;
@@ -364,7 +476,7 @@ void GameState::readKeyInput(InputClass* KeyInput)
 	}
 
 	//send delta mouse movement 
-	if (KeyInput->IsMousePressed())
+	//if (KeyInput->IsMousePressed())
 	{
 		camera.YawRight( KeyInput->GetYaw() );
 		camera.PitchUp( KeyInput->GetPitch() );
@@ -456,13 +568,17 @@ void GameState::Protocol(ProtocolStruct* pos)
 
 void GameState::Protocol( PlayerPos* pos )
 {
-	Oyster::Math::Float4x4 world, translate;
+	//Oyster::Math::Float4x4 world, translate;
 
-	world = Oyster::Math::Float4x4::identity;
+	//world = Oyster::Math::Float4x4::identity;
-	translate = Oyster::Math::Float4x4::identity;
+	//translate = Oyster::Math::Float4x4::identity;
-	translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(pos->playerPos[0],pos->playerPos[1],pos->playerPos[2]));
+	//translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(pos->playerPos[0],pos->playerPos[1],pos->playerPos[2]));
-	world = world * translate;
+	//world = world * translate;
-	privData->object[0]->setPos( world );
+	////privData->object[0]->setPos( world );
+	//for (unsigned int i = 0; i < dynamicObjects.Size(); i++)
+	//{
+	//	dynamicObjects[i]->Render();
+	//}
 }
 
 void GameState::Protocol( ObjPos* pos )
@@ -473,21 +589,21 @@ void GameState::Protocol( ObjPos* pos )
 		world[i] = pos->worldPos[i];
 	}
 	//printf("pos for obj %d, ",pos->object_ID );
-	for (unsigned int i = 0; i < privData->object.size(); i++)
+	for (unsigned int i = 0; i < dynamicObjects.Size(); i++)
 	{
-		if(privData->object[i]->GetId() == pos->object_ID)
+		if(dynamicObjects[i]->GetId() == pos->object_ID)
 		{
-			privData->object[i]->setPos(world);
+			dynamicObjects[i]->setWorld(world);
 
-			if(i == myId) // playerobj
+			if(dynamicObjects[i]->GetId() == myId) // playerobj
 			{
-				Oyster::Math::Float3 right = Oyster::Math::Float3(world[0], world[1], world[2]);
+				Float3 right =		Float3(world[0], world[1], world[2]);
-				Oyster::Math::Float3 up = Oyster::Math::Float3(world[4], world[5], world[6]);
+				Float3 up =			Float3(world[4], world[5], world[6]);
-				Oyster::Math::Float3 objForward = (Oyster::Math::Float3(world[8], world[9], world[10]));
+				Float3 objForward = Float3(world[8], world[9], world[10]);
-				Oyster::Math::Float3 pos = Oyster::Math::Float3(world[12], world[13], world[14]);
+				Float3 pos =		Float3(world[12], world[13], world[14]);
 
-				//Oyster::Math::Float3 cameraLook = camera->GetLook();
+				//Float3 cameraLook = camera->GetLook();
-				//Oyster::Math::Float3 cameraUp = camera->GetUp();
+				//Float3 cameraUp = camera->GetUp();
 
 				/*Oyster::Math::Float3 newUp = cameraUp.Dot(up);
 				up *= newUp;
@@ -496,16 +612,16 @@ void GameState::Protocol( ObjPos* pos )
 				newLook.Normalize();*/
 
 
-				camera->setRight(right);
+				//camera->setRight(right);
-				camera->setUp(up);
+				//camera->setUp(up);
-				camera->setLook(objForward);
+				//camera->setLook(objForward);
 				
 				up *= 1;
 				objForward *= -2;
-				Oyster::Math::Float3 cameraPos = up + pos + objForward;
+				Oyster::Math::Float3 cameraPos = pos + up + objForward;
-				camera->SetPosition(cameraPos);
+				//camera->SetPosition(cameraPos);
-
+				//camera->UpdateViewMatrix();
-				camera->UpdateViewMatrix();
+				
 			}
 		}
 	}
@@ -521,28 +637,29 @@ void GameState::Protocol( NewObj* newObj )
 	}
 	ModelInitData modelData;
 
-	modelData.world = world;
+	//modelData.world = world;
 	modelData.visible = true;
 	modelData.id = newObj->object_ID;
 	//not sure if this is good parsing rom char* to wstring
 	const char* path = newObj->path;
 	modelData.modelPath = std::wstring(path, path + strlen(path));  
 	// load models
-	C_Object* player = new C_Player();
+	C_DynamicObj* player = new C_DynamicObj();
 	player->Init(modelData);
 
-	privData->object.push_back(player);
+	dynamicObjects.Push(player);
 
 }
 
 void DanBias::Client::GameState::Protocol( RemoveObj* obj )
 {
-	for (unsigned int i = 0; i < privData->object.size(); i++)
+	for (unsigned int i = 0; i < dynamicObjects.Size(); i++)
 	{
-		if(privData->object[i]->GetId() == obj->object_ID)
+		if(dynamicObjects[i]->GetId() == obj->object_ID)
 		{
-			privData->object.at(i)->Release();
+			//dynamicObjects[i]->Release();
-			privData->object.erase(privData->object.begin() + i );
+			dynamicObjects[i].Release();
+			//dynamicObjects.erase(privData->object.begin() + i );
 		}
 	}
 	//privData->object[obj->object_ID]->Release( );

Code/Game/DanBiasGame/GameClientState/GameState.h

@@ -7,6 +7,11 @@
 //#include "Camera.h"
 #include "Camera_FPS.h"
 
+#include "LevelLoader/LevelLoader.h"
+#include "C_obj/C_Player.h"
+#include "C_obj/C_DynamicObj.h"
+#include "C_obj/C_StaticObj.h"
+#include "DynamicArray.h"
 namespace DanBias
 {
 namespace Client
@@ -34,15 +39,19 @@ private:
 	//float pitch;
 	struct myData;
 	myData* privData;
+	Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<C_StaticObj>> staticObjects;
+	Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<C_Object>> dynamicObjects;
+	//Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<C_Player>> playObjects;
 public:
 	GameState(void);
 	~GameState(void);
 	bool Init(Oyster::Network::NetworkClient* nwClient);
 	GameClientState::ClientState Update(float deltaTime, InputClass* KeyInput) override;
-	bool LoadModels(std::wstring mapFile) ;
+	bool LoadModels(std::string mapFile);
+	bool LoadModels();
 	bool InitCamera(Oyster::Math::Float3 startPos) ;
+	void InitiatePlayer(int id, std::wstring modelName, Oyster::Math::Float4x4 world);
 	gameStateState LoadGame();
-	void setClientId(int id);
 	void readKeyInput(InputClass* KeyInput);
 	bool Render()override;
 	bool Release()override;

Code/Game/DanBiasGame/GameClientState/LanMenuState.cpp

@@ -64,15 +64,16 @@ bool LanMenuState::LoadModels(std::wstring file)
 
 	ModelInitData modelData;
 
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(0,0,0);
+	modelData.rotation = Oyster::Math::Quaternion::identity;
+	modelData.scale =  Oyster::Math::Float3(1,1,1);
 	modelData.visible = true;
 	modelData.modelPath = L"..\\Content\\Models\\box_2.dan";
 	// load models
 	privData->object[0] = new C_StaticObj();
 	privData->object[0]->Init(modelData);
 
-	Oyster::Math3D::Float4x4 translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-2,-2,-2));
+	modelData.position = Oyster::Math::Float3(-2, -2, -2);
-	modelData.world = modelData.world * translate;
 
 	privData->object[1] = new C_DynamicObj();
 	privData->object[1]->Init(modelData);

Code/Game/DanBiasGame/GameClientState/LevelLoader/LevelLoader.cpp

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

Code/Game/DanBiasGame/GameClientState/LevelLoader/LevelLoader.h

@@ -0,0 +1,42 @@
+//////////////////////////////////
+// Created by Sam Svensson 2013 //
+//////////////////////////////////
+
+#ifndef LEVELLOADER_H
+#define LEVELLOADER_H
+
+#include <string>
+#include <vector>
+#include "../Misc/Utilities.h"
+#include "ObjectDefines.h"
+
+namespace GameLogic
+{
+	class LevelLoader
+	{
+
+	public:
+		LevelLoader();
+		~LevelLoader();
+
+		/********************************************************
+			* Loads the level and objects from file.
+			* @param fileName: Path 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::string 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::string fileName); //.
+
+	private:
+		struct PrivData;
+		Utility::DynamicMemory::SmartPointer<PrivData> pData;
+	};
+}
+
+#endif

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

@@ -0,0 +1,190 @@
+#include "LevelParser.h"
+
+#include "Loader.h"
+#include "ParseFunctions.h"
+
+using namespace GameLogic;
+using namespace ::LevelFileLoader;
+using namespace Utility::DynamicMemory;
+
+LevelParser::LevelParser()
+{
+	formatVersion.formatVersionMajor = 1;
+	formatVersion.formatVersionMinor = 0;
+}
+
+LevelParser::~LevelParser()
+{
+}
+
+std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filename)
+{
+	int bufferSize = 0;
+	int counter = 0;
+
+	std::vector<SmartPointer<ObjectTypeHeader>> objects;
+
+	//Read entire level file.
+	Loader loader;
+	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
+
+	//Read format version
+	FormatVersion levelFormatVersion;
+	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
+	counter += sizeof(levelFormatVersion);
+	if(this->formatVersion != levelFormatVersion)
+	{
+		//Do something if it's not the same version
+	}
+
+  	while(counter < bufferSize)
+	{
+		//Get typeID
+		ObjectTypeHeader typeID;
+		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
+		switch((int)typeID.typeID)
+		{
+			case ObjectType_LevelMetaData:
+			{
+				LevelMetaData* header = new LevelMetaData;
+				ParseLevelMetaData(&buffer[counter], *header, counter);
+				objects.push_back(header);
+				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 = new ObjectHeader;
+				ParseObject(&buffer[counter], *header, counter);
+				objects.push_back(header);
+				break;
+			}
+			
+			case ObjectType_Light:
+			{
+				LightType lightType;
+
+				//Get Light type
+				ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
+
+				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
+	FormatVersion levelFormatVersion;
+	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(formatVersion));
+	counter += sizeof(levelFormatVersion);
+	if(this->formatVersion != levelFormatVersion)
+	{
+		//Do something if it's not the same version
+	}
+
+	//Find the header in the returned string.
+	while(counter < bufferSize)
+	{
+		ObjectTypeHeader typeID;
+		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
+
+		switch(typeID.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);
+			break;
+		}
+
+		case ObjectType_Light:
+		{
+			LightType lightType;
+			ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
+
+			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/DanBiasGame/GameClientState/LevelLoader/LevelParser.h

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

Code/Game/DanBiasGame/GameClientState/LevelLoader/Loader.cpp

@@ -0,0 +1,22 @@
+//////////////////////////////////
+// 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::string 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(temp.c_str(), Oyster::Resource::ResourceType::ResourceType_Byte_Raw, -1 , false);
+
+	size = OysterResource::GetResourceSize(buffer);
+	return buffer;
+}

Code/Game/DanBiasGame/GameClientState/LevelLoader/Loader.h

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

Code/Game/DanBiasGame/GameClientState/LevelLoader/ObjectDefines.h

@@ -0,0 +1,172 @@
+#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,
+		//Etc
+
+		ObjectType_NUM_OF_TYPES,
+
+		ObjectType_Unknown = -1
+	};
+
+	enum UsePhysics
+	{
+		UsePhysics_UseFullPhysics,
+		UsePhysics_IgnoreGravity,
+		UsePhysics_IgnorePhysics,
+		UsePhysics_IgnoreCollision,
+
+		UsePhysics_Count,
+		UsePhysics_Unknown = -1
+	};
+
+	enum CollisionGeometryType
+	{
+		CollisionGeometryType_Box,
+		CollisionGeometryType_Sphere,
+
+		CollisionGeometryType_Count,
+		CollisionGeometryType_Unknown = -1
+	};
+
+	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
+	*************************************/
+
+	struct FormatVersion
+	{
+		unsigned int formatVersionMajor;
+		unsigned int formatVersionMinor;
+
+		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;
+	};
+
+	struct PhysicsObject
+	{
+		UsePhysics usePhysics;
+		float mass;
+		float inertiaMagnitude[3];
+		float inertiaRotation[3];
+		float frictionCoeffStatic;
+		float frictionCoeffDynamic;
+		CollisionGeometryType geometryType;
+	};
+
+	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;
+	};
+
+	struct ObjectHeader : public ObjectTypeHeader, public PhysicsObject
+	{
+		//Model,
+		std::string ModelFile;
+		//Position
+		float position[3];
+		//Rotation
+		float rotation[3];
+		float angle;
+		//Scale
+		float scale[3];
+	};
+
+
+	/************************************
+				Lights
+	*************************************/
+
+	struct BasicLight : public ObjectTypeHeader
+	{
+		LightType lightType;
+		float ambientColor[3];
+		float diffuseColor[3];
+		float specularColor[3];
+	};
+
+	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/DanBiasGame/GameClientState/LevelLoader/ParseFunctions.cpp

@@ -0,0 +1,111 @@
+//////////////////////////////////
+// Created by Sam Svensson 2013 //
+//////////////////////////////////
+
+#include "ParseFunctions.h"
+#include "../../../../Misc/Packing/Packing.h"
+#include <string>
+
+using namespace Oyster::Packing;
+using namespace GameLogic::LevelFileLoader;
+using namespace GameLogic;
+using namespace std;
+
+namespace GameLogic
+{
+	namespace LevelFileLoader
+	{
+		void ParseObject(char* buffer, void *header, int size)
+		{
+			memcpy(header, buffer, size);
+		}
+
+		void ParseObject(char* buffer, ObjectHeader& header, int& size)
+		{
+			char tempName[128];
+			unsigned int tempSize = 0;
+			int start = 0;
+
+			memcpy(&header.typeID, &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;
+
+			//3 float[3], 1 float
+			memcpy(&header.position, &buffer[start], 40);
+			start += 40;
+
+			//2 float[3], 3 float, 2 uint
+			memcpy(&header.usePhysics, &buffer[start], 44);
+			start += 44;
+
+			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 < tempSize; i++)
+			{
+				memcpy(&temp, &buffer[start], 4);
+				start += 4;
+				header.gameModesSupported.push_back((GameMode)temp);
+			}
+
+			size += start;
+		}
+	}
+}

Code/Game/DanBiasGame/GameClientState/LevelLoader/ParseFunctions.h

@@ -0,0 +1,28 @@
+//////////////////////////////////
+// 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);
+		void ParseLevelMetaData(char* buffer, LevelMetaData &header, int &size);
+	}
+}
+
+
+#endif

Code/Game/DanBiasGame/GameClientState/LobbyState.cpp

@@ -5,6 +5,7 @@
 #include "C_obj/C_StaticObj.h"
 #include "C_obj/C_DynamicObj.h"
 #include <GameServerAPI.h>
+#include <Protocols.h>
 
 using namespace DanBias::Client;
 
@@ -53,17 +54,18 @@ bool LobbyState::LoadModels(std::wstring file)
 
 	ModelInitData modelData;
 
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.position = Oyster::Math::Float3(0,0,0);
+	modelData.rotation = Oyster::Math::Quaternion::identity;
+	modelData.scale =  Oyster::Math::Float3(1,1,1);
 	modelData.visible = true;
-	modelData.modelPath = L"..\\Content\\Models\\box_2.dan";
+	modelData.modelPath = L"crate_colonists.dan";
 	// load models
 	privData->object[0] = new C_StaticObj();
 	privData->object[0]->Init(modelData);
 
-	Oyster::Math3D::Float4x4 translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(2,2,2));
+	modelData.position = Oyster::Math::Float3(2,2,2);
-	modelData.world = modelData.world * translate;
 
-	privData->object[1] = new C_DynamicObj();
+	privData->object[1] = new C_StaticObj();
 	privData->object[1]->Init(modelData);
 	return true;
 }
@@ -88,9 +90,15 @@ GameClientState::ClientState LobbyState::Update(float deltaTime, InputClass* Key
 	// send data to server
 	// check data from server
 
-	if( KeyInput->IsKeyPressed(DIK_G)) 
+	if(GameServerAPI::ServerIsRunning() && GameServerAPI::ServerIsRunning())	//May be a problem if server is not shut down properly after lan session.
 	{
-		return ClientState_Game;
+		if( KeyInput->IsKeyPressed(DIK_G)) 
+		{
+			if(!DanBias::GameServerAPI::GameStart())
+			{
+				//this->nwClient->Send(GameLogic::Protocol_LobbyStartGame());
+			}
+		}
 	}
 	  
 	return ClientState_Same;

Code/Game/DanBiasGame/GameClientState/LoginState.cpp

@@ -53,26 +53,18 @@ bool LoginState::LoadModels(std::wstring file)
 
 	ModelInitData modelData;
 
-	modelData.world = Oyster::Math3D::Float4x4::identity;
+	modelData.rotation = Oyster::Math::Quaternion::identity;
+	modelData.scale =  Oyster::Math::Float3(1,1,1);
 	modelData.visible = true;
-	modelData.modelPath = L"identityPlane.dan";
+	modelData.modelPath = L"box.dan";
-	// load models
+	
-	Oyster::Math3D::Float4x4 translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(2,2,-2));
-	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0));
-	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::Float4x4::identity;
-	int scaling = 2;
-	scale.v[0].x = scaling;
-	scale.v[1].y = scaling;
-	scale.v[2].z = scaling;
 
-	modelData.world = translate; //scale * translate * rot;
+	modelData.position = Oyster::Math::Float3(2,2,2);
-	privData->object[0] = new C_DynamicObj();
+	privData->object[0] = new C_StaticObj();
 	privData->object[0]->Init(modelData);
 
-	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(0,0,-2));
+	modelData.position = Oyster::Math::Float3(-2,0,-2);
-	modelData.world = translate ;//* rot;
+	privData->object[1] = new C_StaticObj();
-
-	privData->object[1] = new C_DynamicObj();
 	privData->object[1]->Init(modelData);
 	return true;
 }
@@ -105,7 +97,7 @@ GameClientState::ClientState LoginState::Update(float deltaTime, InputClass* Key
 		DanBias::GameServerAPI::ServerInitiate(desc);
 		DanBias::GameServerAPI::ServerStart();
 		// my ip
-		nwClient->Connect(15151, "127.0.0.1");
+		nwClient->Connect(15152, "127.0.0.1");
 
 		if (!nwClient->IsConnected())
 		{
@@ -118,7 +110,7 @@ GameClientState::ClientState LoginState::Update(float deltaTime, InputClass* Key
 	if( KeyInput->IsKeyPressed(DIK_J)) 
 	{
 		// game ip
-		nwClient->Connect(15151, "127.0.0.1");
+		nwClient->Connect(15152, "127.0.0.1");
 
 		if (!nwClient->IsConnected())
 		{

Code/Game/GameLogic/AttatchmentMassDriver.cpp

@@ -64,11 +64,11 @@ void AttatchmentMassDriver::Update(float dt)
 		state = heldObject->GetState();
 		Oyster::Math::Float3 ownerPos = owner->GetPosition();
 		Oyster::Physics::ICustomBody::State ownerState =  owner->GetRigidBody()->GetState();
-		Oyster::Math::Float3  up = -ownerState.GetGravityNormal();
+		Oyster::Math::Float3  up = -ownerState.GetOrientation().v[2];
 		up *= -0.3;
 		Oyster::Math::Float3 pos = ownerPos + up + (owner->GetLookDir().GetNormalized()*5);
 
-		state.SetCenterPosition(pos);
+		state.centerPos = pos;
 
 		heldObject->SetState(state);
 	}
@@ -88,7 +88,7 @@ void AttatchmentMassDriver::ForcePush(const GameLogic::WEAPON_FIRE &usage, float
 		Oyster::Physics::API::Instance().ReleaseFromLimbo(heldObject);
 		pushForce = Oyster::Math::Float4(this->owner->GetLookDir()) * (700);
 		Oyster::Physics::ICustomBody::State state = heldObject->GetState();
-		state.ApplyLinearImpulse((Oyster::Math::Float3)pushForce);
+		//state.ApplyLinearImpulse((Oyster::Math::Float3)pushForce);
 		heldObject->SetState(state);
 		
 		hasObject = false;
@@ -118,7 +118,7 @@ void AttatchmentMassDriver::ForceZip(const WEAPON_FIRE &usage, float dt)
 	Oyster::Physics::Struct::CustomBodyState state = this->owner->GetRigidBody()->GetState();
 
 	//do something with state
-	state.ApplyLinearImpulse(Oyster::Math::Float3(this->owner->GetLookDir()) * (500 * dt));
+	//state.ApplyLinearImpulse(Oyster::Math::Float3(this->owner->GetLookDir()) * (500 * dt));
 
 	this->owner->GetRigidBody()->SetState(state);
 }
@@ -135,7 +135,7 @@ void AttatchmentMassDriver::ForcePull(const WEAPON_FIRE &usage, float dt)
 
 	//if no object has been picked up then suck objects towards you
 	Oyster::Math::Float4 pushForce = Oyster::Math::Float4(this->owner->GetLookDir()) * (100 * dt);
-	Oyster::Math::Float4x4 aim = Oyster::Math3D::ViewMatrix_LookAtDirection(owner->GetLookDir(), owner->GetRigidBody()->GetGravityNormal(), owner->GetPosition());
+	Oyster::Math::Float4x4 aim = Oyster::Math3D::ViewMatrix_LookAtDirection(owner->GetLookDir(), owner->GetRigidBody()->GetState().GetOrientation().v[2].xyz, owner->GetPosition());
 
 	Oyster::Math::Float4x4 hitSpace = Oyster::Math3D::ProjectionMatrix_Perspective(Oyster::Math::pi/4,1,1,20); 
 	Oyster::Collision3D::Frustrum hitFrustum = Oyster::Collision3D::Frustrum(Oyster::Math3D::ViewProjectionMatrix(aim,hitSpace));

Code/Game/GameLogic/AttatchmentSocket.cpp

@@ -14,7 +14,10 @@ AttatchmentSocket::AttatchmentSocket(void)
 
 AttatchmentSocket::~AttatchmentSocket(void)
 {
-	
+	if(this->attatchment)
+		delete this->attatchment;
+
+	this->attatchment = 0;
 }
 
 IAttatchment* AttatchmentSocket::GetAttatchment()

Code/Game/GameLogic/CollisionManager.cpp

@@ -68,7 +68,7 @@ using namespace GameLogic;
 		Oyster::Physics::ICustomBody::State state;
 
 		state = obj.GetState();
-		state.ApplyLinearImpulse(force);
+		//state.ApplyLinearImpulse(force);
 		obj.SetState(state);
 	}
 	
@@ -83,7 +83,7 @@ using namespace GameLogic;
 
 		if(kineticEnergyLoss > forceThreashHold) //should only take damage if the force is high enough
 		{
-			damageDone = kineticEnergyLoss * 0.10f;
+			damageDone = (int)(kineticEnergyLoss * 0.10f);
 			//player.DamageLife(damageDone);
 		}
 		
@@ -130,7 +130,7 @@ using namespace GameLogic;
 			return;
 
 		state = obj->GetState();
-		state.ApplyLinearImpulse(((forcePushData*)(args))->pushForce);
+		//state.ApplyLinearImpulse(((forcePushData*)(args))->pushForce);
 		obj->SetState(state);
 	}
 

Code/Game/GameLogic/Game.cpp

@@ -68,12 +68,12 @@ void Game::GetAllPlayerPositions() const
 Game::PlayerData* Game::CreatePlayer()
 {
 	// Find a free space in array or insert at end
-	int id = InsertObject(this->players, (PlayerData*)0);
+	int i = InsertObject(this->players, (PlayerData*)0);
 
-	this->players[id] = new PlayerData();
+	this->players[i] = new PlayerData();
-	this->players[id]->player->GetRigidBody()->SetSubscription(Game::PhysicsOnMove);
+	this->players[i]->player->GetRigidBody()->SetSubscription(Game::PhysicsOnMove);
 
-	return this->players[id];
+	return this->players[i];
 }
 
 Game::LevelData* Game::CreateLevel()
@@ -82,6 +82,7 @@ Game::LevelData* Game::CreateLevel()
 
 	this->level = new LevelData();
 	this->level->level->InitiateLevel(1000);
+	//this->level->level->InitiateLevel("3bana.bias");
 
 	return this->level;
 }
@@ -93,42 +94,23 @@ void Game::CreateTeam()
 
 bool Game::NewFrame()
 {
-
 	for (unsigned int i = 0; i < this->players.Size(); i++)
 	{
 		if(this->players[i]->player)	this->players[i]->player->BeginFrame();
 	}
 
-	API::Instance().Update();
+	API::Instance().UpdateWorld();
 
 	for (unsigned int i = 0; i < this->players.Size(); i++)
 	{
 		if(this->players[i]->player)	this->players[i]->player->EndFrame();
+		gameInstance.onMoveFnc(this->players[i]);
 	}
-	for (unsigned int i = 0; i < this->players.Size(); i++)
+	for (unsigned int i = 0; i < this->level->level->dynamicObjects.Size(); i++)
 	{
-		if(this->players[i]->player)	this->players[i]->player->BeginFrame();
+		gameInstance.onMoveFnc(this->level->level->dynamicObjects[i]);
 	}
-
+	
-	API::Instance().Update();
-
-	for (unsigned int i = 0; i < this->players.Size(); i++)
-	{
-		if(this->players[i]->player)	this->players[i]->player->EndFrame();
-	}
-	for (unsigned int i = 0; i < this->players.Size(); i++)
-	{
-		if(this->players[i]->player)	this->players[i]->player->BeginFrame();
-	}
-
-	API::Instance().Update();
-
-	for (unsigned int i = 0; i < this->players.Size(); i++)
-	{
-		if(this->players[i]->player)	this->players[i]->player->EndFrame();
-	}
-
-	gameInstance.onMoveFnc(this->level);
 
 	return true;
 }
@@ -143,24 +125,21 @@ void Game::SetFrameTimeLength( float seconds )
 	this->frameTime = seconds;
 }
 
-void Game::SetSubscription(GameEvent::ObjectEventFunctionType type, GameEvent::ObjectEventFunction functionPointer)
+void Game::SetSubscription(GameEvent::ObjectMovedFunction functionPointer)
 {
-	switch (type)
+	this->onMoveFnc = functionPointer;
-	{
+}
-		case GameLogic::GameEvent::ObjectEventFunctionType_OnMove:
+void Game::SetSubscription(GameEvent::ObjectDisabledFunction functionPointer)
-			this->onMoveFnc = functionPointer;
+{
-		break;
+	this->onDisableFnc = functionPointer;
-		case GameLogic::GameEvent::ObjectEventFunctionType_OnDead:
+
-			this->onDisableFnc = functionPointer;
-		break;
-	}
-	
 }
 
 bool Game::Initiate()
 {
-	API::Instance().Init((int)pow(2u, 9u), 1u, Oyster::Math::Float3());
+	API::Instance().Init();
-	API::Instance().SetSubscription(Game::PhysicsOnDestroy);
+	//API::Instance().SetSubscription(Game::PhysicsOnDestroy);
+	//API::Instance().SetFrameTimeLength(this->frameTime);
 	this->initiated = true;
 	return true;
 }
@@ -183,6 +162,6 @@ void Game::PhysicsOnMove(const ICustomBody *object)
 }
 void Game::PhysicsOnDestroy(::Utility::DynamicMemory::UniquePointer<ICustomBody> proto)
 {
-	if(gameInstance.onDisableFnc) gameInstance.onDisableFnc(0);
+	if(gameInstance.onDisableFnc) gameInstance.onDisableFnc(0, 0);
 }
 

Code/Game/GameLogic/Game.h

@@ -69,7 +69,8 @@ namespace GameLogic
 		bool NewFrame()																									override;
 		void SetFPS( int FPS )																							override;
 		void SetFrameTimeLength( float seconds )																		override;
-		void SetSubscription(GameEvent::ObjectEventFunctionType type, GameEvent::ObjectEventFunction functionPointer)	override;
+		void SetSubscription(GameEvent::ObjectMovedFunction functionPointer)											override;
+		void SetSubscription(GameEvent::ObjectDisabledFunction functionPointer)											override;
 		bool Initiate()																									override;
 
 		float GetFrameTime() const;
@@ -81,8 +82,8 @@ namespace GameLogic
 		LevelData* level;
 		float frameTime;
 		bool initiated;
-		GameEvent::ObjectEventFunction onDisableFnc;
+		GameEvent::ObjectDisabledFunction onDisableFnc;
-		GameEvent::ObjectEventFunction onMoveFnc;
+		GameEvent::ObjectMovedFunction onMoveFnc;
 
 	};	
 }

Code/Game/GameLogic/GameAPI.h

@@ -23,16 +23,8 @@ namespace GameLogic
 	*/
 	namespace GameEvent
 	{
-		/**
+		typedef void(*ObjectMovedFunction)(IObjectData* object);	// Callback method that recieves and object
-		*	The type of event to listen on.
+		typedef void(*ObjectDisabledFunction)(IObjectData* object, float seconds);	// Callback method that recieves and object
-		*/
-		enum ObjectEventFunctionType
-		{
-			ObjectEventFunctionType_OnMove,
-			ObjectEventFunctionType_OnDead,
-		};
-
-		typedef void(*ObjectEventFunction)(IObjectData* object);	// Callback method that recieves and object
 		//etc...
 	};
 
@@ -147,17 +139,22 @@ namespace GameLogic
 		/**	Set the frame time in fps
 		*	@param FPS The fps to set
 		*/
-		virtual void SetFPS( int FPS = 60 ) = 0;
+		virtual void SetFPS( int FPS = 120 ) = 0;
 
 		/**	Set the frames time in seconds
 		*	@param seconds The frame length
 		*/
-		virtual void SetFrameTimeLength( float seconds ) = 0;
+		virtual void SetFrameTimeLength( float seconds = (1.0f/120.0f) ) = 0;
 
 		/**	Set a specific object event subscription callback
 		*	@param 
 		*/
-		virtual void SetSubscription(GameEvent::ObjectEventFunctionType type, GameEvent::ObjectEventFunction functionPointer) = 0;
+		virtual void SetSubscription(GameEvent::ObjectMovedFunction functionPointer) = 0;
+
+		/**	Set a specific object event subscription callback
+		*	@param 
+		*/
+		virtual void SetSubscription(GameEvent::ObjectDisabledFunction functionPointer) = 0;
 
 	};	
 }

Code/Game/GameLogic/GameLogic.vcxproj

@@ -181,7 +181,7 @@
     <ClInclude Include="GameAPI.h" />
     <ClInclude Include="GameLogicDef.h" />
     <ClInclude Include="GameLogicStates.h" />
-    <ClInclude Include="GameMode.h" />
+    <ClInclude Include="GameModeType.h" />
     <ClInclude Include="IAttatchment.h" />
     <ClInclude Include="JumpPad.h" />
     <ClInclude Include="Level.h" />
@@ -203,7 +203,7 @@
     <ClCompile Include="CollisionManager.cpp" />
     <ClCompile Include="DynamicObject.cpp" />
     <ClCompile Include="Game.cpp" />
-    <ClCompile Include="GameMode.cpp" />
+    <ClCompile Include="GameModeType.cpp" />
     <ClCompile Include="Game_LevelData.cpp" />
     <ClCompile Include="Game_PlayerData.cpp" />
     <ClCompile Include="IAttatchment.cpp" />

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/GameMode.cpp

@@ -1,15 +0,0 @@
-#include "GameMode.h"
-
-using namespace GameLogic;
-
-
-GameMode::GameMode()
-{
-
-}
-
-
-GameMode::~GameMode(void)
-{
-
-}

Code/Game/GameLogic/GameModeType.cpp

@@ -0,0 +1,15 @@
+#include "GameModeType.h"
+
+using namespace GameLogic;
+
+
+GameModeType::GameModeType()
+{
+
+}
+
+
+GameModeType::~GameModeType(void)
+{
+
+}

Code/Game/GameLogic/GameModeType.h

@@ -3,16 +3,16 @@
 //////////////////////////////////////////////////
 
 
-#ifndef GAMEMODE_H
+#ifndef GAMEMODETYPE_H
-#define GAMEMODE_H
+#define GAMEMODETYPE_H
 
 namespace GameLogic
 {
-	class GameMode
+	class GameModeType
 	{
 		public:
-			GameMode(void);
+			GameModeType(void);
-			~GameMode(void);
+			~GameModeType(void);
 
 		private:
 

Code/Game/GameLogic/Game_PlayerData.cpp

@@ -6,26 +6,26 @@ using namespace GameLogic;
 Game::PlayerData::PlayerData()
 {	
 	//set some stats that are appropriate to a player
-	Oyster::Physics::API::SimpleBodyDescription sbDesc;
+	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(0,608,-5);
-	sbDesc.centerPosition = Oyster::Math::Float3(0,308,0);
+	Oyster::Math::Float3 size = Oyster::Math::Float3(0.25f,1.0f,0.5f);
-	sbDesc.size = Oyster::Math::Float3(0.5f,2,1);
+	Oyster::Math::Float mass = 15;
-	sbDesc.mass = 70;
+	Oyster::Math::Float restitutionCoeff = 0.5;
-	sbDesc.restitutionCoeff = 0.5;
+	Oyster::Math::Float frictionCoeff_Static = 0.4;
-	sbDesc.frictionCoeff_Static = 0.4;
+	Oyster::Math::Float frictionCoeff_Dynamic = 0.3;
-	sbDesc.frictionCoeff_Dynamic = 0.3;
+	//sbDesc.quaternion = Oyster::Math::Float3(0, Oyster::Math::pi, 0);
-	sbDesc.rotation = Oyster::Math::Float3(0, Oyster::Math::pi, 0);
 
 	//create rigid body
-	Oyster::Physics::ICustomBody *rigidBody = Oyster::Physics::API::Instance().CreateRigidBody(sbDesc).Release();
+	Oyster::Physics::ICustomBody* rigidBody = Oyster::Physics::API::Instance().AddCollisionBox(size, Oyster::Math::Float4(0, 0, 0, 1), centerPosition, mass, 0.5f, 0.8f, 0.6f );
 	
 	//create player with this rigid body
-	this->player = new Player(rigidBody,Player::PlayerCollisionBefore, Player::PlayerCollision, OBJECT_TYPE::OBJECT_TYPE_PLAYER);
+	this->player = new Player(rigidBody,Level::LevelCollisionBefore, Player::PlayerCollision, OBJECT_TYPE::OBJECT_TYPE_PLAYER);
 	this->player->GetRigidBody()->SetCustomTag(this);
-	/*Oyster::Physics::ICustomBody::State state;
+
-	this->player->GetRigidBody()->GetState(state);
+	//Oyster::Physics::ICustomBody::State state;
-	state.SetRotation(Oyster::Math::Float3(0, Oyster::Math::pi, 0));
+	//this->player->GetRigidBody()->GetState(state);
-	this->player->GetRigidBody()->SetState(state);
+	////state.SetRotation(Oyster::Math::Float3(0, Oyster::Math::pi, 0));
-	player->EndFrame();*/
+	//this->player->GetRigidBody()->SetState(state);
+	player->EndFrame();
 }
 Game::PlayerData::PlayerData(int playerID,int teamID)
 {

Code/Game/GameLogic/Level.cpp

@@ -1,5 +1,6 @@
 #include "Level.h"
 #include "CollisionManager.h"
+#include "Game.h"
 
 using namespace GameLogic;
 using namespace Utility::DynamicMemory;
@@ -12,11 +13,188 @@ Level::Level(void)
 }
 Level::~Level(void)
 {
+	delete this->levelObj;
+	this->levelObj = NULL;
 }
+void Level::parseObjectType(ObjectTypeHeader* obj)
+{
+	/*switch (obj->objectTypeID)
+	{
+	case skySphere: 
+		// save the skysphere to be able to rotate it 
+		break;
+	case jumppad: 
+		// save direction 
+		break;
+	case portal: 
+		// save portal destination 
+		break;
+	case world: 
+		// add gravitation well here
+		// add outer limit of the world
+	case spawn: 
+		// save spawnpoint pos 
+		break;
 
+	default:
+		break;
+	}*/
+}
+void Level::parsePhysicsObj(LevelLoaderInternal::BoundingVolumeBase* obj)
+{
+	// offset physObj med modelObj
+}
 void Level::InitiateLevel(std::string levelPath)
 {
+	LevelLoader ll; 
+	std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> objects; 
+	objects = ll.LoadLevel(levelPath);
+	int objCount = objects.size();
+	int modelCount = 0;
+	for (int i = 0; i < objCount; i++)
+	{
+		ObjectTypeHeader* obj = objects.at(i);
+		int id = obj->typeID;
+		switch (obj->typeID)
+		{
+		case ObjectType::ObjectType_LevelMetaData:
+			{
+				LevelMetaData* LevelObjData = ((LevelMetaData*)obj);
+				std::string levelName = LevelObjData->levelName;
+				// LevelObjData->worldSize;
+			}
+			break;
+		case ObjectType::ObjectType_Static:
+			{
+				
+				ObjectHeader* staticObjData = ((ObjectHeader*)obj);
+				//LevelLoaderInternal::BoundingVolumeBase* staticObjPhysicData = ((ObjectHeader*)obj);
+				staticObjData->ModelFile;
 
+				ICustomBody* rigidBody_Static;			
+				//if( staticObjPhysicData->geometryType = CollisionGeometryType_Box)
+				//{
+				//	//API::SimpleBodyDescription sbDesc_Static;
+			
+				//	//sbDesc_Static.centerPosition = staticObjData->position;
+				//	//sbDesc_Static.ignoreGravity = false; // because it is static
+				//	//sbDesc_Static.rotation = Oyster::Math::Float3(staticObjData->rotation[0], staticObjData->rotation[1],staticObjData->rotation[2]);//Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0);
+
+
+				//	////sbDesc_Static.inertiaTensor.Cuboid(staticObjPhysicData->mass); 	
+				//	//sbDesc_Static.mass = staticObjPhysicData->mass;
+				//	//sbDesc_Static.frictionCoeff_Static = staticObjPhysicData->frictionCoeffStatic;
+				//	//sbDesc_Static.frictionCoeff_Dynamic = staticObjPhysicData->frictionCoeffDynamic;
+				//	////sbDesc_Static.restitutionCoeff = 
+				//	//sbDesc_Static.size = Oyster::Math::Float3(40,40,40); 
+				//	//rigidBody_Static = API::Instance().CreateRigidBody(sbDesc_Static).Release();
+				//	//if(rigidBody_Static)
+				//	//{
+				//	//	this->staticObjects.Push(new StaticObject(rigidBody_Static,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_GENERIC));
+				//	//	int id = this->staticObjects.Size()-1;
+				//	//	rigidBody_Static->SetCustomTag(this->staticObjects[this->staticObjects.Size()-1]);
+				//	//}
+				//}
+				//if( staticObjPhysicData->geometryType = CollisionGeometryType_Sphere)
+				//{
+				//	//API::SphericalBodyDescription sbDesc_Static;
+
+				//	//sbDesc_Static.centerPosition = staticObjData->position;
+				//	//sbDesc_Static.ignoreGravity = true; // because it is static
+				//	//sbDesc_Static.rotation = Oyster::Math::Float3(staticObjData->rotation[0], staticObjData->rotation[1],staticObjData->rotation[2]);//Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0);
+
+				//	////sbDesc_Static.inertiaTensor.Sphere(staticObjPhysicData->mass); 
+	
+				//	//sbDesc_Static.mass = staticObjPhysicData->mass;
+				//	//sbDesc_Static.frictionCoeff_Static = staticObjPhysicData->frictionCoeffStatic;
+				//	//sbDesc_Static.frictionCoeff_Dynamic = staticObjPhysicData->frictionCoeffDynamic;
+				//	////sbDesc_Static.restitutionCoeff = 
+				//	////sbDesc_Static.radius = 
+				//	//rigidBody_Static = API::Instance().CreateRigidBody(sbDesc_Static).Release();
+				//	if(rigidBody_Static)
+				//	{
+				//		this->staticObjects.Push(new StaticObject(rigidBody_Static,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_GENERIC));
+				//		int id = this->staticObjects.Size()-1;
+				//		rigidBody_Static->SetCustomTag(this->staticObjects[this->staticObjects.Size()-1]);
+				//	}
+
+				//	if (OBJECT_TYPE::OBJECT_TYPE_WORLD)
+				//	{
+				//		/*API::Gravity gravityWell;
+				//		gravityWell.gravityType = API::Gravity::GravityType_Well;
+				//		gravityWell.well.mass = 1e17f;
+				//		gravityWell.well.position = Oyster::Math::Float4(0,0,0,1);
+				//		API::Instance().AddGravity(gravityWell);*/
+				//	}
+				//}
+			}
+			break;
+		case ObjectType::ObjectType_Dynamic:
+			{
+				ObjectHeader* staticObjData = ((ObjectHeader*)obj);
+				//LevelLoaderInternal::BoundingVolumeBase* staticObjPhysicData = ((ObjectHeader*)obj);
+				staticObjData->ModelFile;
+
+				ICustomBody* rigidBody_Dynamic;			
+				//if( staticObjPhysicData->geometryType = CollisionGeometryType_Box)
+				//{
+				//	//API::Instance().AddCollisionBox() 
+				//	//API::SimpleBodyDescription sbDesc_Dynamic;
+
+				//	//sbDesc_Dynamic.centerPosition = staticObjData->position;
+				//	//sbDesc_Dynamic.ignoreGravity = false; // because it is static
+				//	//sbDesc_Dynamic.rotation = Oyster::Math::Float3(staticObjData->rotation[0], staticObjData->rotation[1],staticObjData->rotation[2]);//Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0);
+
+
+				//	////sbDesc_Static.inertiaTensor.Cuboid(staticObjPhysicData->mass); 	
+				//	//sbDesc_Dynamic.mass = staticObjPhysicData->mass;
+				//	//sbDesc_Dynamic.frictionCoeff_Static = staticObjPhysicData->frictionCoeffStatic;
+				//	//sbDesc_Dynamic.frictionCoeff_Dynamic = staticObjPhysicData->frictionCoeffDynamic;
+				//	////sbDesc_Static.restitutionCoeff = 
+				//	//sbDesc_Dynamic.size = Oyster::Math::Float3(40,40,40); 
+				//	//rigidBody_Dynamic = API::Instance().CreateRigidBody(sbDesc_Dynamic).Release();
+				//	//if(rigidBody_Dynamic)
+				//	//{
+				//	//	rigidBody_Dynamic->SetSubscription(Level::PhysicsOnMoveLevel);
+				//	//	this->dynamicObjects.Push(new DynamicObject(rigidBody_Dynamic,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_GENERIC));
+				//	//	int id = this->dynamicObjects.Size()-1;
+				//	//	rigidBody_Dynamic->SetCustomTag(this->dynamicObjects[this->dynamicObjects.Size()-1]);
+				//	//}
+				//}
+				//if( staticObjPhysicData->geometryType = CollisionGeometryType_Sphere)
+				//{
+				//	//API::Instance().AddCollisionBox() 
+				//	//API::SphericalBodyDescription sbDesc_Dynamic;
+
+				//	//sbDesc_Dynamic.centerPosition = staticObjData->position;
+				//	//sbDesc_Dynamic.ignoreGravity = false; // use gravity on dynamic obj
+				//	//sbDesc_Dynamic.rotation = Oyster::Math::Float3(staticObjData->rotation[0], staticObjData->rotation[1],staticObjData->rotation[2]);//Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0);
+
+				//	////sbDesc_Static.inertiaTensor.Sphere(staticObjPhysicData->mass); 
+
+				//	//sbDesc_Dynamic.mass = staticObjPhysicData->mass;
+				//	//sbDesc_Dynamic.frictionCoeff_Static = staticObjPhysicData->frictionCoeffStatic;
+				//	//sbDesc_Dynamic.frictionCoeff_Dynamic = staticObjPhysicData->frictionCoeffDynamic;
+				//	////sbDesc_Static.restitutionCoeff = 
+				//	////sbDesc_Static.radius = 
+				//	//rigidBody_Dynamic = API::Instance().CreateRigidBody(sbDesc_Dynamic).Release();
+				//	//if(rigidBody_Dynamic)
+				//	//{
+				//	//	rigidBody_Dynamic->SetSubscription(Level::PhysicsOnMoveLevel);
+				//	//	this->dynamicObjects.Push(new DynamicObject(rigidBody_Dynamic,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_GENERIC));
+				//	//	int id = this->dynamicObjects.Size()-1;
+				//	//	rigidBody_Dynamic->SetCustomTag(this->dynamicObjects[this->dynamicObjects.Size()-1]);
+				//	//}
+				//}
+			}
+			break;
+		case ObjectType::ObjectType_Light:
+			// read on client
+			break;
+		default:
+			break;
+		}
+	}
 }
 void Level::InitiateLevel(float radius)
 {
@@ -50,33 +228,12 @@ void Level::InitiateLevel(float radius)
 		z /= norm;
 	}
 
+	int idCount = 100;
 	// add level sphere
-	API::SphericalBodyDescription sbDesc;
+	ICustomBody* rigidBody = API::Instance().AddCollisionSphere(599.2f, Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(0, 0, 0), 0, 0.5f, 0.8f, 0.6f);
-	sbDesc.centerPosition = Oyster::Math::Float4(0,0,0,1);
-	sbDesc.ignoreGravity = true;
-	sbDesc.radius = 300; 
-	sbDesc.mass = 10e12f;
-	sbDesc.frictionCoeff_Static = 0;
-	sbDesc.frictionCoeff_Dynamic = 0;
-	//sbDesc.rotation = 
-	ICustomBody* rigidBody = API::Instance().CreateRigidBody(sbDesc).Release();
-	
-	ICustomBody::State state;
-	rigidBody->GetState(state);
-	state.SetRestitutionCoeff(0.2);
-	rigidBody->SetState(state);
-	
 	levelObj = new StaticObject(rigidBody, LevelCollisionBefore, LevelCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_WORLD);
+	this->levelObj->objectID = idCount++;
 	rigidBody->SetCustomTag(levelObj);
-	
-	//this->dynamicObjects = new DynamicArray< DynamicObject>;
-	// add box
-	API::SimpleBodyDescription sbDesc_TestBox;
-	sbDesc_TestBox.centerPosition = Oyster::Math::Float4(10,320,0,0);
-	sbDesc_TestBox.ignoreGravity = false;
-
-	sbDesc_TestBox.mass = 50;
-	sbDesc_TestBox.size = Oyster::Math::Float4(2,2,2,0);
 
 	
 	ICustomBody* rigidBody_TestBox;
@@ -85,85 +242,57 @@ void Level::InitiateLevel(float radius)
 	int offset = 0;
 	for(int i =0; i< nrOfBoxex; i ++)
 	{
-		sbDesc_TestBox.centerPosition = Oyster::Math::Float4(-20 +( i*7) ,320,20,0);
+		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, 605 + i*5, 10), 5, 0.5f, 0.8f, 0.6f);
-		rigidBody_TestBox = API::Instance().CreateRigidBody(sbDesc_TestBox).Release();
+
-		rigidBody_TestBox->SetSubscription(Level::PhysicsOnMoveLevel);
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+		this->dynamicObjects[i]->objectID = idCount++;
+		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i]);
+	}
+	/*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));
+		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);
+		
+	}
+	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(200, 620 + ( i*7), 0), 5);
+
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);	
+	}
+	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(5, 605 + i*5, 0), 5);
 
 		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
 		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i]);
-	}
+		
-	offset += nrOfBoxex;
+	}*/
-	for(int i =0; i< nrOfBoxex; i ++)
-	{
-		sbDesc_TestBox.centerPosition = Oyster::Math::Float4(-20,320, -20 +( i*7),0);
-		rigidBody_TestBox = API::Instance().CreateRigidBody(sbDesc_TestBox).Release();
-		rigidBody_TestBox->SetSubscription(Level::PhysicsOnMoveLevel);
-
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
-		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);
-	}
-	offset += nrOfBoxex;
-	for(int i =0; i< nrOfBoxex; i ++)
-	{
-		sbDesc_TestBox.centerPosition = Oyster::Math::Float4(20,320,-20 + ( i*7),0);
-		rigidBody_TestBox = API::Instance().CreateRigidBody(sbDesc_TestBox).Release();
-		rigidBody_TestBox->SetSubscription(Level::PhysicsOnMoveLevel);
-
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
-		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);
-	}
-	offset += nrOfBoxex;
-	for(int i =0; i< nrOfBoxex; i ++)
-	{
-		sbDesc_TestBox.centerPosition = Oyster::Math::Float4(-20 +( i*7) ,320,-20,0);
-		rigidBody_TestBox = API::Instance().CreateRigidBody(sbDesc_TestBox).Release();
-		rigidBody_TestBox->SetSubscription(Level::PhysicsOnMoveLevel);
-
-		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
-		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i+offset]);
-	}
 	
 
 
 
 
-	// add crystal
+	//// add crystal
-	API::SimpleBodyDescription sbDesc_Crystal;
-	sbDesc_Crystal.centerPosition = Oyster::Math::Float4(10, 305, 0, 0);
-	sbDesc_Crystal.ignoreGravity = false;
-	sbDesc_Crystal.mass = 70;
-	sbDesc_Crystal.size = Oyster::Math::Float4(2,3,2,0);
 
-	ICustomBody* rigidBody_Crystal = API::Instance().CreateRigidBody(sbDesc_Crystal).Release();
+	//ICustomBody* rigidBody_Crystal = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(10, 605, 0), 5);
-	rigidBody_Crystal->SetSubscription(Level::PhysicsOnMoveLevel);
+
-	this->dynamicObjects.Push(new DynamicObject(rigidBody_Crystal,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+	//this->dynamicObjects.Push(new DynamicObject(rigidBody_Crystal,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
-	rigidBody_Crystal->SetCustomTag(this->dynamicObjects[nrOfBoxex]);
+	//rigidBody_Crystal->SetCustomTag(this->dynamicObjects[nrOfBoxex]);
+
+	//
 
 
-	// add house
+	//// add house
-	API::SimpleBodyDescription sbDesc_House;
+	//ICustomBody* rigidBody_House =API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(10, 905, 0), 0);
-	//sbDesc_House.centerPosition = Oyster::Math::Float4(212, 212, 0, 0);
+	//this->staticObjects.Push(new StaticObject(rigidBody_House,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_GENERIC));
-	sbDesc_House.centerPosition = Oyster::Math::Float4(-50, 290, 0, 0);
+	//rigidBody_House->SetCustomTag(this->staticObjects[0]);
-	sbDesc_House.ignoreGravity = false;
-	sbDesc_House.rotation = Oyster::Math::Float3(0 ,Utility::Value::Radian(90.0f), 0);
-	sbDesc_House.mass = 70;
-	sbDesc_House.size = Oyster::Math::Float4(40,40,40,0);
-
-
-	ICustomBody* rigidBody_House = API::Instance().CreateRigidBody(sbDesc_House).Release();
-	rigidBody_House->SetSubscription(Level::PhysicsOnMoveLevel);
-	this->staticObjects.Push(new StaticObject(rigidBody_House,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_GENERIC));
-	rigidBody_House->SetCustomTag(this->staticObjects[0]);
-	rigidBody_House->GetState(state);
-	Oyster::Math::Float4x4 world = state.GetOrientation();
-	
-	
-	// add gravitation 
-	API::Gravity gravityWell;
-	gravityWell.gravityType = API::Gravity::GravityType_Well;
-	gravityWell.well.mass = 1e17f;
-	gravityWell.well.position = Oyster::Math::Float4(0,0,0,1);
-	API::Instance().AddGravity(gravityWell);
 }
 
 void Level::AddPlayerToTeam(Player *player, int teamID)
@@ -198,4 +327,6 @@ void Level::PhysicsOnMoveLevel(const ICustomBody *object)
 {
 	// function call from physics update when object was moved
 	Object* temp = (Object*)object->GetCustomTag();
+	((Game*)&Game::Instance())->onMoveFnc(temp);
+	
 }

Code/Game/GameLogic/Level.h

@@ -8,11 +8,12 @@
 #include "Player.h"
 #include "StaticObject.h"
 #include "DynamicObject.h"
-#include "GameMode.h"
+#include "GameModeType.h"
 #include "Player.h"
 #include "PhysicsAPI.h"
 #include "TeamManager.h"
 #include "DynamicArray.h"
+#include "LevelLoader/LevelLoader.h"
 
 namespace GameLogic
 {
@@ -29,8 +30,10 @@ namespace GameLogic
 		* @param levelPath: Path to a file that contains all information on the level
 		********************************************************/
 		void InitiateLevel(std::string levelPath);
-		void Level::InitiateLevel(float radius);
+		void InitiateLevel(float radius);
 
+		void parseObjectType(ObjectTypeHeader* obj);
+		void parsePhysicsObj(LevelLoaderInternal::BoundingVolumeBase* obj);
 		/********************************************************
 		* Creates a team in the level
 		* @param teamSize: The size of the team you want to create
@@ -65,11 +68,11 @@ namespace GameLogic
 		static void PhysicsOnMoveLevel(const Oyster::Physics::ICustomBody *object);
 		
 
-	private:
+	//private:
 		TeamManager teamManager;
 		Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<StaticObject>> staticObjects;
 		Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<DynamicObject>> dynamicObjects;
-		GameMode gameMode;
+		GameModeType gameMode;
 		Utility::DynamicMemory::SmartPointer<Oyster::Physics::ICustomBody> rigidBodyLevel;
 		StaticObject *levelObj;
 

Code/Game/GameLogic/LevelLoader/LevelLoader.cpp

@@ -17,7 +17,14 @@ struct LevelLoader::PrivData
 LevelLoader::LevelLoader()
 	: pData(new PrivData)
 {
-	pData->folderPath = "Standard path";
+	//standard path
+	pData->folderPath = "";
+}
+
+LevelLoader::LevelLoader(std::string folderPath)
+	: pData(new PrivData)
+{
+	pData->folderPath = folderPath;
 }
 
 LevelLoader::~LevelLoader()
@@ -26,10 +33,20 @@ LevelLoader::~LevelLoader()
 
 std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LevelLoader::LoadLevel(std::string fileName)
 {
-	return pData->parser.Parse(fileName);
+	return pData->parser.Parse(pData->folderPath + fileName);
 }
 
 LevelMetaData LevelLoader::LoadLevelHeader(std::string fileName)
 {
-	return pData->parser.ParseHeader(fileName);
+	return pData->parser.ParseHeader(pData->folderPath + fileName);
+}
+
+std::string LevelLoader::GetFolderPath()
+{
+	return this->pData->folderPath;
+}
+
+void LevelLoader::SetFolderPath(std::string folderPath)
+{
+
 }

Code/Game/GameLogic/LevelLoader/LevelLoader.h

@@ -17,11 +17,15 @@ namespace GameLogic
 
 	public:
 		LevelLoader();
+		/***********************************************************
+			* Lets you set the standard folderpath for the levels
+			********************************************************/
+		LevelLoader(std::string folderPath);
 		~LevelLoader();
 
 		/********************************************************
 			* Loads the level and objects from file.
-			* @param fileName: Path to the level-file that you want to load.
+			* @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::string fileName);
@@ -33,10 +37,20 @@ namespace GameLogic
 			********************************************************/
 		LevelMetaData LoadLevelHeader(std::string fileName); //.
 
+		/***********************************************************
+			* @return: Returns the current standard folder path
+			********************************************************/
+		std::string GetFolderPath();
+
+		/***********************************************************
+			* Sets the standard folder path
+			********************************************************/
+		void SetFolderPath(std::string folderPath);
+
 	private:
 		struct PrivData;
 		Utility::DynamicMemory::SmartPointer<PrivData> pData;
-	};
+	}; 
 }
 
 #endif

Code/Game/GameLogic/LevelLoader/LevelParser.cpp

@@ -13,7 +13,7 @@ using namespace Utility::DynamicMemory;
 
 LevelParser::LevelParser()
 {
-	formatVersion.formatVersionMajor = 2;
+	formatVersion.formatVersionMajor = 3;
 	formatVersion.formatVersionMinor = 0;
 }
 
@@ -71,7 +71,6 @@ std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filen
 				{
 					//These three does not have any specail variables at this time. 
 					//There for they are using the same 'parser'.
-					case ObjectSpecialType_World:
 					case ObjectSpecialType_Building:
 					case ObjectSpecialType_Damaging:
 					case ObjectSpecialType_Explosive:
@@ -113,14 +112,24 @@ std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filen
 
 						break;
 					}
-					case ObjectSpecialType_SpawnPoint:
+					
+					case ObjectSpecialType_World:
 					{
-						SpawnPointAttributes* header = new SpawnPointAttributes;
+						WorldAttributes* header = new WorldAttributes;
 						ParseObject(&buffer[counter], *header, counter);
 
-						ParseObject(&buffer[counter], header->spawnPosition, 12);
+						ParseObject(&buffer[counter], &header->worldSize, 8);
 						objects.push_back(header);
+						break;
+					}
 
+					case ObjectSpecialType_Sky:
+					{
+						SkyAttributes* header = new SkyAttributes;
+						ParseObject(&buffer[counter], *header, counter);
+
+						ParseObject(&buffer[counter], &header->skySize, 4);
+						objects.push_back(header);
 						break;
 					}
 					default:
@@ -239,9 +248,6 @@ LevelMetaData LevelParser::ParseHeader(std::string filename)
 			case ObjectSpecialType_Portal:
 				counter += sizeof(12);
 				break;
-			case ObjectSpecialType_SpawnPoint:
-				counter += sizeof(12);
-				break;
 			default:
 				break;
 			}	

Code/Game/GameLogic/LevelLoader/ObjectDefines.h

@@ -32,7 +32,7 @@ namespace GameLogic
 		ObjectSpecialType_JumpPad,
 		ObjectSpecialType_BoostPad,
 		ObjectSpecialType_Portal,
-		ObjectSpecialType_SpawnPoint,
+		ObjectSpecialType_Sky,
 
 		ObjectSpecialType_Count,
 		ObjectSpecialType_Unknown  = -1
@@ -134,18 +134,22 @@ namespace GameLogic
 
 	namespace LevelLoaderInternal
 	{
-		const FormatVersion boundingVolumeVersion(1, 0);
+		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];
-			float angularAxis[3];
-			float angle;
 		};
 
 		struct BoundingVolumeSphere : public BoundingVolumeBase
@@ -156,8 +160,6 @@ namespace GameLogic
 		struct BoundingVolumeCylinder : public BoundingVolumeBase
 		{
 			float length;
-			float angularAxis[3];
-			float angle;
 			float radius;
 		};
 
@@ -172,17 +174,6 @@ namespace GameLogic
 			};
 		};
 
-		struct PhysicsObject
-		{
-			UsePhysics usePhysics;
-			float mass;
-			float inertiaMagnitude[3];
-			float inertiaRotation[3];
-			float frictionCoeffStatic;
-			float frictionCoeffDynamic;
-			float restitutionCoeff;
-			BoundingVolume boundingVolume;
-		};
 	}
 
 	struct LevelMetaData : public ObjectTypeHeader
@@ -200,7 +191,7 @@ namespace GameLogic
 
 	};
 
-	struct ObjectHeader : public ObjectTypeHeader, public LevelLoaderInternal::PhysicsObject
+	struct ObjectHeader : public ObjectTypeHeader
 	{
 		//Special type id for special objects: portal, jumppad, exploding objects, etc.
 		ObjectSpecialType specialTypeID;
@@ -208,12 +199,13 @@ namespace GameLogic
 		std::string ModelFile;
 		//Position
 		float position[3];
-		//Rotation
+		//Rotation Quaternion
-		float rotation[3];
+		float rotation[4];
-		float angle;
 		//Scale
 		float scale[3];
 
+		::GameLogic::LevelLoaderInternal::BoundingVolume boundingVolume;
+
 		virtual ~ObjectHeader(){}
 	};
 
@@ -232,11 +224,19 @@ namespace GameLogic
 		float destination[3];
 	};
 
-	struct SpawnPointAttributes : public ObjectHeader
+	struct WorldAttributes : public ObjectHeader
 	{
-		float spawnPosition[3];
+		float worldSize;
+		float atmoSphereSize;
 	};
 
+	struct SkyAttributes : public ObjectHeader
+	{
+		float skySize;
+	};
+
+	
+
 	/************************************
 				Lights
 	*************************************/

Code/Game/GameLogic/LevelLoader/ParseFunctions.cpp

@@ -16,6 +16,7 @@ namespace GameLogic
 {
 	namespace LevelFileLoader
 	{
+		//can parse any struct without strings or char[]
 		void ParseObject(char* buffer, void *header, int size)
 		{
 			memcpy(header, buffer, size);
@@ -44,11 +45,6 @@ namespace GameLogic
 			//3 float[3], 1 float
 			memcpy(&header.position, &buffer[start], 40);
 			start += 40;
-
-			//Physics struct
-			//2 float[3], 4 float, 1 uint
-			memcpy(&header.usePhysics, &buffer[start], 44);
-			start += 44;
 			
 			//Read path for bounding volume
 			ParseBoundingVolume(&buffer[start], header.boundingVolume, start);
@@ -122,7 +118,7 @@ namespace GameLogic
 			int start = 0;
 			int tempSize = 0;
 			char tempName[128];
-
+			
 			memcpy(&tempSize, &buffer[start], 4);
 			start += 4;
 
@@ -132,39 +128,41 @@ namespace GameLogic
 			fileName.assign(&tempName[0], &tempName[tempSize]);
 			start += tempSize;
 
+			size += start;
+
 			//Läs in filen.
 			int fileLength = 0;
 			Loader loader;
 			char* buf = loader.LoadFile("E:\\Dropbox\\Programming\\Github\\Danbias\\Bin\\Content\\Worlds\\cgf\\"+ fileName, fileLength);
-			
-			LevelLoaderInternal::FormatVersion version;
-			memcpy(&version, &buffer[0], sizeof(version));
 
-			memcpy(&volume.geoType, &buf[8], sizeof(volume.geoType));
+			start = 0;
-			//start += sizeof(volume.geoType);
+			LevelLoaderInternal::FormatVersion version;
+			memcpy(&version, &buf[0], sizeof(version));
+			start += 4;
+
+			memcpy(&volume.geoType, &buf[start], sizeof(volume.geoType));
+			start += sizeof(volume.geoType);
 
 			switch(volume.geoType)
 			{
 			case CollisionGeometryType_Box:
-				memcpy(&volume.box, &buf[12], sizeof(volume.box));
+				memcpy(&volume.box, &buf[start], sizeof(volume.box));
-				//start += sizeof(volume.box);
+				start += sizeof(volume.box);
 				break;
 
 			case CollisionGeometryType_Sphere:
-				memcpy(&volume.sphere, &buf[12], sizeof(volume.sphere));
+				memcpy(&volume.sphere, &buf[start], sizeof(volume.sphere));
-				//start += sizeof(volume.sphere);
+				start += sizeof(volume.sphere);
 				break;
 
 			case CollisionGeometryType_Cylinder:
-				memcpy(&volume.cylinder, &buf[12], sizeof(volume.cylinder));
+				memcpy(&volume.cylinder, &buf[start], sizeof(volume.cylinder));
-				//start += sizeof(volume.cylinder);
+				start += sizeof(volume.cylinder);
 				break;
 
 			default:
 				break;
 			}
-
-			size += start;
 		}
 	}
 }

Code/Game/GameLogic/Object.cpp

@@ -15,10 +15,8 @@ const Game *Object::gameInstance = (Game*)(&Game::Instance());
 
 Object::Object()
 {	
-	API::SimpleBodyDescription sbDesc;
 
-	this->rigidBody = API::Instance().CreateRigidBody(sbDesc).Release();
+	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);
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
 
 	this->type = OBJECT_TYPE::OBJECT_TYPE_UNKNOWN;
 	this->objectID = GID();
@@ -28,10 +26,7 @@ Object::Object()
 
 Object::Object(OBJECT_TYPE type)
 {
-	API::SimpleBodyDescription sbDesc;
+	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->rigidBody = API::Instance().CreateRigidBody(sbDesc).Release();
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
 	this->type = type;
 	this->objectID = GID();
 	this->currPhysicsState = this->rigidBody->GetState();
@@ -40,7 +35,6 @@ Object::Object(OBJECT_TYPE type)
 
 Object::Object(Oyster::Physics::ICustomBody *rigidBody, OBJECT_TYPE type)
 {
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
 	this->rigidBody = rigidBody;
 	this->type = type;
 	this->objectID = GID();
@@ -50,10 +44,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody, OBJECT_TYPE type)
 
 Object::Object(void* collisionFuncBefore, void* collisionFuncAfter, OBJECT_TYPE type)
 {
-	API::SimpleBodyDescription sbDesc;
+	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->rigidBody = API::Instance().CreateRigidBody(sbDesc).Release();
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
 	
 	this->type = type;
 	this->objectID = GID();
@@ -63,11 +54,7 @@ Object::Object(void* collisionFuncBefore, void* collisionFuncAfter, OBJECT_TYPE
 
 Object::Object(Oyster::Physics::ICustomBody *rigidBody ,void* collisionFuncBefore, void* collisionFuncAfter, OBJECT_TYPE type)
 {
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
-
 	this->rigidBody = rigidBody;
-	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse)(collisionFuncBefore));
-	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse)(collisionFuncAfter));	
 
 	this->type = type;
 	this->objectID = GID();
@@ -77,11 +64,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody ,void* collisionFuncBefor
 
 Object::Object(Oyster::Physics::ICustomBody *rigidBody ,Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncBefore)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter), Oyster::Physics::ICustomBody::SubscriptMessage (*collisionFuncAfter)(Oyster::Physics::ICustomBody *proto,Oyster::Physics::ICustomBody *deuter,Oyster::Math::Float kineticEnergyLoss), OBJECT_TYPE type)
 {
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
-	
 	this->rigidBody = rigidBody;
-	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse)(collisionFuncBefore));
-	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse)(collisionFuncAfter));
 
 	
 	this->type = type;
@@ -92,7 +75,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody ,Oyster::Physics::ICustom
 
 void Object::ApplyLinearImpulse(Oyster::Math::Float3 force)
 {
-	newPhysicsState.ApplyLinearImpulse(force);
+	
 }
 
 
@@ -119,85 +102,17 @@ Oyster::Physics::ICustomBody* Object::GetRigidBody()
 void Object::BeginFrame()
 {
 	
-	
-	if(currPhysicsState.GetLinearMomentum() !=currPhysicsState.GetLinearMomentum())
-	{
-		//error
-		int i =0 ;
-	}
-	if(currPhysicsState.GetCenterPosition() !=currPhysicsState.GetCenterPosition())
-	{
-		//error
-		int i =0 ;
-	}
-	if(currPhysicsState.GetAngularAxis() !=currPhysicsState.GetAngularAxis())
-	{
-		//error
-		int i =0 ;
-	}
 	this->rigidBody->SetState(this->newPhysicsState);
 }
 // update physic 
 void Object::EndFrame()
 {
-	if(currPhysicsState.GetLinearMomentum() !=currPhysicsState.GetLinearMomentum())
-	{
-		//error
-		int i =0 ;
-	}
-	this->currPhysicsState = this->rigidBody->GetState();
-	if(currPhysicsState.GetLinearMomentum() !=currPhysicsState.GetLinearMomentum())
-	{
-		//error
-		int i =0 ;
-	}
-	if(currPhysicsState.GetGravityNormal() !=currPhysicsState.GetGravityNormal())
-	{
-		//error
-		int i =0 ;
-	}
-
-
-	if(currPhysicsState.GetGravityNormal()!= Float3::null)
-	{
-		Oyster::Math::Float4 axis;
-		Oyster::Math3D::SnapAngularAxis(Oyster::Math::Float4(currPhysicsState.GetAngularAxis(), 0), Oyster::Math::Float4::standard_unit_y, -Oyster::Math::Float4(currPhysicsState.GetGravityNormal()), axis);
-		if(axis !=axis)
-		{
-			//error
-			int i =0 ;
-		}
-		currPhysicsState.SetRotation(axis.xyz);
-		currPhysicsState.SetAngularMomentum(Float3::null);
-		Oyster::Math::Float3 debug = ::LinearAlgebra3D::WorldAxisOf(::LinearAlgebra3D::Rotation(axis.xyz), Oyster::Math::Float3::standard_unit_y);
-		debug += currPhysicsState.GetGravityNormal();
-	}
-	Oyster::Math::Float3 pos = currPhysicsState.GetCenterPosition(); 
-	Oyster::Math::Float3 up = -currPhysicsState.GetGravityNormal();
-	//300, 0,0,
-	//1,0,0
-	
-	if( pos.GetLength() < 303.5f) 
-	{
-		Oyster::Math::Float moveUp = 303.5 - pos.GetLength();
-		up *= moveUp;
-
-		currPhysicsState.SetCenterPosition(pos + up);
-	}
-
-
-	if(currPhysicsState.GetLinearMomentum() !=currPhysicsState.GetLinearMomentum())
-	{
-		//error
-		int i =0 ;
-	}
-
 	this->newPhysicsState = this->currPhysicsState;
 }
 
 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));
+	//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))
 {
@@ -208,7 +123,7 @@ Oyster::Math::Float3 Object::GetPosition()
 {
 	Oyster::Physics::ICustomBody::State state; 
 	state = this->rigidBody->GetState();
-	return state.GetCenterPosition();
+	return state.centerPos;
 }
 Oyster::Math::Float4x4 Object::GetOrientation() 
 {

Code/Game/GameLogic/Object.h

@@ -27,6 +27,7 @@ namespace GameLogic
 
 		// API overrides
 		OBJECT_TYPE GetObjectType() const;
+		void setID(int id);
 		int GetID() const;
 		Oyster::Math::Float3 GetPosition();
 		Oyster::Math::Float4x4 GetOrientation();
@@ -43,7 +44,8 @@ namespace GameLogic
 
 		static Oyster::Physics::ICustomBody::SubscriptMessage DefaultCollisionBefore(Oyster::Physics::ICustomBody *rigidBodyLevel, Oyster::Physics::ICustomBody *obj);
 		static Oyster::Physics::ICustomBody::SubscriptMessage DefaultCollisionAfter(Oyster::Physics::ICustomBody *rigidBodyLevel, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss);
-	private:
+	
+	public: //TODO: Hax This should be private when level is dynamic
 		OBJECT_TYPE type;
 		int objectID;
 

Code/Game/GameLogic/Player.cpp

@@ -73,7 +73,7 @@ void Player::EndFrame()
 	Oyster::Math::Float3 up = currPhysicsState.GetOrientation().v[1];
 	Oyster::Math::Float3 deltaAxis = up * (-dx * 0.02) ;
 
-	currPhysicsState.AddRotation(deltaAxis);
+	//currPhysicsState.AddRotation(deltaAxis);
 	dx = 0; 
 	this->newPhysicsState = this->currPhysicsState;
 }
@@ -108,30 +108,31 @@ void Player::MoveForward()
 {
 	Oyster::Math::Float3 forward = currPhysicsState.GetOrientation().v[2];
 	//Oyster::Math::Float3 forward = lookDir;
-	newPhysicsState.ApplyLinearImpulse(forward * (MOVE_FORCE * this->gameInstance->GetFrameTime()));
+	//newPhysicsState.ApplyLinearImpulse(forward * (MOVE_FORCE * this->gameInstance->GetFrameTime()));
+	//rigidBody->SetLinearVelocity( 10 *  this->gameInstance->GetFrameTime() );
 }
 void Player::MoveBackwards()
 {
 	Oyster::Math::Float3 forward = currPhysicsState.GetOrientation().v[2];
 	//Oyster::Math::Float3 forward = lookDir;
-	newPhysicsState.ApplyLinearImpulse(-forward * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	//newPhysicsState.ApplyLinearImpulse(-forward * MOVE_FORCE * this->gameInstance->GetFrameTime());
 }
 void Player::MoveRight()
 {
 	//Do cross product with forward vector and negative gravity vector
 	Oyster::Math::Float3 forward = currPhysicsState.GetOrientation().v[2];
+
 	//Oyster::Math::Float3 forward = lookDir;
-	Oyster::Math::Float3 r = (-currPhysicsState.GetGravityNormal()).Cross(forward);
+	Oyster::Math::Float3 r = (-currPhysicsState.centerPos.Normalize()).Cross(forward);
-	newPhysicsState.ApplyLinearImpulse(-r * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	//rigidBody->SetLinearVelocity(-r * 10 *  this->gameInstance->GetFrameTime() );
-	
 }
 void Player::MoveLeft()
 {
 	//Do cross product with forward vector and negative gravity vector
 	Oyster::Math::Float3 forward = currPhysicsState.GetOrientation().v[2];
 	//Oyster::Math::Float3 forward = lookDir;
-	Oyster::Math::Float3 r = (-currPhysicsState.GetGravityNormal()).Cross(forward);	//Still get zero
+	//Oyster::Math::Float3 r = (-currPhysicsState.GetGravityNormal()).Cross(forward);	//Still get zero
-	newPhysicsState.ApplyLinearImpulse(r * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	//newPhysicsState.ApplyLinearImpulse(r * MOVE_FORCE * this->gameInstance->GetFrameTime());
 }
 
 void Player::UseWeapon(const WEAPON_FIRE &usage)
@@ -144,7 +145,7 @@ void Player::Respawn(Oyster::Math::Float3 spawnPoint)
 	this->life = 100;
 	this->playerState = PLAYER_STATE::PLAYER_STATE_IDLE;
 	this->lookDir = Oyster::Math::Float4(1,0,0);
-	this->newPhysicsState.SetCenterPosition(spawnPoint);
+	this->newPhysicsState.centerPos = spawnPoint;
 }
 
 void Player::Rotate(const Oyster::Math3D::Float4 lookDir)
@@ -162,7 +163,7 @@ void Player::Rotate(const Oyster::Math3D::Float4 lookDir)
 void Player::Jump()
 {
 	Oyster::Math::Float3 up = currPhysicsState.GetOrientation().v[1];
-	newPhysicsState.ApplyLinearImpulse(up * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	//newPhysicsState.ApplyLinearImpulse(up * MOVE_FORCE * this->gameInstance->GetFrameTime());
 }
 
 bool Player::IsWalking()
@@ -180,7 +181,7 @@ bool Player::IsIdle()
 
 Oyster::Math::Float3 Player::GetPosition() const
 {
-	return (Oyster::Math::Float3)currPhysicsState.GetCenterPosition();
+	return (Oyster::Math::Float3)currPhysicsState.centerPos;
 }
 Oyster::Math::Float4x4 Player::GetOrientation() const 
 {
@@ -208,7 +209,7 @@ void Player::DamageLife(int damage)
 	{
 		this->life = 0;
 		playerState = PLAYER_STATE_DEAD;
-		this->gameInstance->onDisableFnc(this);
+		this->gameInstance->onDisableFnc(this, 0.0f);
 	}
 }
 

Code/Game/GameLogic/Player.h

@@ -85,8 +85,8 @@ namespace GameLogic
 		int teamID;
 		Weapon *weapon;
 		PLAYER_STATE playerState;
-		Oyster::Math::Float3 lookDir;
+		Oyster::Math::Float3 lookDir;	//Duplicate in Object.h?
-		Oyster::Math::Float dx;
+		Oyster::Math::Float dx;			//dx of what?
 
 		bool hasTakenDamage;
 		float invincibleCooldown;

Code/Game/GameLogic/StaticObject.cpp

@@ -18,8 +18,8 @@ StaticObject::StaticObject(OBJECT_TYPE type)
 StaticObject::StaticObject(Oyster::Physics::ICustomBody *rigidBody, OBJECT_TYPE type)
 	:Object(rigidBody,type)
 {
-	this->rigidBody->SetGravity(true);
+	//this->rigidBody->SetGravity(true);
-	this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse)(CollisionManager::IgnoreCollision));
+	//this->rigidBody->SetSubscription((Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse)(CollisionManager::IgnoreCollision));
 }
 
 StaticObject::StaticObject(void* collisionFuncBefore, void* collisionFuncAfter, OBJECT_TYPE type)

Code/Game/GameLogic/TeamManager.cpp

@@ -35,13 +35,11 @@ TeamManager::~TeamManager(void)
 
 void TeamManager::RespawnPlayerRandom(Player *player)
 {
-																// Whats going on here?
+	int teamID = player->GetTeamID();
-	int teamID = player->GetTeamID();							// ?
+
-																// ?
+	Player *respawnOnThis = this->teams[teamID]->GetPlayer(0);
-	Player *respawnOnThis = this->teams[teamID]->GetPlayer(0);	// ?
+
-																// ?
+	player->Respawn(respawnOnThis->GetPosition());
-	player->Respawn(respawnOnThis->GetPosition());				// ?
-																// player->Respawn(player->GetPosition()); ?
 }
 
 void TeamManager::CreateTeam(int teamSize)

Code/Game/GameLogic/Weapon.cpp

@@ -18,9 +18,17 @@ Weapon::Weapon()
 
 Weapon::Weapon(int MaxNrOfSockets,Player *owner)
 {
+	if(MaxNrOfSockets > 1) return;
+
+
 	attatchmentSockets.Resize(MaxNrOfSockets);
 	attatchmentSockets[0] = new AttatchmentSocket();
 
+	for (int i = 0; i < MaxNrOfSockets; i++)
+	{
+		this->attatchmentSockets[i] = 0;
+	}
+
 	weaponState = WEAPON_STATE_IDLE;
 	currentNrOfAttatchments = 0;
 	selectedAttatchment = 0;
@@ -36,7 +44,11 @@ Weapon::Weapon(int MaxNrOfSockets,Player *owner)
 
 Weapon::~Weapon(void)
 {
-
+	for (unsigned int i = 0; i < this->attatchmentSockets.Size(); i++)
+	{
+		delete this->attatchmentSockets[i];
+		this->attatchmentSockets[i] = 0;
+	}
 }
 
 /********************************************************
@@ -129,5 +141,7 @@ void Weapon::SelectAttatchment(int socketID)
 
 void Weapon::Update(float dt)
 {
+	if(!selectedAttatchment) return;
+
 	selectedAttatchment->Update(dt);
 }

Code/Game/GameProtocols/GameProtocols.vcxproj

@@ -69,25 +69,25 @@
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
-    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(IncludePath)</IncludePath>
+    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)Misc;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
-    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(IncludePath)</IncludePath>
+    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)Misc;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
-    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(IncludePath)</IncludePath>
+    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)Misc;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <OutDir>$(SolutionDir)..\External\Lib\$(ProjectName)\</OutDir>
     <IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
-    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(IncludePath)</IncludePath>
+    <IncludePath>$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)Misc;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

Code/Game/GameProtocols/GeneralProtocols.h

@@ -24,23 +24,24 @@ namespace GameLogic
 
 			this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
 		}
-		Protocol_General_Status(Oyster::Network::CustomNetProtocol& p)
-		{
-			this->protocol = p;
-			status = (States)p[1].value.netShort;
-		}
 		Protocol_General_Status(States state)
 		{
 			this->protocol[0].value = protocol_General_Status;
 			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
-			this->status = state;
+
 			this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
+			this->status = state;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+	
+		Protocol_General_Status(Oyster::Network::CustomNetProtocol& p)
+		{
+			status = (States)this->protocol[1].value.netShort;
+		}
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = status;
 
-			return &protocol;		 
+			return protocol;		 
 		}							 
 
 	private:
@@ -59,12 +60,12 @@ namespace GameLogic
 			destination = p.Get(1).value.netInt;
 			text = p.Get(2).value.netCharPtr;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol.Set(0, protocol_General_Text, Oyster::Network::NetAttributeType_Short);
 			this->protocol.Set(1, destination, Oyster::Network::NetAttributeType_Int);
 			this->protocol.Set(2, text);
-			return &protocol;
+			return protocol;
 		}							 
 
 	private:

Code/Game/GameProtocols/LobbyProtocols.h

@@ -12,61 +12,111 @@
 #include <DynamicArray.h>
 
 
+/**	OBS!
+**	It seems like if a string is set in the middle of a data set, 
+**	the reciever will crach when trying to use the protocol. 
+**	Only tested on Protocol_LobbyStartGame.
+**/
+
+
 namespace GameLogic
 {
-	/*
 	struct Protocol_LobbyCreateGame :public Oyster::Network::CustomProtocolObject
 	{
-		char* mapName;
+		short clientID; // The unuiqe id reprsenting a specific client
-		char gameId;
+		std::string modelName;
+		float worldMatrix[16];
 
 		Protocol_LobbyCreateGame()
 		{
-			this->protocol[0].value = protocol_Lobby_Create;
+			int c = 0;
-			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[c].value = protocol_Lobby_Create;
+			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
 
-			this->protocol[1].type = Oyster::Network::NetAttributeType_CharArray;
+			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
-			this->protocol[2].type = Oyster::Network::NetAttributeType_Char;
+			for (int i = 0; i <= 16; i++)
+			{
+				this->protocol[c++].type = Oyster::Network::NetAttributeType_Float;
+			}
+			this->protocol[c++].type = Oyster::Network::NetAttributeType_CharArray;
 		}
-		Protocol_LobbyCreateGame(Oyster::Network::CustomNetProtocol& o)
+		Protocol_LobbyCreateGame(short _clientID, std::string name, float world[16])
 		{
-			mapName = o[1].value.netCharPtr;
+			int c = 0;
-			gameId = o[2].value.netChar;
+			this->protocol[c].value = protocol_Lobby_Create;
+			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
+
+			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
+			for (int i = 0; i <= 16; i++)
+			{
+				this->protocol[c++].type = Oyster::Network::NetAttributeType_Float;
+			}
+
+			this->protocol[c++].type = Oyster::Network::NetAttributeType_CharArray;
+
+			clientID = _clientID;
+			modelName = name;
+			memcpy(&worldMatrix[0], &world[0], sizeof(float) * 16);
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Protocol_LobbyCreateGame(Oyster::Network::CustomNetProtocol o)
 		{
-			protocol[1].value = mapName;
+			int c = 1;
-			protocol[2].value = gameId;
+			clientID = o[c++].value.netInt;
-			return &protocol;
+			for (int i = 0; i <= 16; i++)
+			{
+				this->worldMatrix[i] = o[c++].value.netFloat;
+			}
+			modelName.assign(o[c++].value.netCharPtr);
+		}
+		Oyster::Network::CustomNetProtocol GetProtocol() override
+		{
+			int c = 1;
+			protocol[c++].value = clientID;
+			
+			for (int i = 0; i <= 16; i++)
+			{
+				this->protocol[c++].value = this->worldMatrix[i];
+			}
+			protocol.Set(c++, this->modelName);
+			return protocol;
 		}
 		
 		private:
 			Oyster::Network::CustomNetProtocol protocol;
+
 	};
-	*/
+
 	struct Protocol_LobbyStartGame :public Oyster::Network::CustomProtocolObject
 	{
-		short gameId;
+		float seconds;
 
 		Protocol_LobbyStartGame()
 		{
 			this->protocol[0].value = protocol_Lobby_Start;
 			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
-
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Float;
-			this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
+			seconds = 0;
+		}
+		Protocol_LobbyStartGame(float _seconds)
+		{
+			this->protocol[0].value = protocol_Lobby_Start;
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Float;
+			seconds = _seconds;
 		}
 		Protocol_LobbyStartGame(Oyster::Network::CustomNetProtocol& o)
 		{
-			gameId = o[1].value.netInt;
+			seconds = o[1].value.netFloat;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
-			protocol[1].value = gameId;
+			this->protocol[1].value = seconds;
-			return &protocol;
+			return protocol;
 		}
 		
 		private:
 			Oyster::Network::CustomNetProtocol protocol;
+
 	};
 
 	struct Protocol_LobbyLogin :public Oyster::Network::CustomProtocolObject
@@ -83,9 +133,9 @@ namespace GameLogic
 		{
 
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
-			return &protocol;
+			return protocol;
 		}
 		
 		private:
@@ -109,7 +159,7 @@ namespace GameLogic
 	//		this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
 	//		value = p[1].value.netShort;
 	//	}
-	//	Oyster::Network::CustomNetProtocol* GetProtocol() override
+	//	Oyster::Network::CustomNetProtocol GetProtocol() override
 	//	{
 	//		protocol[1].value = value;
 	//		return &protocol;
@@ -130,8 +180,8 @@ namespace GameLogic
 		{
 			
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
-		{ return &protocol; }
+		{ return protocol; }
 		
 		private:
 			Oyster::Network::CustomNetProtocol protocol;
@@ -175,7 +225,7 @@ namespace GameLogic
 				list.Push(d);
 			}
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = list.Size();
 
@@ -195,7 +245,7 @@ namespace GameLogic
 					this->protocol.Set(a++, list[i].ip);
 			}
 			
-			return &protocol;
+			return protocol;
 		}
 		
 		private:
@@ -223,13 +273,13 @@ namespace GameLogic
 			minorVersion = (int)p.Get(2).value.netInt;
 			mapName = p.Get(3).value.netCharPtr;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = majorVersion;
 			this->protocol[2].value = minorVersion;
 			this->protocol.Set(3, mapName.c_str());
 
-			return &protocol;
+			return protocol;
 		}
 		
 		private:
@@ -254,7 +304,7 @@ namespace GameLogic
 	//	{
 	//
 	//	}
-	//	Oyster::Network::CustomNetProtocol* GetProtocol() override
+	//	Oyster::Network::CustomNetProtocol GetProtocol() override
 	//	{
 	//		return &protocol;
 	//	}

Code/Game/GameProtocols/ObjectProtocols.h

@@ -39,11 +39,11 @@ namespace GameLogic
 			pickup_ID = pickupID;
 
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = object_ID;
 			this->protocol[2].value = pickup_ID;
-			return &protocol;		 
+			return protocol;		 
 		}	
 
 	private:
@@ -80,11 +80,11 @@ namespace GameLogic
 			object_ID = id;
 			health = hp;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = object_ID;
 			this->protocol[2].value = health;
-			return &protocol;		 
+			return protocol;		 
 		}	
 
 	private:
@@ -129,14 +129,14 @@ namespace GameLogic
 			object_ID = id;
 			memcpy(&worldMatrix[0], &m[0], sizeof(float)*16);
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = object_ID;
 			for (int i = 2; i <= 17; i++)
 			{
 				this->protocol[i].value = worldMatrix[i-2];
 			}
-			return &protocol;		 
+			return protocol;		 
 		}	
 
 	private:
@@ -179,14 +179,14 @@ namespace GameLogic
 			object_ID = id;
 			memcpy(&worldMatrix[0], &m[0], sizeof(float)*16);
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = object_ID;
 			for (int i = 2; i <= 17; i++)
 			{
 				this->protocol[i].value = worldMatrix[i-2];
 			}
-			return &protocol;		 
+			return protocol;		 
 		}	
 
 	private:
@@ -221,11 +221,11 @@ namespace GameLogic
 			object_ID = id;
 			timer = time;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = object_ID;
 			this->protocol[2].value = timer;
-			return &protocol;		 
+			return protocol;		 
 		}							 
 
 	private:
@@ -234,8 +234,9 @@ namespace GameLogic
 
 	struct Protocol_ObjectCreate :public Oyster::Network::CustomProtocolObject
 	{
+		//ObjectType type; //ie player, box or whatever
 		int object_ID;
-		char *name;
+		std::string name;
 		float worldMatrix[16];
 
 		Protocol_ObjectCreate()
@@ -244,7 +245,7 @@ namespace GameLogic
 			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
 
 			this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
-			this->protocol[2].type = Oyster::Network::NetAttributeType_CharArray; 
+			this->protocol[2].type = Oyster::Network::NetAttributeType_CharArray;
 			
 			for (int i = 3; i <= 18; i++)
 			{
@@ -272,11 +273,11 @@ namespace GameLogic
 			this->name = path;
 			memcpy(&worldMatrix[0], &m[0], sizeof(float)*16);
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 
 			this->protocol[1].value = object_ID;
-			this->protocol[2].value = name;
+			this->protocol.Set(2, name);
 			this->protocol[3].value = worldMatrix[0];
 			this->protocol[4].value = worldMatrix[1]; 
 			this->protocol[5].value	= worldMatrix[2];
@@ -297,7 +298,7 @@ namespace GameLogic
 		
 		
 
-			return &protocol;		 
+			return protocol;		 
 		}							 
 
 	private:

Code/Game/GameProtocols/PlayerProtocols.h

@@ -49,14 +49,14 @@ namespace GameLogic
 
 			return *this;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = bForward;
 			this->protocol[2].value = bBackward;
 			this->protocol[3].value = bLeft;
 			this->protocol[4].value = bRight;
 
-			return &protocol;
+			return protocol;
 		}
 
 		private:
@@ -98,7 +98,7 @@ namespace GameLogic
 
 			return *this;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = lookDirX;
 			this->protocol[2].value = lookDirY;
@@ -106,7 +106,7 @@ namespace GameLogic
 			this->protocol[4].value	= deltaX;
 
 
-			return &protocol;
+			return protocol;
 		}
 
 	private:
@@ -131,9 +131,9 @@ namespace GameLogic
 		{
 			return *this;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
-			return &protocol;
+			return protocol;
 		}
 
 	private:
@@ -168,12 +168,12 @@ namespace GameLogic
 			utilityPressed		= val[3].value.netBool;
 			return *this;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = primaryPressed;
 			this->protocol[2].value = secondaryPressed;
 			this->protocol[3].value = utilityPressed;
-			return &protocol;
+			return protocol;
 		}
 
 	private:
@@ -200,10 +200,10 @@ namespace GameLogic
 			hasJumped		= val[1].value.netBool;
 			return *this;
 		}
-		Oyster::Network::CustomNetProtocol* GetProtocol() override
+		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
 			this->protocol[1].value = hasJumped;
-			return &protocol;
+			return protocol;
 		}
 
 	private:

Code/Game/GameServer/GameClient.h

@@ -24,14 +24,19 @@ namespace DanBias
 		GameLogic::IPlayerData* ReleasePlayer();
 		Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> GetClient();
 		Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> ReleaseClient();
-		int GetID() const;
 
+		float GetSinceLastResponse() const;
+		bool IsReady() const;
 		bool Equals(const Oyster::Network::NetworkClient* c);
 
+		void SetReadyState(bool isReady);
+		void SetSinceLastResponse(float seconds);
+
 	private:
 		GameLogic::IPlayerData* player;
 		Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client;
-		int id;
+		bool isReady;
+		float secondsSinceLastResponse;
 	};
 
 }//End namespace DanBias

Code/Game/GameServer/GameLobby.h

@@ -52,8 +52,10 @@ namespace DanBias
 	private:
 		Utility::WinTimer timer;
 		float refreshFrequency;
+		
 		GameSession gameSession;
 		LobbyLevelData description;
+		Utility::DynamicMemory::SmartPointer<DanBias::GameClient> sessionOwner;
 	};
 }//End namespace DanBias
 #endif // !DANBIASGAME_GAMELOBBY_H

Code/Game/GameServer/GameServerAPI.h

@@ -32,9 +32,11 @@ namespace DanBias
 			{
 				char* serverName;
 				int listenPort;
+				bool broadcast;			//Not fully implemented!
 				ServerInitDesc() 
 					: serverName("Game Server")
-					, listenPort(15151)
+					, listenPort(15152)
+					, broadcast(true)
 				{};
 			};
 			struct GameServerInfo
@@ -49,6 +51,7 @@ namespace DanBias
 			static void					ServerStop();
 			static void					ServerUpdate();
 			static GameServerInfo		ServerGetInfo();
+			static bool					ServerIsRunning();
 
 			static void					GameSetMapId(const int& val);
 			static void					GameSetMaxClients(const int& val);

Code/Game/GameServer/GameSession.h

@@ -52,24 +52,27 @@ namespace DanBias
 		*	@param client The client to attach to the session
 		*/
 		bool Attach(Oyster::Network::NetClient client) override;
+		void CloseSession( bool dissconnectClients ) override; 
 		
 		inline bool IsCreated() const	{ return this->isCreated; }
 		inline bool IsRunning() const	{ return this->isRunning; }
+		operator bool() { return (this->isCreated && this->isCreated); }
 
 		//Private member functions
 	private:
 		// TODO: find out what this method does..
 		void ClientEventCallback(Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e) override;
-
 		
 		//Sends a client to the owner, if obj is NULL then all clients is sent
 		void SendToOwner(DanBias::GameClient* obj);
 		
-		//Frame function, derived from IThreadObject
+		//Derived from IThreadObject
+		void ThreadEntry() override;
 		bool DoWork	( ) override;
 
+
 	private:
-		void ParseProtocol					(Oyster::Network::CustomNetProtocol& p, DanBias::GameClient* c);
+		void ParseProtocol					( Oyster::Network::CustomNetProtocol& p, DanBias::GameClient* c );
 
 		void Gameplay_PlayerMovement		( GameLogic::Protocol_PlayerMovement& p, DanBias::GameClient* c );
 		void Gameplay_PlayerLookDir			( GameLogic::Protocol_PlayerLook& p, DanBias::GameClient* c );
@@ -86,18 +89,23 @@ namespace DanBias
 		void General_Text					( GameLogic::Protocol_General_Text& p, DanBias::GameClient* c );
 		
 		//Callback method recieving from gamelogic
-		static void ObjectMove(GameLogic::IObjectData* movedObject);
+		static void ObjectMove				( GameLogic::IObjectData* movedObject );
+		static void ObjectDisabled			( GameLogic::IObjectData* movedObject, float seconds );
 
 		//Private member variables
 	private:
 		Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<GameClient>> clients;
+		Utility::DynamicMemory::SmartPointer<DanBias::GameClient> sessionOwner;
 		Oyster::Thread::OysterThread worker;
 		GameLogic::GameAPI& gameInstance;
 		GameLogic::ILevelData *levelData;
 		NetworkSession* owner;
 		bool isCreated;
 		bool isRunning;
-		Utility::WinTimer timer;
+		float logicFrameTime;
+		float networkFrameTime;
+		Utility::WinTimer logicTimer;
+		Utility::WinTimer networkTimer;
 		GameDescription description;
 
 		//TODO: Remove this uggly hax

Code/Game/GameServer/Implementation/GameClient.cpp

@@ -11,19 +11,18 @@ using namespace Oyster::Network;
 using namespace DanBias;
 using namespace GameLogic;
 
-static int gameClientIDCount = 1;
 
 GameClient::GameClient(SmartPointer<NetworkClient> client, GameLogic::IPlayerData* player)
 {
 	this->client = client;
-	this->id = gameClientIDCount++;
 	this->player = player;
+	isReady = false;
 }
 GameClient::~GameClient()
 {
 	this->client->Disconnect();
 	this->player = 0;
-	this->id = -1;
+	isReady = false;
 }
 
 GameLogic::IPlayerData* GameClient::GetPlayer()
@@ -46,13 +45,26 @@ SmartPointer<Oyster::Network::NetworkClient> GameClient::ReleaseClient()
 	this->client = 0;
 	return temp;
 }
-int GameClient::GetID() const
+
+float GameClient::GetSinceLastResponse() const
 {
-	return this->id;
+	return this->secondsSinceLastResponse;
+}
+bool GameClient::IsReady() const
+{
+	return this->isReady;
 }
 bool GameClient::Equals(const NetworkClient* c)
 {
 	return (c->GetID() == this->client->GetID());
 }
+void GameClient::SetReadyState(bool r)
+{
+	this->isReady = r;
+}
+void GameClient::SetSinceLastResponse(float s)
+{
+	this->secondsSinceLastResponse = s;
+}
 
 

Code/Game/GameServer/Implementation/GameLobby.cpp

@@ -17,18 +17,18 @@ namespace DanBias
 	{   }
 
 	GameLobby::~GameLobby()
-	{  }
+	{  
+		this->clients.Clear();
+	}
 
 	void GameLobby::Release()
 	{  
 		NetworkSession::CloseSession(true);
+		this->gameSession.CloseSession(true);
 	}
 
 	void GameLobby::Update()
 	{
-		if(GetAsyncKeyState(VK_DOWN))	//TODO: Dont forget to remove this...
-			this->Send(*GameLogic::Protocol_General_Status().GetProtocol());
-
 		this->ProcessClients();
 	}
 	void GameLobby::SetGameDesc(const LobbyLevelData& desc)
@@ -45,20 +45,21 @@ namespace DanBias
 		desc.mapNumber = this->description.mapNumber;		
 		desc.maxClients = this->description.maxClients;	
 	}
-	bool GameLobby::StartGameSession()
+	bool GameLobby::StartGameSession(  )
 	{
 		GameSession::GameDescription desc;
-		desc.gameMode = this->description.gameMode;
+			desc.gameMode = this->description.gameMode;
-		desc.gameTime = this->description.gameTime;
+			desc.gameTime = this->description.gameTime;
-		desc.mapNumber = this->description.mapNumber;
+			desc.mapNumber = this->description.mapNumber;
-		desc.owner = this;
+			desc.owner = this;
-		desc.clients = this->clients;
+			desc.clients = this->clients;
 
-		this->clients.Clear();
+		this->clients.Clear();	//Remove clients from lobby list
 		
 		if(this->gameSession.Create(desc))
 		{
 			this->gameSession.Run();
+
 			return true;
 		}
 		return false;
@@ -85,29 +86,36 @@ namespace DanBias
 	void GameLobby::ClientConnectedEvent(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client)
 	{
 		printf("New client(%i) connected - %s \n", client->GetID(), client->GetIpAddress().c_str());
-		Attach(client);
 
-		Protocol_LobbyClientData p1;
+		if(this->gameSession)
-		Protocol_LobbyGameData p2;
-		
-		for (unsigned int i = 0; i < this->clients.Size(); i++)
 		{
-			if(this->clients[i])
+			this->gameSession.Attach(client);
-			{
-				Protocol_LobbyClientData::PlayerData t;
-				t.id = this->clients[i]->GetID();
-				t.ip = this->clients[i]->GetIpAddress();
-				t.team = 0;
-				t.name = "DennisÄrKung";
-				p1.list.Push(t);
-			}
 		}
-		p2.majorVersion = 1;
+		else
-		p2.minorVersion = 0;
+		{
-		p2.mapName = "BetsMap";
+			Attach(client);
+			Protocol_LobbyClientData p1;
+			Protocol_LobbyGameData p2;
+		
+			for (unsigned int i = 0; i < this->clients.Size(); i++)
+			{
+				if(this->clients[i])
+				{
+					Protocol_LobbyClientData::PlayerData t;
+					t.id = this->clients[i]->GetID();
+					t.ip = this->clients[i]->GetIpAddress();
+					t.team = 0;
+					t.name = "Dennis är kung tycker Erik!";
+					p1.list.Push(t);
+				}
+			}
+			p2.majorVersion = 1;
+			p2.minorVersion = 0;
+			p2.mapName = "Dennis är kung tycker Erik!";
 
-		client->Send(p1.GetProtocol());
+			client->Send(p1.GetProtocol());
-		client->Send(p2.GetProtocol());
+			client->Send(p2.GetProtocol());
+		}
 	}
 
 }//End namespace DanBias

Code/Game/GameServer/Implementation/GameLobby_ProtocolParser.cpp

@@ -62,7 +62,14 @@ void GameLobby::GeneralText(GameLogic::Protocol_General_Text& p, Oyster::Network
 //}
 void GameLobby::LobbyStartGame(GameLogic::Protocol_LobbyStartGame& p, Oyster::Network::NetworkClient* c)
 {
-	//TODO: Prio 1
+	if(this->sessionOwner->GetClient()->GetID() == c->GetID())
+	{
+		
+	}
+	else
+	{
+		//Someone else tried to start the server..
+	}
 }
 //void GameLobby::LobbyJoin(GameLogic::Protocol_LobbyJoin& p, Oyster::Network::NetworkClient* c)
 //{

Code/Game/GameServer/Implementation/GameServer.cpp

@@ -53,6 +53,7 @@ void GameServerAPI::ServerStart()
 }
 void GameServerAPI::ServerStop()
 {
+	if(!server.IsRunning()) return;
 	lobby.Release();
 	server.Shutdown();
 	
@@ -61,19 +62,19 @@ void GameServerAPI::ServerStop()
 	int time = (int)total;
 	int hour, min, sec; 
 
-	hour=time / 3600; 
+	hour = time / 3600; 
-	time=time % 3600; 
+	time = time % 3600; 
-	min=time / 60; 
+	min = time / 60; 
-	time=time % 60;
+	time = time % 60;
 	sec = time; 
 
 	printf( "Server has been running for: %i:%i:%i - [hh:mm:ss] \n\n", hour, min, sec );
-	printf( "Terminating in : ");
+	//printf( "Terminating in : ");
-	for (int i = 0; i < 3; i++)
+	//for (int i = 0; i < 3; i++)
-	{
+	//{
-		printf( "%i ", 3-i );
+	//	printf( "%i ", 3-i );
-		Sleep(1000);
+	//	Sleep(1000);
-	}
+	//}
 	printf( "\nServer terminated!" );
 }
 void GameServerAPI::ServerUpdate()
@@ -82,7 +83,6 @@ void GameServerAPI::ServerUpdate()
 	lobby.Update();
 
 }
-
 GameServerAPI::GameServerInfo GameServerAPI::ServerGetInfo()
 {
 	GameServerAPI::GameServerInfo i;
@@ -90,6 +90,11 @@ GameServerAPI::GameServerInfo GameServerAPI::ServerGetInfo()
 	i.listenPort = server.GetPort();
 	return i;
 }
+bool GameServerAPI::ServerIsRunning()
+{
+	return server.IsRunning();
+}
+
 void		GameServerAPI::GameSetMapId(const int& val)
 {
 	LobbyLevelData d;
@@ -150,6 +155,11 @@ const char*	GameServerAPI::GameGetGameName()
 }
 bool		GameServerAPI::GameStart()
 {
-	return lobby.StartGameSession();
+	if(lobby.StartGameSession())
+	{
+		
+		return true;
+	}
+	return false;
 }
 

Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp

@@ -3,19 +3,16 @@
 /////////////////////////////////////////////////////////////////////
 #include "..\GameSession.h"
 #include "..\GameClient.h"
+#include <WinTimer.h>
 
 #include <Protocols.h>
 #include <PostBox\PostBox.h>
 #include <GameLogicStates.h>
 #include <OysterMath.h>
+
 #define NOMINMAX
 #include <Windows.h>
 
-#define DELTA_TIME_20	0.05f
-#define DELTA_TIME_24	0.04166666666666666666666666666667f
-#define DELTA_TIME_30	0.03333333333333333333333333333333f
-#define DELTA_TIME_60	0.01666666666666666666666666666667f
-#define DELTA_TIME_120	0.00833333333333333333333333333333f
 
 using namespace Utility::DynamicMemory;
 using namespace Oyster;
@@ -25,20 +22,20 @@ using namespace GameLogic;
 
 namespace DanBias
 {
+	Utility::WinTimer testTimer;
+	int testID = -1;
+
 	bool GameSession::DoWork(  )
 	{
 		if(this->isRunning)
 		{
-			double dt = this->timer.getElapsedSeconds();
+			float dt = (float)this->logicTimer.getElapsedSeconds();
-			gameInstance.SetFrameTimeLength((float)dt);
+			if( dt >= this->logicFrameTime )
-
-			if(dt >= DELTA_TIME_20)
 			{
 				this->ProcessClients();
-
 				this->gameInstance.NewFrame();
 
-				this->timer.reset();
+				this->logicTimer.reset();
 			}
 		}
 
@@ -71,11 +68,16 @@ namespace DanBias
 			case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToRecieve:
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend:
-				printf("\t(%i : %s) - EventType_ProtocolFailedToSend\n", e.sender->GetID(), e.sender->GetIpAddress().c_str());	
+				printf("\t(%i : %s) - EventType_ProtocolFailedToSend\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
-				this->Detach(e.sender)->Disconnect();
+				this->Detach(e.sender);
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolRecieved:
-				printf("\t(%i : %s) - EventType_ProtocolRecieved\n", e.sender->GetID(), e.sender->GetIpAddress().c_str());	
+				printf("\t(%i : %s) - EventType_ProtocolRecieved\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
+				testID = 2;
+				if(cl->GetPlayer()->GetID() == testID)//TODO: TEST
+				{
+					testTimer.reset();
+				}
 				this->ParseProtocol(e.args.data.protocol, cl);
 			break;
 		}
@@ -83,38 +85,47 @@ namespace DanBias
 
 	void GameSession::ObjectMove(GameLogic::IObjectData* movedObject)
 	{
-		if(dynamic_cast<IPlayerData*> (movedObject))
+		float dt = GameSession::gameSession->networkTimer.getElapsedSeconds();
+		//Duh... This was causing alot of problems, it's in the wrong place...
+		//Need to figure out where to put this frame locker.
+		//We only need to send network packages when necessary, ie not 120 times per frame. 
+		//I think it would be enough with 60-70 packages per second due to the nature of
+		//graphics update (60 fps) on the client side. To send more than this would be lost
+		//bandwidth.
+		//if( dt >= GameSession::gameSession->networkFrameTime )
 		{
-			IPlayerData* temp = (IPlayerData*)movedObject;
+			GameSession::gameSession->networkTimer.reset();
-			
-			int id = temp->GetID();
-			Oyster::Math::Float4x4 world = temp->GetOrientation();
-					
-			Protocol_ObjectPosition p(world, id);
-			GameSession::gameSession->Send(*p.GetProtocol());
-		}
 
-		GameLogic::IObjectData* obj = NULL;
+			GameLogic::IObjectData* obj = movedObject;
-		if(dynamic_cast<GameLogic::ILevelData*>(movedObject))
+			if(movedObject->GetID() == testID)	//TODO: TEST
-		{
-			obj = ((GameLogic::ILevelData*)movedObject)->GetObjectAt(0);
-			if(obj)
 			{
-				if(obj->GetObjectType() == OBJECT_TYPE_WORLD)
+				float sec = (float)testTimer.getElapsedSeconds();
-				{
+				sec = 0;
-					int id = obj->GetID();
-					Oyster::Math::Float4x4 world =obj->GetOrientation();
-					
-					Protocol_ObjectPosition p(world, id);
-					//GameSession::gameSession->Send(*p.GetProtocol());
-				}
 			}
 
-			obj = NULL;
+			int id = obj->GetID();
-			int count = ((GameLogic::ILevelData*)movedObject)->getNrOfDynamicObj();
+			Protocol_ObjectPosition p(obj->GetOrientation(), id);
-			for( int i = 0; i < count; i++  )
+			//if(id != 1)
+			GameSession::gameSession->Send(p.GetProtocol());
+
+
+			/*
+			if(dynamic_cast<GameLogic::ILevelData*>(obj))
 			{
-				obj =((GameLogic::ILevelData*)movedObject)->GetObjectAt(i+1);
+				obj = ((GameLogic::ILevelData*)movedObject)->GetObjectAt(0);
+				if(obj)
+				{
+					if(obj->GetObjectType() == OBJECT_TYPE_WORLD)
+					{
+						int id = obj->GetID();
+						Oyster::Math::Float4x4 world =obj->GetOrientation();
+					
+						Protocol_ObjectPosition p(world, id);
+						gameSession->Send(p.GetProtocol());
+					}
+				}
+
+				obj =((GameLogic::ILevelData*)movedObject)->GetObjectAt(1);
 				if(obj)
 				{
 					if(obj->GetObjectType() == OBJECT_TYPE_BOX)
@@ -122,13 +133,30 @@ namespace DanBias
 						int id = obj->GetID();
 						Oyster::Math::Float4x4 world = obj->GetOrientation();
 						Protocol_ObjectPosition p(world, id);
-						GameSession::gameSession->Send(*p.GetProtocol());
+						gameSession->Send(p.GetProtocol());
+					}
+				}
+			
+				obj =((GameLogic::ILevelData*)movedObject)->GetObjectAt(2);
+				if(obj)
+				{
+					if(obj->GetObjectType() == OBJECT_TYPE_BOX)
+					{
+						int id = obj->GetID();
+						Oyster::Math::Float4x4 world = obj->GetOrientation();
+						Protocol_ObjectPosition p(world, id);
+						GameSession::gameSession->Send(p.GetProtocol());
 					}
 				}
 			}
+			*/
 		}
 		
 	}
+	void GameSession::ObjectDisabled( GameLogic::IObjectData* movedObject, float seconds )
+	{
+		GameSession::gameSession->Send(Protocol_ObjectDisable(movedObject->GetID(), seconds).GetProtocol());
+	}
 
 //*****************************************************//
 //****************** Protocol methods *****************//
@@ -136,6 +164,8 @@ namespace DanBias
 
 	void GameSession::ParseProtocol(Oyster::Network::CustomNetProtocol& p, DanBias::GameClient* c)
 	{
+		//TODO: Update response timer
+
 		switch (p[0].value.netShort)
 		{
 			case protocol_Gameplay_PlayerMovement:		this->Gameplay_PlayerMovement		( Protocol_PlayerMovement		(p), c );
@@ -228,6 +258,8 @@ namespace DanBias
 		{
 			case GameLogic::Protocol_General_Status::States_disconected:
 				printf("Client with ID [%i] dissconnected\n", c->GetClient()->GetID());
+				//TODO: Tell other clients
+				//Protocol_
 				this->Detach(c->GetClient()->GetID());
 			break;
 
@@ -236,7 +268,7 @@ namespace DanBias
 			break;
 
 			case GameLogic::Protocol_General_Status::States_ready:
-
+				c->SetReadyState(true);
 			break;
 
 			case GameLogic::Protocol_General_Status::States_leave:
@@ -246,7 +278,7 @@ namespace DanBias
 	}
 	void GameSession::General_Text					( Protocol_General_Text& p, DanBias::GameClient* c )
 	{
-		printf("Message recieved from (%i):\t %s\n", c->GetID(), p.text.c_str());
+		printf("Message recieved from (%i):\t %s\n", c->GetClient()->GetID(), p.text.c_str());
 	}
 
 }//End namespace DanBias

Code/Game/GameServer/Implementation/GameSession_General.cpp

@@ -9,6 +9,13 @@
 
 #define NOMINMAX
 #include <Windows.h>
+#include <Queue.h>
+
+#define DELTA_TIME_20	0.05f
+#define DELTA_TIME_24	0.04166666666666666666666666666667f
+#define DELTA_TIME_30	0.03333333333333333333333333333333f
+#define DELTA_TIME_60	0.01666666666666666666666666666667f
+#define DELTA_TIME_120	0.00833333333333333333333333333333f
 
 
 using namespace Utility::DynamicMemory;
@@ -28,6 +35,10 @@ namespace DanBias
 		this->isCreated = false;
 		this->isRunning = false;
 		this->gameSession = this;
+		this->logicFrameTime = DELTA_TIME_20;
+		this->networkFrameTime = DELTA_TIME_20;
+		this->networkTimer.reset();
+		this->logicTimer.reset();
 
 		memset(&this->description, 0, sizeof(GameDescription));
 	}
@@ -45,37 +56,30 @@ namespace DanBias
 	bool GameSession::Create(GameDescription& desc)
 	{
 		this->description = desc;
-		/* Do some error checking */
+	/* Do some error checking */
 		if(desc.clients.Size() == 0)	return false;
 		if(!desc.owner)					return false;
 		if(this->isCreated)				return false;
 
-		/* standard initialization of some data */
+	/* standard initialization of some data */
 		NetworkSession::clients = desc.clients;
-		this->clients.Resize(desc.clients.Size());
+		this->clients.Reserve(desc.clients.Size());
 		this->owner = desc.owner;
 
-		/* Initiate the game instance */
+	/* Initiate the game instance */
 		if(!this->gameInstance.Initiate())
 		{
 			printf("Failed to initiate the game instance\n");
 		}
 
-		/* Create the game level */
+	/* Create the players in the game instance */
-		if(!(this->levelData = this->gameInstance.CreateLevel()))
-		{
-			printf("Level not created!");
-			return false;
-		}
-
-		/* Create the players in the game instance */
 		GameLogic::IPlayerData* p = 0;
 		for (unsigned int i = 0; i < desc.clients.Size(); i++)
 		{
 			if( (p = this->gameInstance.CreatePlayer()) )
 			{
 				desc.clients[i]->SetOwner(this);
-				this->clients[i] = new GameClient(desc.clients[i], p);
+				this->clients.Push(new GameClient(desc.clients[i], p));
 			}
 			else
 			{
@@ -83,16 +87,26 @@ namespace DanBias
 			}
 		}
 
+	/* Create the game level */
+		if(!(this->levelData = this->gameInstance.CreateLevel()))
+		{
+			printf("Level not created!");
+			return false;
+		}
+
+	/* Set some game instance data options */
+		this->gameInstance.SetSubscription(GameSession::ObjectMove);
+		this->gameInstance.SetSubscription(GameSession::ObjectDisabled);
+		this->gameInstance.SetFPS(60);
+
+		this->description.clients.Clear();
+
+		this->isCreated = true;
+
 		/* Create the worker thread */
 		if(this->worker.Create(this, false) != OYSTER_THREAD_ERROR_SUCCESS) 
 			return false;
 
-		this->worker.SetPriority(Oyster::Thread::OYSTER_THREAD_PRIORITY_3);
-
-		/* Set some game instance data options */
-		this->gameInstance.SetSubscription(GameLogic::GameEvent::ObjectEventFunctionType_OnMove, GameSession::ObjectMove);
-
-		this->isCreated = true;
 		return this->isCreated;
 	}
 
@@ -108,14 +122,71 @@ namespace DanBias
 		}
 	}
 
+	void GameSession::ThreadEntry(  )
+	{
+	//List with clients that we are waiting on..
+		DynamicArray<SmartPointer<GameClient>> readyList = this->clients;
 
+	//First we need to clean invalid clients, if any, and tell them to start loading game data
+		for (unsigned int i = 0; i < readyList.Size(); i++)
+		{
+			if(!readyList[i]) 
+			{
+				readyList.Remove(i);
+			}
+			else
+			{
+				Protocol_LobbyCreateGame p(readyList[i]->GetPlayer()->GetID(), "char_white.dan", readyList[i]->GetPlayer()->GetOrientation());
+				readyList[i]->GetClient()->Send(p);
+			}
+		}
+	
+		unsigned int readyCounter = readyList.Size();
+
+	//Sync with clients
+		while (readyCounter != 0)
+		{
+			this->ProcessClients();
+			for (unsigned int i = 0; i < readyList.Size(); i++)
+			{
+				if(readyList[i] && readyList[i]->IsReady())
+				{
+					//Need to send information about other players, to all players
+					for (unsigned int k = 0; k < this->clients.Size(); k++)
+					{
+						if((this->clients[k] && readyList[i]) && readyList[i]->GetClient()->GetID() != this->clients[k]->GetClient()->GetID())
+						{
+							Protocol_ObjectCreate p(this->clients[k]->GetPlayer()->GetOrientation(), this->clients[k]->GetPlayer()->GetID(), "char_white.dan"); //The model name will be custom later..
+							readyList[i]->GetClient()->Send(p);
+						}
+					}
+					
+					readyCounter-- ;
+					readyList[i] = 0;
+				}
+			}
+			Sleep(5); //TODO: This might not be needed here.
+		}
+
+		for (unsigned int i = 0; i < this->clients.Size(); i++)
+		{
+			if(this->clients[i])
+			{
+				this->clients[i]->GetClient()->Send(GameLogic::Protocol_LobbyStartGame(5));
+			}
+		}
+	}
 
 	bool GameSession::Attach(Utility::DynamicMemory::SmartPointer<NetworkClient> client)
 	{
 		if(!this->isCreated)	return false;
 
 		client->SetOwner(this);
-		SmartPointer<GameClient> obj = new GameClient(client, this->gameInstance.CreatePlayer());
+
+		IPlayerData* player = this->gameInstance.CreatePlayer();
+		if(!player) return false;
+
+		SmartPointer<GameClient> obj = new GameClient(client, player);
 	
 		for (unsigned int i = 0; i < clients.Size(); i++)
 		{
@@ -131,6 +202,13 @@ namespace DanBias
 		return true;
 	}
 
+	void GameSession::CloseSession( bool dissconnectClients )
+	{
+		this->worker.Terminate();
+		NetworkSession::CloseSession(true);
+		this->clients.Clear();
+	}
+
 
 }//End namespace DanBias
 

Code/GamePhysics/GamePhysics.vcxproj

@@ -89,7 +89,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;$(SolutionDir)Physics\Bullet Source\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
@@ -97,6 +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>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -119,7 +120,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;$(SolutionDir)Physics\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>

Code/GamePhysics/Implementation/Octree.cpp

@@ -31,11 +31,11 @@ Octree& Octree::operator=(const Octree& orig)
 
 void Octree::AddObject(UniquePointer< ICustomBody > customBodyRef)
 {
-	customBodyRef->SetScene( this );
+	//customBodyRef->SetScene( this );
 	Data data;
 	//Data* tempPtr = this->worldNode.dataPtr;
 
-	data.container = customBodyRef->GetBoundingSphere();
+	//data.container = customBodyRef->GetBoundingSphere();
 	data.queueRef = -1;
 	data.next = NULL;
 	data.prev = NULL;
@@ -140,6 +140,7 @@ void Octree::Visit(ICustomBody* customBodyRef, VisitorAction hitAction )
 {
 	auto object = this->mapReferences.find(customBodyRef);
 
+	// If rigid body is not found
 	if(object == this->mapReferences.end())
 	{	
 		return;
@@ -147,8 +148,10 @@ void Octree::Visit(ICustomBody* customBodyRef, VisitorAction hitAction )
 
 	unsigned int tempRef = object->second;
 
+	// Go through all object and test for intersection
 	for(unsigned int i = 0; i<this->leafData.size(); i++)
 	{
+		// If objects intersect call collision response function
 		if(tempRef != i && !this->leafData[i].limbo) if(this->leafData[tempRef].container.Intersects(this->leafData[i].container))
 		{
 			hitAction(*this, tempRef, i);
@@ -213,7 +216,7 @@ unsigned int Octree::GetTemporaryReferenceOf( const ICustomBody* objRef ) const
 
 void Octree::SetAsAltered( unsigned int tempRef )
 {
-	this->leafData[tempRef].container = this->leafData[tempRef].customBodyRef->GetBoundingSphere();
+	//this->leafData[tempRef].container = this->leafData[tempRef].customBodyRef->GetBoundingSphere();
 	//! @todo TODO: implement stub
 }
 

Code/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

@@ -12,149 +12,6 @@ using namespace ::Utility::Value;
 
 API_Impl API_instance;
 
-namespace
-{
-	void OnPossibleCollision( Octree& worldScene, unsigned int protoTempRef, unsigned int deuterTempRef )
-	{
-		auto proto = worldScene.GetCustomBody( protoTempRef );
-		auto deuter = worldScene.GetCustomBody( deuterTempRef );
-
-		Float4 worldPointOfContact;
-		if( proto->Intersects(*deuter, worldPointOfContact) )
-		{
-			// Apply CollisionResponse in pure gather pattern
-			ICustomBody::State protoState; proto->GetState( protoState );
-			ICustomBody::State deuterState; deuter->GetState( deuterState );
-
-			// calc from perspective of deuter.
-			Float4 normal = (worldPointOfContact - Float4(deuterState.GetCenterPosition(), 1.0f )).GetNormalized(); // Init value is only borrowed
-			if( normal.Dot(normal) > 0.0f )
-			{
-				deuter->GetNormalAt( worldPointOfContact, normal );
-			}
-			else
-			{ // special case: deuter is completly contained within proto or they have overlapping centers.
-
-				normal = Float4( protoState.GetCenterPosition() - deuterState.GetCenterPosition(), 0.0f );
-				if( normal.Dot(normal) == 0.0f )
-				{ // they have overlapping centers. Rebound at least
-					// calculate and store time interpolation value, for later rebound.
-					proto->SetTimeOfContact( worldPointOfContact );
-					return;
-				}
-				
-				// borrowing the negated normal of proto.
-				proto->GetNormalAt( worldPointOfContact, normal );
-				normal = -normal;
-			}
-			normal.Normalize();
-
-			Float4 protoG  = Float4(protoState.GetLinearMomentum( worldPointOfContact.xyz ), 0),
-				   deuterG = Float4(deuterState.GetLinearMomentum( worldPointOfContact.xyz ), 0);
-
-			if( normal != normal ) // debug: trap
-				const char *breakpoint = "This should never happen";
-
-			if( protoG != protoG ) // debug: trap
-				const char *breakpoint = "This should never happen";
-
-			if( deuterG != deuterG ) // debug: trap
-				const char *breakpoint = "This should never happen";
-
-			Float protoG_Magnitude = protoG.Dot( normal ),
-				  deuterG_Magnitude = deuterG.Dot( normal );
-
-			// if they are not relatively moving towards eachother, there is no collision
-			Float deltaPos = normal.Dot( Float4(deuterState.GetCenterPosition(), 1) - Float4(protoState.GetCenterPosition(), 1) );
-			if( deltaPos < 0.0f )
-			{
-				if( protoG_Magnitude >= deuterG_Magnitude )
-				{
-					return;
-				}
-			}
-			else if( deltaPos > 0.0f )
-			{
-				if( protoG_Magnitude <= deuterG_Magnitude )
-				{
-					return;
-				}
-			}
-			else
-			{
-				return;
-			}
-
-			if( proto->CallSubscription_BeforeCollisionResponse(proto) == ICustomBody::SubscriptMessage_ignore_collision_response )
-			{
-				return;
-			}
-
-			// PLayerHAck
-			if( proto->CallSubscription_BeforeCollisionResponse(proto) == ICustomBody::SubscriptMessage_player_collision_response )
-			{
-				Float3 linearMomentum = protoState.GetLinearMomentum();
-				Float3 up = -protoState.GetGravityNormal();
-				Float3 upForce = (linearMomentum.Dot(up) * up);
-
-				Float3 noBounceForce = linearMomentum - upForce;
-				protoState.SetLinearMomentum(noBounceForce);
-				proto->SetState(protoState);
-				return;
-			}
-			// calculate and store time interpolation value, for later rebound.
-			proto->SetTimeOfContact( worldPointOfContact );
-
-			// bounce
-			Float4 bounceD = normal * -Formula::CollisionResponse::Bounce( deuterState.GetRestitutionCoeff(),
-																		   deuterState.GetMass(), deuterG_Magnitude,
-																		   protoState.GetMass(), protoG_Magnitude );
-					
-
-			// calc from perspective of proto
-
-			normal = (worldPointOfContact - Float4(protoState.GetCenterPosition(), 1.0f )).GetNormalized();
-			if( normal.Dot(normal) > 0.0f )
-			{
-				proto->GetNormalAt( worldPointOfContact, normal );
-				protoG_Magnitude = protoG.Dot( normal );
-				deuterG_Magnitude = deuterG.Dot( normal );
-			}
-			else
-			{ // special case: proto is completly contained within deuter.
-				// borrowing the negated normal of deuter.
-				deuter->GetNormalAt( worldPointOfContact, normal );
-				normal = -normal;
-				protoG_Magnitude = -protoG_Magnitude;
-				deuterG_Magnitude = -deuterG_Magnitude;
-			}
-			
-			if( normal != normal ) // debug: trap
-				const char *breakpoint = "This should never happen";
-
-			// bounce
-			Float4 bounceP = normal * Formula::CollisionResponse::Bounce( protoState.GetRestitutionCoeff(),
-																		  protoState.GetMass(), protoG_Magnitude,
-																		  deuterState.GetMass(), deuterG_Magnitude );
-
-			Float4 bounce = Average( bounceD, bounceP );
-
-			Float4 friction = Formula::CollisionResponse::Friction( protoG_Magnitude, normal,
-																	Float4(protoState.GetLinearMomentum(), 0),  protoState.GetFrictionCoeff_Static(),  protoState.GetFrictionCoeff_Kinetic(),  protoState.GetMass(), 
-																	Float4(deuterState.GetLinearMomentum(), 0), deuterState.GetFrictionCoeff_Static(), deuterState.GetFrictionCoeff_Kinetic(), deuterState.GetMass());
-			
-			Float kineticEnergyPBefore = Oyster::Physics3D::Formula::LinearKineticEnergy( protoState.GetMass(), protoState.GetLinearMomentum()/protoState.GetMass() );
-
-			protoState.ApplyImpulse( bounce.xyz - friction.xyz, worldPointOfContact.xyz, normal.xyz );
-			proto->SetState( protoState );
-
-			Float kineticEnergyPAFter = Oyster::Physics3D::Formula::LinearKineticEnergy( protoState.GetMass(), (protoState.GetLinearMomentum() + protoState.GetLinearImpulse())/protoState.GetMass() );
-
-			proto->CallSubscription_AfterCollisionResponse( deuter,  kineticEnergyPBefore - kineticEnergyPAFter );
-		}
-	}
-}
-
 API & API::Instance()
 {
 	return API_instance;
@@ -162,312 +19,250 @@ API & API::Instance()
 
 API_Impl::API_Impl()
 {
-	this->gravityConstant = Constant::gravity_constant;
+	this->broadphase = NULL;
-	this->epsilon = Constant::epsilon;
+	this->collisionConfiguration = NULL;
-	this->updateFrameLength = 1.0f / 120.0f;
+    this->dispatcher = NULL;
-	this->destructionAction = Default::EventAction_Destruction;
+	this->solver = NULL;
-	this->gravity = ::std::vector<Gravity>();
+	this->dynamicsWorld = NULL;
-	this->worldScene = Octree();
 }
 
-API_Impl::~API_Impl() {}
+API_Impl::~API_Impl() 
-
-void API_Impl::Init( unsigned int numObjects, unsigned int numGravityWells , const Float3 &worldSize )
 {
-	unsigned char numLayers = 4; //!< @todo TODO: calc numLayers from worldSize
+	delete this->dynamicsWorld;
-	this->gravity.resize( 0 );
+	this->dynamicsWorld = NULL;
-	this->gravity.reserve( numGravityWells );
+    delete this->solver;
-	this->worldScene = Octree( numObjects, numLayers, worldSize );
+	this->solver = NULL;
-}
+    delete this->dispatcher;
+	this->dispatcher = NULL;
+    delete this->collisionConfiguration;
+	this->collisionConfiguration = NULL;
+    delete this->broadphase;
+	this->broadphase = NULL;
 
-void API_Impl::SetFrameTimeLength( float deltaTime )
+	for(int i = 0; i < this->customBodies.size(); i++)
-{
-	this->updateFrameLength = deltaTime;
-}
-
-void API_Impl::SetGravityConstant( float g )
-{
-	this->gravityConstant = g;
-}
-
-void API_Impl::SetEpsilon( float e )
-{
-	this->epsilon = e;
-}
-
-void API_Impl::SetSubscription( API::EventAction_Destruction functionPointer )
-{
-	if( functionPointer )
 	{
-		this->destructionAction = functionPointer;
+		delete this->customBodies[i];
-	}
+		this->customBodies[i] = NULL;
-	else
-	{
-		this->destructionAction = Default::EventAction_Destruction;
 	}
 }
 
-float API_Impl::GetFrameTimeLength() const
+// Bullet physics
+ICustomBody* API_Impl::AddCollisionSphere(float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction)
 {
-	return this->updateFrameLength;
+	SimpleRigidBody* body = new SimpleRigidBody;
+	SimpleRigidBody::State state;
+
+	// Add collision shape
+	btCollisionShape* collisionShape = new btSphereShape(radius);
+	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(radius, radius, radius);
+	state.dynamicFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = 0.5f;
+	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
+	state.mass = mass;
+
+	body->SetState(state);
+
+	return body;
 }
 
-void API_Impl::Update()
+ICustomBody* API_Impl::AddCollisionBox(Float3 halfSize, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction)
-{ /** @todo TODO: Update is a temporary solution .*/
+{
-	::std::vector<ICustomBody*> updateList;
+	SimpleRigidBody* body = new SimpleRigidBody;
-	auto proto = this->worldScene.Sample( Universe(), updateList ).begin();
+	SimpleRigidBody::State state;
+
+	// Add collision shape
+	btCollisionShape* collisionShape = new btBoxShape(btVector3(halfSize.x, halfSize.y, halfSize.z));
+	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 = halfSize;
+	state.dynamicFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = 0.5f;
+	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
+	state.mass = mass;
+
+	body->SetState(state);
+
+	return body;
+}
+
+ICustomBody* API_Impl::AddCollisionCylinder(::Oyster::Math::Float3 halfSize, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction)
+{
+	SimpleRigidBody* body = new SimpleRigidBody;
+	SimpleRigidBody::State state;
+
+	// Add collision shape
+	btCollisionShape* collisionShape = new btCylinderShape(btVector3(halfSize.x, halfSize.y, halfSize.z));
+	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 = halfSize;
+	state.dynamicFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = 0.5f;
+	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
+	state.mass = mass;
+
+	body->SetState(state);
+
+	return body;
+}
+
+void API_Impl::UpdateWorld()
+{
+	this->dynamicsWorld->stepSimulation(1.0f/60.0f, 1.0f, 1.0f/60.0f);
+
 	ICustomBody::State state;
-	for( ; proto != updateList.end(); ++proto )
+
+	for(unsigned int i = 0; i < this->customBodies.size(); i++ )
 	{
-		// Step 1: Apply Gravity
+		btTransform trans;
-		Float4 gravityImpulse = Float4::null;
+		dynamic_cast<SimpleRigidBody*>(this->customBodies[i])->GetMotionState()->getWorldTransform(trans);
-		(*proto)->GetState( state );
+		this->customBodies[i]->SetPosition(Float3(trans.getOrigin().x(), trans.getOrigin().y(), trans.getOrigin().z()));
-		for( ::std::vector<Gravity>::size_type i = 0; i < this->gravity.size(); ++i )
+		this->customBodies[i]->SetRotation(Quaternion(Float3(trans.getRotation().x(), trans.getRotation().y(), trans.getRotation().z()), trans.getRotation().w()));
+		
+		if(dynamic_cast<SimpleRigidBody*>(this->customBodies[i])->GetRigidBody()->getActivationState() == ACTIVE_TAG)
 		{
-			switch( this->gravity[i].gravityType )
+			dynamic_cast<SimpleRigidBody*>(this->customBodies[i])->CallSubscription_Move();
-			{
+		}
-			case Gravity::GravityType_Well:
+	}
-				{
+
-					Float4 d = Float4( this->gravity[i].well.position, 1.0f ) - Float4( state.GetCenterPosition(), 1.0f );
+	int numManifolds = this->dynamicsWorld->getDispatcher()->getNumManifolds();
-					Float rSquared = d.Dot( d );
+	for (int i=0;i<numManifolds;i++)
-					if( rSquared != 0.0 )
+	{
-					{
+		btPersistentManifold* contactManifold =  this->dynamicsWorld->getDispatcher()->getManifoldByIndexInternal(i);
-						Float force = Physics3D::Formula::ForceField( this->gravityConstant, state.GetMass(), this->gravity[i].well.mass, rSquared );
+		const btCollisionObject* obA = contactManifold->getBody0();
-						gravityImpulse += (this->updateFrameLength * force / ::std::sqrt(rSquared)) * d;
+		const btCollisionObject* obB = contactManifold->getBody1();
-					}
+
-					break;
+		ICustomBody* bodyA = (ICustomBody*)obA->getUserPointer();
-				}
+		ICustomBody* bodyB = (ICustomBody*)obB->getUserPointer();
-			case Gravity::GravityType_Directed:
+
-				gravityImpulse += Float4( this->gravity[i].directed.impulse, 0.0f );
+		dynamic_cast<SimpleRigidBody*>(bodyA)->CallSubscription_AfterCollisionResponse(bodyA, bodyB, 0.0f);
-				break;
+		dynamic_cast<SimpleRigidBody*>(bodyB)->CallSubscription_AfterCollisionResponse(bodyB, bodyA, 0.0f);
-//			case Gravity::GravityType_DirectedField:
+
-//				//this->gravity[i].directedField.
+		int numContacts = contactManifold->getNumContacts();
-//				//! TODO: @todo rethink
+		for (int j=0;j<numContacts;j++)
-//				break;
+		{
-			default: break;
+			btManifoldPoint& pt = contactManifold->getContactPoint(j);
+			if (pt.getDistance()<0.f)
+			{   
+				const btVector3& ptA = pt.getPositionWorldOnA();
+				const btVector3& ptB = pt.getPositionWorldOnB();
+				const btVector3& normalOnB = pt.m_normalWorldOnB;
 			}
 		}
-
-		if( gravityImpulse != gravityImpulse ) // debug: trap
-				const char *breakpoint = "This should never happen";
-
-		if( gravityImpulse != Float4::null )
-		{
-			state.ApplyLinearImpulse( gravityImpulse.xyz );
-			state.SetGravityNormal( gravityImpulse.GetNormalized().xyz );
-			(*proto)->SetState( state );
-		}
-
-		// Step 2: Apply Collision Response
-		this->worldScene.Visit( *proto, OnPossibleCollision );
 	}
 
-	proto = updateList.begin();
-	for( ; proto != updateList.end(); ++proto )
-	{
-		(*proto)->GetState( state );
-		Float3 lM = state.GetLinearMomentum();
-
-		//LinearAlgebra3D::InterpolateAxisYToNormal_UsingNlerp(state.SetOrientation(, Float4(state.GetGravityNormal(), 0.0f), 1.0f);
-
-
-		if( abs(lM.x) < this->epsilon )
-		{
-			state.linearMomentum.x = 0;
-		}
-		if( abs(lM.y) < this->epsilon )
-		{
-			state.linearMomentum.y = 0;
-		}
-		if( abs(lM.z) < this->epsilon )
-		{
-			state.linearMomentum.z = 0;
-		}
-
-		(*proto)->SetState( state );
-
-		switch( (*proto)->Update(this->updateFrameLength) )
-		{
-		case UpdateState_altered:
-			this->worldScene.SetAsAltered( this->worldScene.GetTemporaryReferenceOf(*proto) );
-			(*proto)->CallSubscription_Move();
-		case UpdateState_resting: 
-		default:
-			break;
-		}
-	}
 }
 
+void API_Impl::Init()
+{
+	this->broadphase = new btDbvtBroadphase();
+	this->collisionConfiguration = new btDefaultCollisionConfiguration();
+    this->dispatcher = new btCollisionDispatcher(this->collisionConfiguration);
+	this->solver = new btSequentialImpulseConstraintSolver;
+	this->dynamicsWorld = new btDiscreteDynamicsWorld(this->dispatcher,this->broadphase,this->solver,this->collisionConfiguration);
+	this->dynamicsWorld->setGravity(btVector3(0,-10,0));
+}
+
+
 bool API_Impl::IsInLimbo( const ICustomBody* objRef )
 {
-	return this->worldScene.IsInLimbo( objRef );
+	return true;
 }
 
 void API_Impl::MoveToLimbo( const ICustomBody* objRef )
 {
-	this->worldScene.MoveToLimbo( objRef );
+	
 }
+
 void API_Impl::ReleaseFromLimbo( const ICustomBody* objRef )
 {
-	this->worldScene.ReleaseFromLimbo( objRef );
+	
-}
-
-void API_Impl::AddObject( ::Utility::DynamicMemory::UniquePointer<ICustomBody> handle )
-{
-	this->worldScene.AddObject( handle );
-}
-
-UniquePointer<ICustomBody> API_Impl::ExtractObject( const ICustomBody* objRef )
-{
-	return this->worldScene.Extract( objRef );
-}
-
-void API_Impl::DestroyObject( const ICustomBody* objRef )
-{
-	UniquePointer<ICustomBody> object = this->worldScene.Extract( objRef );
-	if( object )
-	{
-		this->destructionAction( object );
-	}
-}
-
-void API_Impl::AddGravity( const API::Gravity &g )
-{
-	this->gravity.push_back( g );
-}
-
-void API_Impl::RemoveGravity( const API::Gravity &g )
-{
-	for( ::std::vector<Gravity>::size_type i = this->gravity.size() - 1; i >= 0; --i )
-	{
-		if( g == this->gravity[i] )
-		{
-			int end = this->gravity.size() - 1;
-			this->gravity[i] = this->gravity[end];
-			this->gravity.resize( end );
-		}
-	}
 }
 
 void API_Impl::ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void* args, void(hitAction)(ICustomBody*, void*) )
 {
-	this->worldScene.Visit(collideable, args, hitAction);
+	
 }
 
-//void API_Impl::ApplyForceAt( const ICustomBody* objRef, const Float3 &worldPos, const Float3 &worldF )
+namespace Oyster 
-//{
+{ 
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
+	namespace Physics
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		//this->worldScene.GetCustomBody( tempRef )->Apply //!< @todo TODO: need function
-//		this->worldScene.SetAsAltered( tempRef );		
-//	}
-//}
-//
-//void API_Impl::SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const Float4x4 &localI )
-//{ // deprecated
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepVelocity( localI );
-//	}
-//}
-//
-//void API_Impl::SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const Float4x4 &localI )
-//{ // deprecated
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepMomentum( localI );
-//	}
-//}
-//
-//void API_Impl::SetMass_KeepVelocity( const ICustomBody* objRef, Float m )
-//{ // deprecated
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetMass_KeepVelocity( m );
-//	}
-//}
-//
-//void API_Impl::SetMass_KeepMomentum( const ICustomBody* objRef, Float m )
-//{ // deprecated
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetMass_KeepMomentum( m );
-//	}
-//}
-//
-//void API_Impl::SetCenter( const ICustomBody* objRef, const Float3 &worldPos )
-//{
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		//this->worldScene.GetCustomBody( tempRef )->Set //!< @todo TODO: need function
-//		this->worldScene.EvaluatePosition( tempRef );
-//	}
-//}
-//
-//void API_Impl::SetRotation( const ICustomBody* objRef, const Float4x4 &rotation )
-//{
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetRotation( rotation );
-//		this->worldScene.EvaluatePosition( tempRef );
-//	}
-//}
-//
-//void API_Impl::SetOrientation( const ICustomBody* objRef, const Float4x4 &orientation )
-//{
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetOrientation( orientation );
-//		this->worldScene.EvaluatePosition( tempRef );
-//	}
-//}
-//
-//void API_Impl::SetSize( const ICustomBody* objRef, const Float3 &size )
-//{
-//	unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
-//	if( tempRef != this->worldScene.invalid_ref )
-//	{
-//		this->worldScene.GetCustomBody( tempRef )->SetSize( size );
-//		this->worldScene.EvaluatePosition( tempRef );
-//	}
-//}
-
-UniquePointer<ICustomBody> API_Impl::CreateRigidBody( const API::SimpleBodyDescription &desc ) const
-{
-	return new SimpleRigidBody( desc );
-}
-
-UniquePointer<ICustomBody> API_Impl::CreateRigidBody( const API::SphericalBodyDescription &desc ) const
-{
-	return new SphericalRigidBody( desc );
-}
-
-namespace Oyster { namespace Physics
-{
-	namespace Default
 	{
-		void EventAction_Destruction( ::Utility::DynamicMemory::UniquePointer<::Oyster::Physics::ICustomBody> proto )
+		namespace Default
-		{ /* Do nothing except allowing the proto uniquePointer destroy itself. */ }
+		{
+			void EventAction_Destruction( ::Utility::DynamicMemory::UniquePointer<::Oyster::Physics::ICustomBody> proto )
+			{ /* Do nothing except allowing the proto uniquePointer destroy itself. */ }
 
-		::Oyster::Physics::ICustomBody::SubscriptMessage EventAction_BeforeCollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter )
+			::Oyster::Physics::ICustomBody::SubscriptMessage EventAction_BeforeCollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter )
-		{ /* Do nothing except returning business as usual. */
+			{ /* Do nothing except returning business as usual. */
-			return ::Oyster::Physics::ICustomBody::SubscriptMessage_none;
+				return ::Oyster::Physics::ICustomBody::SubscriptMessage_none;
+			}
+
+			void EventAction_AfterCollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss )
+			{ /* Do nothing except returning business as usual. */
+				
+			}
+
+			void EventAction_Move( const ::Oyster::Physics::ICustomBody *object )
+			{ /* Do nothing. */ }
 		}
-
+	} 
-		void EventAction_AfterCollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss )
+}
-		{ /* Do nothing except returning business as usual. */
-			
-		}
-
-		void EventAction_Move( const ::Oyster::Physics::ICustomBody *object )
-		{ /* Do nothing. */ }
-	}
-} }

Code/GamePhysics/Implementation/PhysicsAPI_Impl.h

@@ -3,6 +3,7 @@
 
 #include "../PhysicsAPI.h"
 #include "Octree.h"
+#include <btBulletDynamicsCommon.h>
 
 namespace Oyster
 {
@@ -14,49 +15,28 @@ namespace Oyster
 			API_Impl();
 			virtual ~API_Impl();
 
-			void Init( unsigned int numObjects, unsigned int numGravityWells , const ::Oyster::Math::Float3 &worldSize );
+			void Init();
-
-			void SetFrameTimeLength( float deltaTime );
-			void SetGravityConstant( float g );
-			void SetEpsilon( float e );
-			void SetSubscription( EventAction_Destruction functionPointer );
-
-			float GetFrameTimeLength() const;
-
-			void Update();
 
 			bool IsInLimbo( const ICustomBody* objRef );
 			void MoveToLimbo( const ICustomBody* objRef );
 			void ReleaseFromLimbo( const ICustomBody* objRef );
 
-			void AddObject( ::Utility::DynamicMemory::UniquePointer<ICustomBody> handle );
+			// Bullet physics
-			::Utility::DynamicMemory::UniquePointer<ICustomBody> ExtractObject( const ICustomBody* objRef );
+			ICustomBody* AddCollisionSphere(float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
-			void DestroyObject( const ICustomBody* objRef );
+			ICustomBody* AddCollisionBox(::Oyster::Math::Float3 halfSize, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
+			ICustomBody* AddCollisionCylinder(::Oyster::Math::Float3 halfSize, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
 
-			void AddGravity( const API::Gravity &g );
+			void UpdateWorld();
-			void RemoveGravity( const API::Gravity &g );
 
 			void ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void* args, void(hitAction)(ICustomBody*, void*) );
 
-			//void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF );
-
-			//void SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI );
-			//void SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI );
-			//void SetMass_KeepVelocity( const ICustomBody* objRef, ::Oyster::Math::Float m );
-			//void SetMass_KeepMomentum( const ICustomBody* objRef, ::Oyster::Math::Float m );
-			//void SetCenter( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos );
-			//void SetRotation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &rotation );
-			//void SetOrientation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &orientation );
-			//void SetSize( const ICustomBody* objRef, const ::Oyster::Math::Float3 &size );
-
-			::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SimpleBodyDescription &desc ) const;
-			::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SphericalBodyDescription &desc ) const;
-
 		private:
-			::Oyster::Math::Float gravityConstant, updateFrameLength, epsilon;
+			btBroadphaseInterface* broadphase;
-			EventAction_Destruction destructionAction;
+			btDefaultCollisionConfiguration* collisionConfiguration;
-			::std::vector<API::Gravity> gravity;
+			btCollisionDispatcher* dispatcher;
-			Octree worldScene;
+			btSequentialImpulseConstraintSolver* solver;
+			btDiscreteDynamicsWorld* dynamicsWorld;
+			std::vector<ICustomBody*> customBodies;
 		};
 
 		namespace Default

Code/GamePhysics/Implementation/SimpleRigidBody.cpp

@@ -8,291 +8,177 @@ using namespace ::Oyster::Collision3D;
 using namespace ::Utility::DynamicMemory;
 using namespace ::Utility::Value;
 
-namespace Private
-{
-	const Float epsilon = (const Float)1e-20;
-
-	// Float calculations can suffer roundingerrors. Which is where epsilon = 1e-20 comes into the picture
-	inline bool EqualsZero( const Float &value )
-	{ // by Dan Andersson
-		return Abs( value ) < epsilon;
-	}
-
-	inline bool Contains( const Plane &container, const Float4 &pos )
-	{ // by Dan Andersson
-		return EqualsZero( container.normal.Dot( pos ) + container.phasing );
-	}
-
-	// revision of Ray Vs Plane intersect test, there ray is more of an axis
-	bool Intersects( const Ray &axis, const Plane &plane, Float &connectDistance )
-	{ // by Dan Andersson
-		Float c = plane.normal.Dot(axis.direction);
-		if( EqualsZero(c) )
-		{ // axis is parallell with the plane. (axis direction orthogonal with the planar normal)
-			connectDistance = 0.0f;
-			return Contains( plane, axis.origin );
-		}
-
-		connectDistance = -plane.phasing;
-		connectDistance -= plane.normal.Dot( axis.origin );
-		connectDistance /= c;
-
-		return true;
-	}
-}
-
 SimpleRigidBody::SimpleRigidBody()
 {
-	this->rigid = RigidBody();
+	this->collisionShape = NULL;
-	this->rigid.SetMass_KeepMomentum( 16.0f );
+	this->motionState = NULL;
-	this->gravityNormal = Float3::null;
+	this->rigidBody = NULL;
-	this->onCollision = Default::EventAction_BeforeCollisionResponse;
+
-	this->onCollisionResponse = Default::EventAction_AfterCollisionResponse;
+	this->state.centerPos = Float3(0.0f, 0.0f, 0.0f);
-	this->onMovement = Default::EventAction_Move;
+	this->state.quaternion = Quaternion(Float3(0.0f, 0.0f, 0.0f), 1.0f);
-	
+	this->state.dynamicFrictionCoeff = 0.0f;
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
+	this->state.staticFrictionCoeff = 0.0f;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
+	this->state.mass = 0.0f;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
+	this->state.restitutionCoeff = 0.0f;
-	this->collisionRebound.timeOfContact = 1.0f;
+	this->state.reach = Float3(0.0f, 0.0f, 0.0f);
+
+	this->afterCollision = NULL;
+	this->onMovement = NULL;
 
-	this->scene = nullptr;
 	this->customTag = nullptr;
-	this->ignoreGravity = this->isForwarded = false;
 }
 
-SimpleRigidBody::SimpleRigidBody( const API::SimpleBodyDescription &desc )
+SimpleRigidBody::~SimpleRigidBody()
-{	
-	this->rigid = RigidBody();
-	this->rigid.SetRotation( desc.rotation );
-	this->rigid.centerPos				= desc.centerPosition;
-	this->rigid.SetSize( desc.size );
-	this->rigid.restitutionCoeff		= desc.restitutionCoeff;
-	this->rigid.frictionCoeff_Static	= desc.frictionCoeff_Static;
-	this->rigid.frictionCoeff_Kinetic	= desc.frictionCoeff_Dynamic;
-	this->rigid.SetMass_KeepMomentum( desc.mass );
-	this->rigid.SetMomentOfInertia_KeepMomentum( desc.inertiaTensor );
-	this->deltaPos						= Float4::null;
-	this->deltaAxis						= Float4::null;
-
-	this->gravityNormal = Float3::null;
-	
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
-	this->collisionRebound.timeOfContact = 1.0f;
-
-	if( desc.subscription_onCollision )
-	{
-		this->onCollision = desc.subscription_onCollision;
-	}
-	else
-	{
-		this->onCollision = Default::EventAction_BeforeCollisionResponse;
-	}
-
-	if( desc.subscription_onCollisionResponse )
-	{
-		this->onCollisionResponse = desc.subscription_onCollisionResponse;
-	}
-	else
-	{
-		this->onCollisionResponse = Default::EventAction_AfterCollisionResponse;
-	}
-
-	if( desc.subscription_onMovement )
-	{
-		this->onMovement= desc.subscription_onMovement;
-	}
-	else
-	{
-		this->onMovement = Default::EventAction_Move;
-	}
-
-	this->scene = nullptr;
-	this->customTag = nullptr;
-	this->ignoreGravity = desc.ignoreGravity;
-}
-
-SimpleRigidBody::~SimpleRigidBody() {}
-
-UniquePointer<ICustomBody> SimpleRigidBody::Clone() const	
 {
-	return new SimpleRigidBody( *this );
+	delete this->motionState;
+	this->motionState = NULL;
+	delete this->collisionShape;
+	this->collisionShape = NULL;
+	delete this->rigidBody;
+	this->rigidBody = NULL;
 }
 
 SimpleRigidBody::State SimpleRigidBody::GetState() const
 {
-	return State( this->rigid.GetMass(), this->rigid.restitutionCoeff,
+	return this->state;
-				  this->rigid.frictionCoeff_Static, this->rigid.frictionCoeff_Kinetic,
-				  this->rigid.GetMomentOfInertia(), this->rigid.boundingReach,
-				  this->rigid.centerPos, this->rigid.axis,
-				  this->rigid.momentum_Linear, this->rigid.momentum_Angular, 
-				  this->rigid.gravityNormal );
 }
 
-SimpleRigidBody::State & SimpleRigidBody::GetState( SimpleRigidBody::State &targetMem ) const
+SimpleRigidBody::State& SimpleRigidBody::GetState( SimpleRigidBody::State &targetMem ) const
 {
-	return targetMem = State( this->rigid.GetMass(), this->rigid.restitutionCoeff,
+	targetMem = this->state;
-							  this->rigid.frictionCoeff_Static, this->rigid.frictionCoeff_Kinetic,
+	return targetMem;
-							  this->rigid.GetMomentOfInertia(), this->rigid.boundingReach,
-							  this->rigid.centerPos, this->rigid.axis,
-							  this->rigid.momentum_Linear, this->rigid.momentum_Angular,
-							  this->rigid.gravityNormal );
 }
 
 void SimpleRigidBody::SetState( const SimpleRigidBody::State &state )
 {
-	this->rigid.centerPos			  = state.GetCenterPosition();
+	btTransform trans;
-	this->rigid.axis				  = state.GetAngularAxis();
+	btVector3 position(state.centerPos.x, state.centerPos.y, state.centerPos.z);
-	this->rigid.boundingReach		  = state.GetReach();
+	btQuaternion quaternion(state.quaternion.imaginary.x, state.quaternion.imaginary.y, state.quaternion.imaginary.z, state.quaternion.real);
-	this->rigid.momentum_Linear		  = state.GetLinearMomentum();
+	this->motionState->getWorldTransform(trans);
-	this->rigid.momentum_Angular	  = state.GetAngularMomentum();
+	trans.setRotation(quaternion);
-	this->rigid.impulse_Linear		 += state.GetLinearImpulse();
+	trans.setOrigin(position);
-	this->rigid.impulse_Angular		 += state.GetAngularImpulse();
+	this->motionState->setWorldTransform(trans);
-	this->rigid.restitutionCoeff	  = state.GetRestitutionCoeff();
+	this->rigidBody->setFriction(state.staticFrictionCoeff);
-	this->rigid.frictionCoeff_Static  = state.GetFrictionCoeff_Static();
+	this->rigidBody->setRestitution(state.restitutionCoeff);
-	this->rigid.frictionCoeff_Kinetic = state.GetFrictionCoeff_Kinetic();
+	btVector3 fallInertia(0, 0, 0);
-	this->rigid.SetMass_KeepMomentum( state.GetMass() );
+	collisionShape->calculateLocalInertia(state.mass, fallInertia);
-	this->rigid.SetMomentOfInertia_KeepMomentum( state.GetMomentOfInertia() );
+	this->rigidBody->setMassProps(state.mass, fallInertia);
-	this->rigid.gravityNormal		  = state.GetGravityNormal();
 
-	if( state.IsForwarded() )
+	this->state = state;
-	{
-		this->deltaPos += Float4(state.GetForward_DeltaPos(), 0);
-		this->deltaAxis += Float4(state.GetForward_DeltaAxis(), 0);
-		this->isForwarded;
-	}
-
-	if( this->scene )
-	{
-		if( state.IsSpatiallyAltered() )
-		{
-			unsigned int tempRef = this->scene->GetTemporaryReferenceOf( this );
-			this->scene->SetAsAltered( tempRef );
-			this->scene->EvaluatePosition( tempRef );
-		}
-		else if( state.IsDisturbed() )
-		{
-			this->scene->SetAsAltered( this->scene->GetTemporaryReferenceOf(this) );
-		}
-	}
 }
 
-ICustomBody::SubscriptMessage SimpleRigidBody::CallSubscription_BeforeCollisionResponse( const ICustomBody *deuter )
+void SimpleRigidBody::SetCollisionShape(btCollisionShape* shape)
 {
-	return this->onCollision( this, deuter );
+	this->collisionShape = shape;
 }
 
-void SimpleRigidBody::CallSubscription_AfterCollisionResponse( const ICustomBody *deuter, Float kineticEnergyLoss )
+void SimpleRigidBody::SetMotionState(btDefaultMotionState* motionState)
 {
-	return this->onCollisionResponse( this, deuter, kineticEnergyLoss );
+	this->motionState = motionState;
+}
+
+void SimpleRigidBody::SetRigidBody(btRigidBody* rigidBody)
+{
+	this->rigidBody = rigidBody;
+	
+}
+
+void SimpleRigidBody::SetSubscription(EventAction_AfterCollisionResponse function)
+{
+	this->afterCollision = function;
+}
+
+void SimpleRigidBody::SetSubscription(EventAction_Move function)
+{
+	this->onMovement = function;
+}
+
+void SimpleRigidBody::SetLinearVelocity(Float3 velocity)
+{
+	this->rigidBody->setLinearVelocity(btVector3(velocity.x, velocity.y, velocity.z));
+}
+
+void SimpleRigidBody::SetPosition(::Oyster::Math::Float3 position)
+{
+	btTransform trans;
+	this->motionState->getWorldTransform(trans);
+	trans.setOrigin(btVector3(position.x, position.y, position.z));
+	this->motionState->setWorldTransform(trans);
+	this->state.centerPos = position;
+}
+
+void SimpleRigidBody::SetRotation(Float4 quaternion)
+{
+	btTransform trans;
+	this->motionState->getWorldTransform(trans);
+	trans.setRotation(btQuaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w));
+	this->motionState->setWorldTransform(trans);
+	this->state.quaternion = Quaternion(quaternion.xyz, quaternion.w);
+}
+
+void SimpleRigidBody::SetRotation(::Oyster::Math::Quaternion quaternion)
+{
+	btTransform trans;
+	this->motionState->getWorldTransform(trans);
+	trans.setRotation(btQuaternion(quaternion.imaginary.x, quaternion.imaginary.y, quaternion.imaginary.z, quaternion.real));
+	this->motionState->setWorldTransform(trans);
+	this->state.quaternion = quaternion;
+}
+
+void SimpleRigidBody::SetRotation(Float3 eulerAngles)
+{
+	btTransform trans;
+	this->motionState->getWorldTransform(trans);
+	trans.setRotation(btQuaternion(eulerAngles.x, eulerAngles.y, eulerAngles.z));
+	this->motionState->setWorldTransform(trans);
+	this->state.quaternion = Quaternion(Float3(trans.getRotation().x(), trans.getRotation().y(), trans.getRotation().z()), trans.getRotation().w());
+}
+
+Float4x4 SimpleRigidBody::GetRotation() const
+{
+	return this->state.GetRotation();
+}
+
+Float4x4 SimpleRigidBody::GetOrientation() const
+{
+	return this->state.GetOrientation();
+}
+
+Float4x4 SimpleRigidBody::GetView() const
+{
+	return this->state.GetView();
+}
+
+Float4x4 SimpleRigidBody::GetView( const ::Oyster::Math::Float3 &offset ) const
+{
+	return this->state.GetView(offset);
+}
+
+void SimpleRigidBody::CallSubscription_AfterCollisionResponse(ICustomBody* bodyA, ICustomBody* bodyB, Oyster::Math::Float kineticEnergyLoss)
+{
+	if(this->afterCollision)
+		this->afterCollision(bodyA, bodyB, kineticEnergyLoss);
 }
 
 void SimpleRigidBody::CallSubscription_Move()
 {
-	this->onMovement( this );
+	if(this->onMovement)
+		this->onMovement(this);
 }
 
-bool SimpleRigidBody::IsAffectedByGravity() const
+btCollisionShape* SimpleRigidBody::GetCollisionShape() const
 {
-	return !this->ignoreGravity;
+	return this->collisionShape;
 }
 
-bool SimpleRigidBody::Intersects( const ICollideable &shape ) const
+btDefaultMotionState* SimpleRigidBody::GetMotionState() const
 {
-	return Box( this->rigid.GetRotationMatrix(), this->rigid.centerPos, this->rigid.GetSize() ).Intersects( shape );
+	return this->motionState;
 }
 
-bool SimpleRigidBody::Intersects( const ICollideable &shape, Float4 &worldPointOfContact ) const
+btRigidBody* SimpleRigidBody::GetRigidBody() const
 {
-	return Box( this->rigid.GetRotationMatrix(), this->rigid.centerPos, this->rigid.GetSize() ).Intersects( shape, worldPointOfContact );
+	return this->rigidBody;
-}
-
-bool SimpleRigidBody::Intersects( const ICustomBody &object, Float4 &worldPointOfContact ) const
-{
-	return object.Intersects( Box(this->rigid.GetRotationMatrix(), this->rigid.centerPos, this->rigid.GetSize()), worldPointOfContact );
-}
-
-void SimpleRigidBody::SetTimeOfContact( Float4 &worldPointOfContact )
-{
-	Point pointOfContact = Point( worldPointOfContact );
-	Box start = Box();
-	{
-		start.rotation = RotationMatrix( this->collisionRebound.previousSpatial.axis );
-		start.center = this->collisionRebound.previousSpatial.center;
-		start.boundingOffset = this->collisionRebound.previousSpatial.reach;
-	}
-	Box end = Box();
-	{
-		end.rotation = RotationMatrix( this->rigid.axis );
-		end.center = this->rigid.centerPos;
-		end.boundingOffset = this->rigid.boundingReach;
-	}
-	Float timeOfContact = ::Oyster::Collision3D::Utility::TimeOfContact( start, end, pointOfContact );
-
-	this->collisionRebound.timeOfContact = Min( this->collisionRebound.timeOfContact, timeOfContact );
-}
-
-Sphere & SimpleRigidBody::GetBoundingSphere( Sphere &targetMem ) const
-{
-	return targetMem = Sphere( this->rigid.centerPos, this->rigid.boundingReach.GetMagnitude() );
-}
-
-Float4 & SimpleRigidBody::GetNormalAt( const Float4 &worldPos, Float4 &targetMem ) const
-{
-	Float4 offset = worldPos.xyz - this->rigid.centerPos;
-	Float distance = offset.Dot( offset );
-	Float3 normal = Float3::null;
-
-	if( distance != 0.0f )
-	{ // sanity check
-		Ray axis( Float4::standard_unit_w, offset / (Float)::std::sqrt(distance) );
-		Float minDistance = numeric_limits<Float>::max();
-		Float4x4 rotationMatrix = this->rigid.GetRotationMatrix();
-		
-		if( Private::Intersects(axis, Plane(rotationMatrix.v[0], -this->rigid.boundingReach.x), axis.collisionDistance) )
-		{ // check along x-axis
-			if( axis.collisionDistance < 0.0f )
-				normal = -rotationMatrix.v[0].xyz;
-			else
-				normal = rotationMatrix.v[0].xyz;
-
-			minDistance = Abs( axis.collisionDistance );
-		}
-
-		if( Private::Intersects(axis, Plane(rotationMatrix.v[1], -this->rigid.boundingReach.y), axis.collisionDistance) )
-		{ // check along y-axis
-			distance = Abs( axis.collisionDistance ); // recycling memory
-			if( minDistance > distance )
-			{
-				if( axis.collisionDistance < 0.0f )
-					normal = -rotationMatrix.v[1].xyz;
-				else
-					normal = rotationMatrix.v[1].xyz;
-
-				minDistance = distance;
-			}
-		}
-
-		if( Private::Intersects(axis, Plane(rotationMatrix.v[2], -this->rigid.boundingReach.z), axis.collisionDistance) )
-		{ // check along z-axis
-			if( minDistance > Abs( axis.collisionDistance ) )
-			{
-				if( axis.collisionDistance < 0.0f )
-					normal = -rotationMatrix.v[2].xyz;
-				else
-					normal = rotationMatrix.v[2].xyz;
-			}
-		}
-	}
-	targetMem.xyz = normal;
-	targetMem.w = 0.0f;
-	return targetMem;
-}
-
-Float3 & SimpleRigidBody::GetGravityNormal( Float3 &targetMem ) const
-{
-	return targetMem = this->gravityNormal;	
 }
 
 void * SimpleRigidBody::GetCustomTag() const
@@ -300,182 +186,10 @@ void * SimpleRigidBody::GetCustomTag() const
 	return this->customTag;
 }
 
-//Float3 & SimpleRigidBody::GetCenter( Float3 &targetMem ) const
-//{
-//	return targetMem = this->rigid.centerPos;
-//}
-//
-//Float4x4 & SimpleRigidBody::GetRotation( Float4x4 &targetMem ) const
-//{
-//	return targetMem = this->rigid.box.rotation;
-//}
-//
-//Float4x4 & SimpleRigidBody::GetOrientation( Float4x4 &targetMem ) const
-//{
-//	return targetMem = this->rigid.GetOrientation();
-//}
-//
-//Float4x4 & SimpleRigidBody::GetView( Float4x4 &targetMem ) const
-//{
-//	return targetMem = this->rigid.GetView();
-//}
-
-//Float3 SimpleRigidBody::GetRigidLinearVelocity() const
-//{
-//	return this->rigid.GetLinearVelocity();
-//}
-
-UpdateState SimpleRigidBody::Update( Float timeStepLength )
-{
-	if( this->collisionRebound.timeOfContact < 1.0f )
-	{ // Rebound if needed
-		this->rigid.centerPos = Lerp( this->collisionRebound.previousSpatial.center, this->rigid.centerPos, this->collisionRebound.timeOfContact );
-		this->rigid.SetRotation( Lerp(this->collisionRebound.previousSpatial.axis, this->rigid.axis, this->collisionRebound.timeOfContact) );
-		this->rigid.boundingReach = Lerp( this->collisionRebound.previousSpatial.reach, this->rigid.boundingReach, this->collisionRebound.timeOfContact );
-		timeStepLength *= 2.0f - this->collisionRebound.timeOfContact; // compensate for rebounded time
-		this->collisionRebound.timeOfContact = 1.0f;
-	}
-
-	// Maintain rotation resolution by keeping axis within [0, 2pi] (trigonometric methods gets faster too)
-	Float4 temp;
-	::std::modf( this->rigid.axis * (0.5f / pi), temp.xyz );
-	this->rigid.axis -= ((2.0f * pi) * temp).xyz;
-
-	// Update rebound data
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
-
-	// Check if this is close enough to be set resting
-	temp = Float4( this->rigid.impulse_Linear, 0.0f ) + Float4( this->rigid.impulse_Angular, 0.0f );
-	if( temp.Dot(temp) <= (Constant::epsilon * Constant::epsilon) )
-	{
-		unsigned char resting = 0;
-		if( this->rigid.momentum_Linear.Dot(this->rigid.momentum_Linear) <= (Constant::epsilon * Constant::epsilon) )
-		{
-			this->rigid.momentum_Linear = Float3::null;
-			resting = 1;
-		}
-		if( this->rigid.momentum_Angular.Dot(this->rigid.momentum_Angular) <= (Constant::epsilon * Constant::epsilon) )
-		{
-			this->rigid.momentum_Angular = Float3::null;
-			++resting;
-		}
-		if( resting == 2 )
-		{
-			this->rigid.impulse_Linear = this->rigid.impulse_Angular = Float3::null;
-			return UpdateState_resting;
-		}
-	}
-
-	this->rigid.Update_LeapFrog( timeStepLength );
-	return UpdateState_altered;
-}
-
-void SimpleRigidBody::Predict( Float4 &outDeltaPos, Float4 &outDeltaAxis, const Float4 &actingLinearImpulse, const Float4 &actingAngularImpulse, Float deltaTime )
-{
-	this->rigid.Predict_LeapFrog( outDeltaPos.xyz, outDeltaAxis.xyz, actingLinearImpulse.xyz, actingAngularImpulse.xyz, deltaTime );
-}
-
-void SimpleRigidBody::SetScene( void *scene )
-{
-	this->scene = (Octree*)scene;
-}
-
-void SimpleRigidBody::SetSubscription( ICustomBody::EventAction_BeforeCollisionResponse functionPointer )
-{
-	if( functionPointer )
-	{
-		this->onCollision = functionPointer;
-	}
-	else
-	{
-		this->onCollision = Default::EventAction_BeforeCollisionResponse;
-	}
-}
-
-void SimpleRigidBody::SetSubscription( ICustomBody::EventAction_AfterCollisionResponse functionPointer )
-{
-	if( functionPointer )
-	{
-		this->onCollisionResponse = functionPointer;
-	}
-	else
-	{
-		this->onCollisionResponse = Default::EventAction_AfterCollisionResponse;
-	}
-}
-
-void SimpleRigidBody::SetSubscription( ICustomBody::EventAction_Move functionPointer )
-{
-	if( functionPointer )
-	{
-		this->onMovement = functionPointer;
-	}
-	else
-	{
-		this->onMovement = Default::EventAction_Move;
-	}
-}
-
-void SimpleRigidBody::SetGravity( bool ignore)
-{
-	this->ignoreGravity = ignore;
-	this->gravityNormal = Float3::null;
-}
-
-void SimpleRigidBody::SetGravityNormal( const Float3 &normalizedVector )
-{
-	this->gravityNormal = normalizedVector;
-	this->rigid.gravityNormal = Float4( this->gravityNormal, 0 );
-}
 
 void SimpleRigidBody::SetCustomTag( void *ref )
 {
 	this->customTag = ref;
 }
 
-//void SimpleRigidBody::SetMomentOfInertiaTensor_KeepVelocity( const Float4x4 &localI )
+
-//{
-//	this->rigid.SetMomentOfInertia_KeepVelocity( localI );
-//}
-//
-//void SimpleRigidBody::SetMomentOfInertiaTensor_KeepMomentum( const Float4x4 &localI )
-//{
-//	this->rigid.SetMomentOfInertia_KeepMomentum( localI );
-//}
-//
-//void SimpleRigidBody::SetMass_KeepVelocity( Float m )
-//{
-//	this->rigid.SetMass_KeepVelocity( m );
-//}
-//
-//void SimpleRigidBody::SetMass_KeepMomentum( Float m )
-//{
-//	this->rigid.SetMass_KeepMomentum( m );
-//}
-//
-//void SimpleRigidBody::SetCenter( const Float3 &worldPos )
-//{
-//	this->rigid.SetCenter( worldPos );
-//}
-//
-//void SimpleRigidBody::SetRotation( const Float4x4 &rotation )
-//{
-//	this->rigid.SetRotation( rotation );
-//}
-//
-//void SimpleRigidBody::SetOrientation( const Float4x4 &orientation )
-//{
-//	this->rigid.SetOrientation( orientation );
-//}
-//
-//void SimpleRigidBody::SetSize( const Float3 &size )
-//{
-//	this->rigid.SetSize( size );
-//}
-//
-//void SimpleRigidBody::SetMomentum( const Float3 &worldG )
-//{
-//	this->rigid.SetLinearMomentum( worldG );
-//}

Code/GamePhysics/Implementation/SimpleRigidBody.h

@@ -2,86 +2,63 @@
 #define OYSTER_PHYSICS_SIMPLE_RIGIDBODY_H
 
 #include "..\PhysicsAPI.h"
-#include "RigidBody.h"
+#include <btBulletDynamicsCommon.h>
-#include "Octree.h"
 
-namespace Oyster { namespace Physics
+namespace Oyster 
-{
+{ 
-	class SimpleRigidBody : public ICustomBody
+	namespace Physics
 	{
-	public:
+		class SimpleRigidBody : public ICustomBody
-		SimpleRigidBody();
-		SimpleRigidBody( const API::SimpleBodyDescription &desc );
-		virtual ~SimpleRigidBody();
-
-		::Utility::DynamicMemory::UniquePointer<ICustomBody> Clone() const;
-		
-		State GetState() const;
-		State & GetState( State &targetMem ) const;
-		void SetState( const State &state );
-		//::Oyster::Math::Float3 GetRigidLinearVelocity() const;
-
-		SubscriptMessage CallSubscription_BeforeCollisionResponse( const ICustomBody *deuter );
-		void CallSubscription_AfterCollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
-		void CallSubscription_Move();
-
-		bool IsAffectedByGravity() const;
-		bool Intersects( const ::Oyster::Collision3D::ICollideable &shape ) const;
-		bool Intersects( const ::Oyster::Collision3D::ICollideable &shape, ::Oyster::Math::Float4 &worldPointOfContact ) const;
-		bool Intersects( const ICustomBody &object, ::Oyster::Math::Float4 &worldPointOfContact ) const;
-
-		void SetTimeOfContact( ::Oyster::Math::Float4 &worldPointOfContact );
-
-		::Oyster::Collision3D::Sphere &	GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const;
-		::Oyster::Math::Float4 &		GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const;
-		::Oyster::Math::Float3 &		GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
-		void *							GetCustomTag() const;
-		//::Oyster::Math::Float3 &		GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
-		//::Oyster::Math::Float4x4 &		GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
-		//::Oyster::Math::Float4x4 &		GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
-		//::Oyster::Math::Float4x4 &		GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
-
-		UpdateState Update( ::Oyster::Math::Float timeStepLength );
-		void Predict( ::Oyster::Math::Float4 &outDeltaPos, ::Oyster::Math::Float4 &outDeltaAxis, const ::Oyster::Math::Float4 &actingLinearImpulse, const ::Oyster::Math::Float4 &actingAngularImpulse, ::Oyster::Math::Float deltaTime );
-
-		void SetScene( void *scene );
-
-		void SetSubscription( EventAction_BeforeCollisionResponse functionPointer );
-		void SetSubscription( EventAction_AfterCollisionResponse functionPointer );
-		void SetSubscription( EventAction_Move functionPointer );
-
-		void SetGravity( bool ignore);
-		void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector );
-		void SetCustomTag( void *ref );
-		//void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI );
-		//void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI );
-		//void SetMass_KeepVelocity( ::Oyster::Math::Float m );
-		//void SetMass_KeepMomentum( ::Oyster::Math::Float m );
-		//void SetCenter( const ::Oyster::Math::Float3 &worldPos );
-		//void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
-		//void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
-		//void SetSize( const ::Oyster::Math::Float3 &size );
-		//void SetMomentum( const ::Oyster::Math::Float3 &worldG );
-
-	private:
-		::Oyster::Physics3D::RigidBody rigid;
-		::Oyster::Math::Float4 deltaPos, deltaAxis;
-		::Oyster::Math::Float3 gravityNormal;
-
-		struct
 		{
-			struct { ::Oyster::Math::Float3 center, axis, reach; } previousSpatial;
+		public:
-			::Oyster::Math::Float timeOfContact;
+			SimpleRigidBody();
-		} collisionRebound;
+			virtual ~SimpleRigidBody();
 
-		EventAction_BeforeCollisionResponse onCollision;
+			State GetState() const;
-		EventAction_AfterCollisionResponse onCollisionResponse;
+			State& GetState( State &targetMem ) const;
-		EventAction_Move onMovement;
+			void SetState( const State &state );
 
-		Octree *scene;
+			void SetCollisionShape(btCollisionShape* shape);
-		void *customTag;
+			void SetMotionState(btDefaultMotionState* motionState);
-		bool ignoreGravity, isForwarded;
+			void SetRigidBody(btRigidBody* rigidBody);
-	};
+			
-} }
+			void SetSubscription(EventAction_AfterCollisionResponse function);
+			void SetSubscription(EventAction_Move function);
+
+			void SetLinearVelocity(Math::Float3 velocity);
+			void SetPosition(::Oyster::Math::Float3 position);
+			void SetRotation(Math::Float4 quaternion);
+			void SetRotation(::Oyster::Math::Quaternion quaternion);
+			void SetRotation(Math::Float3 eulerAngles);
+
+			Math::Float4x4 GetRotation() const;
+			Math::Float4x4 GetOrientation() const;
+			Math::Float4x4 GetView() const;
+			Math::Float4x4 GetView( const ::Oyster::Math::Float3 &offset ) const;
+
+			void CallSubscription_AfterCollisionResponse(ICustomBody* bodyA, ICustomBody* bodyB, Math::Float kineticEnergyLoss);
+			void CallSubscription_Move();
+
+			btCollisionShape* GetCollisionShape() const;
+			btDefaultMotionState* GetMotionState() const;
+			btRigidBody* GetRigidBody() const;
+
+			void SetCustomTag( void *ref );
+			void* GetCustomTag() const;
+
+			private:
+			btCollisionShape* collisionShape;
+			btDefaultMotionState* motionState;
+			btRigidBody* rigidBody;
+
+			Struct::CustomBodyState state;
+
+			EventAction_AfterCollisionResponse afterCollision;
+			EventAction_Move onMovement;
+
+			void *customTag;
+		};
+	} 
+}
 
 #endif

Code/GamePhysics/Implementation/SphericalRigidBody.cpp

@@ -1,405 +0,0 @@
-#include "SphericalRigidBody.h"
-#include "PhysicsAPI_Impl.h"
-
-using namespace ::Oyster::Physics;
-using namespace ::Oyster::Physics3D;
-using namespace ::Oyster::Math3D;
-using namespace ::Oyster::Collision3D;
-using namespace ::Utility::DynamicMemory;
-using namespace ::Utility::Value;
-
-SphericalRigidBody::SphericalRigidBody()
-{
-	this->rigid = RigidBody();
-	this->rigid.SetMass_KeepMomentum( 16.0f );
-	this->gravityNormal = Float3::null;
-	this->onCollision = Default::EventAction_BeforeCollisionResponse;
-	this->onCollisionResponse = Default::EventAction_AfterCollisionResponse;
-	this->onMovement = Default::EventAction_Move;
-	
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
-	this->collisionRebound.timeOfContact = 1.0f;
-
-	this->scene = nullptr;
-	this->customTag = nullptr;
-	this->ignoreGravity = this->isForwarded = false;
-}
-
-SphericalRigidBody::SphericalRigidBody( const API::SphericalBodyDescription &desc )
-{
-	this->rigid							= RigidBody();
-	this->rigid.SetRotation( desc.rotation );
-	this->rigid.centerPos				= desc.centerPosition;
-	this->rigid.boundingReach			= Float4( desc.radius, desc.radius, desc.radius, 0.0f );
-	this->rigid.restitutionCoeff		= desc.restitutionCoeff;
-	this->rigid.frictionCoeff_Static	= desc.frictionCoeff_Static;
-	this->rigid.frictionCoeff_Kinetic	= desc.frictionCoeff_Dynamic;
-	this->rigid.SetMass_KeepMomentum( desc.mass );
-	this->rigid.SetMomentOfInertia_KeepMomentum( MomentOfInertia::Sphere(desc.mass, desc.radius) );
-	this->deltaPos						= Float4::null;
-	this->deltaAxis						= Float4::null;
-
-	this->gravityNormal = Float3::null;
-
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
-	this->collisionRebound.timeOfContact = 1.0f;
-
-	if( desc.subscription_onCollision )
-	{
-		this->onCollision = desc.subscription_onCollision;
-	}
-	else
-	{
-		this->onCollision = Default::EventAction_BeforeCollisionResponse;
-	}
-
-	if( desc.subscription_onCollisionResponse )
-	{
-		this->onCollisionResponse = desc.subscription_onCollisionResponse;
-	}
-	else
-	{
-		this->onCollisionResponse = Default::EventAction_AfterCollisionResponse;
-	}
-
-	if( desc.subscription_onMovement )
-	{
-		this->onMovement= desc.subscription_onMovement;
-	}
-	else
-	{
-		this->onMovement = Default::EventAction_Move;
-	}
-
-	this->scene = nullptr;
-	this->customTag = nullptr;
-	this->ignoreGravity = desc.ignoreGravity;
-
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
-	this->collisionRebound.timeOfContact = 1.0f;
-}
-
-SphericalRigidBody::~SphericalRigidBody() {}
-
-UniquePointer<ICustomBody> SphericalRigidBody::Clone() const	
-{
-	return new SphericalRigidBody( *this );
-}
-
-SphericalRigidBody::State SphericalRigidBody::GetState() const
-{
-	return State( this->rigid.GetMass(), this->rigid.restitutionCoeff,
-				  this->rigid.frictionCoeff_Static, this->rigid.frictionCoeff_Kinetic,
-				  this->rigid.GetMomentOfInertia(), this->rigid.boundingReach,
-				  this->rigid.centerPos, this->rigid.axis,
-				  this->rigid.momentum_Linear, this->rigid.momentum_Angular );
-}
-
-SphericalRigidBody::State & SphericalRigidBody::GetState( SphericalRigidBody::State &targetMem ) const
-{
-	return targetMem = State( this->rigid.GetMass(), this->rigid.restitutionCoeff,
-							  this->rigid.frictionCoeff_Static, this->rigid.frictionCoeff_Kinetic,
-							  this->rigid.GetMomentOfInertia(), this->rigid.boundingReach,
-							  this->rigid.centerPos, this->rigid.axis,
-							  this->rigid.momentum_Linear, this->rigid.momentum_Angular );
-}
-
-void SphericalRigidBody::SetState( const SphericalRigidBody::State &state )
-{
-	this->rigid.centerPos			  = state.GetCenterPosition();
-	this->rigid.axis				  = state.GetAngularAxis();
-	this->rigid.boundingReach		  = state.GetReach();
-	this->rigid.momentum_Linear		  = state.GetLinearMomentum();
-	this->rigid.momentum_Angular	  = state.GetAngularMomentum();
-	this->rigid.impulse_Linear		 += state.GetLinearImpulse();
-	this->rigid.impulse_Angular		 += state.GetAngularImpulse();
-	this->rigid.restitutionCoeff	  = state.GetRestitutionCoeff();
-	this->rigid.frictionCoeff_Static  = state.GetFrictionCoeff_Static();
-	this->rigid.frictionCoeff_Kinetic = state.GetFrictionCoeff_Kinetic();
-	this->rigid.SetMass_KeepMomentum( state.GetMass() );
-	this->rigid.SetMomentOfInertia_KeepMomentum( state.GetMomentOfInertia() );
-	this->rigid.gravityNormal		  = state.GetGravityNormal();
-
-	if( state.IsForwarded() )
-	{
-		this->deltaPos += Float4(state.GetForward_DeltaPos(), 0);
-		this->deltaAxis += Float4(state.GetForward_DeltaAxis());
-		this->isForwarded = false;
-	}
-
-	if( this->scene )
-	{
-		if( state.IsSpatiallyAltered() )
-		{
-			unsigned int tempRef = this->scene->GetTemporaryReferenceOf( this );
-			this->scene->SetAsAltered( tempRef );
-			this->scene->EvaluatePosition( tempRef );
-		}
-		else if( state.IsDisturbed() )
-		{
-			this->scene->SetAsAltered( this->scene->GetTemporaryReferenceOf(this) );
-		}
-	}
-}
-
-ICustomBody::SubscriptMessage SphericalRigidBody::CallSubscription_BeforeCollisionResponse( const ICustomBody *deuter )
-{
-	return this->onCollision( this, deuter );
-}
-
-void SphericalRigidBody::CallSubscription_AfterCollisionResponse( const ICustomBody *deuter, Float kineticEnergyLoss )
-{
-	this->onCollisionResponse( this, deuter, kineticEnergyLoss);
-}
-
-
-void SphericalRigidBody::CallSubscription_Move()
-{
-	this->onMovement( this );
-}
-
-bool SphericalRigidBody::IsAffectedByGravity() const
-{
-	return !this->ignoreGravity;
-}
-
-bool SphericalRigidBody::Intersects( const ICollideable &shape ) const
-{
-	return Sphere( this->rigid.centerPos, this->rigid.boundingReach.x ).Intersects( shape );
-}
-
-bool SphericalRigidBody::Intersects( const ICollideable &shape, Float4 &worldPointOfContact ) const
-{
-	return Sphere( this->rigid.centerPos, this->rigid.boundingReach.x ).Intersects( shape, worldPointOfContact );
-}
-
-bool SphericalRigidBody::Intersects( const ICustomBody &object, Float4 &worldPointOfContact ) const
-{
-	return object.Intersects( Sphere(this->rigid.centerPos, this->rigid.boundingReach.x), worldPointOfContact );
-}
-
-void SphericalRigidBody::SetTimeOfContact( Float4 &worldPointOfContact )
-{
-	Point pointOfContact = Point( worldPointOfContact );
-	Sphere start = Sphere( this->collisionRebound.previousSpatial.center, this->collisionRebound.previousSpatial.reach.x );
-	Sphere end = Sphere( this->rigid.centerPos, this->rigid.boundingReach.x );
-
-	Float timeOfContact = ::Oyster::Collision3D::Utility::TimeOfContact( start, end, pointOfContact );
-
-	this->collisionRebound.timeOfContact = Min( this->collisionRebound.timeOfContact, timeOfContact );
-}
-
-Sphere & SphericalRigidBody::GetBoundingSphere( Sphere &targetMem ) const
-{
-	return targetMem = Sphere( this->rigid.centerPos, this->rigid.boundingReach.x );
-}
-
-Float4 & SphericalRigidBody::GetNormalAt( const Float4 &worldPos, Float4 &targetMem ) const
-{
-	targetMem = Float4( worldPos.xyz - this->rigid.centerPos, 0);
-	Float magnitude = targetMem.GetMagnitude();
-	if( magnitude != 0.0f )
-	{ // sanity check
-		targetMem.Normalize();
-	}
-
-	return targetMem;
-}
-
-Float3 & SphericalRigidBody::GetGravityNormal( Float3 &targetMem ) const
-{
-	return targetMem = this->gravityNormal;	
-}
-
-void * SphericalRigidBody::GetCustomTag() const
-{
-	return this->customTag;
-}
-
-//Float3 & SphericalRigidBody::GetCenter( Float3 &targetMem ) const
-//{
-//	return targetMem = this->rigid.centerPos;
-//}
-//
-//Float4x4 & SphericalRigidBody::GetRotation( Float4x4 &targetMem ) const
-//{
-//	return targetMem = this->rigid.box.rotation;
-//}
-//
-//Float4x4 & SphericalRigidBody::GetOrientation( Float4x4 &targetMem ) const
-//{
-//	return targetMem = this->rigid.GetOrientation();
-//}
-//
-//Float4x4 & SphericalRigidBody::GetView( Float4x4 &targetMem ) const
-//{
-//	return targetMem = this->rigid.GetView();
-//}
-
-//Float3 SphericalRigidBody::GetRigidLinearVelocity() const
-//{
-//	return this->rigid.GetLinearVelocity();
-//}
-
-UpdateState SphericalRigidBody::Update( Float timeStepLength )
-{
-	if( this->collisionRebound.timeOfContact < 1.0f )
-	{ // Rebound if needed
-		this->rigid.centerPos = Lerp( this->collisionRebound.previousSpatial.center, this->rigid.centerPos, this->collisionRebound.timeOfContact );
-		this->rigid.SetRotation( Lerp(this->collisionRebound.previousSpatial.axis, this->rigid.axis, this->collisionRebound.timeOfContact) );
-		this->rigid.boundingReach = Lerp( this->collisionRebound.previousSpatial.reach, this->rigid.boundingReach, this->collisionRebound.timeOfContact );
-		timeStepLength *= 2.0f - this->collisionRebound.timeOfContact; // compensate for rebounded time
-		this->collisionRebound.timeOfContact = 1.0f;
-	}
-
-	// Maintain rotation resolution by keeping axis within [0, 2pi] (trigonometric methods gets faster too)
-	Float4 temp;
-	::std::modf( this->rigid.axis * (0.5f / pi), temp.xyz );
-	this->rigid.axis -= ((2.0f * pi) * temp).xyz;
-
-	// Update rebound data
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
-
-	// Check if this is close enough to be set resting
-	temp = Float4( this->rigid.impulse_Linear, 0.0f ) + Float4( this->rigid.impulse_Angular, 0.0f );
-	if( temp.Dot(temp) <= (Constant::epsilon * Constant::epsilon) )
-	{
-		unsigned char resting = 0;
-		if( this->rigid.momentum_Linear.Dot(this->rigid.momentum_Linear) <= (Constant::epsilon * Constant::epsilon) )
-		{
-			this->rigid.momentum_Linear = Float3::null;
-			resting = 1;
-		}
-		if( this->rigid.momentum_Angular.Dot(this->rigid.momentum_Angular) <= (Constant::epsilon * Constant::epsilon) )
-		{
-			this->rigid.momentum_Angular = Float3::null;
-			++resting;
-		}
-		if( resting == 2 )
-		{
-			this->rigid.impulse_Linear = this->rigid.impulse_Angular = Float3::null;
-			return UpdateState_resting;
-		}
-	}
-
-	this->rigid.Update_LeapFrog( timeStepLength );
-	return UpdateState_altered;
-}
-
-void SphericalRigidBody::Predict( ::Oyster::Math::Float4 &outDeltaPos, ::Oyster::Math::Float4 &outDeltaAxis, const ::Oyster::Math::Float4 &actingLinearImpulse, const ::Oyster::Math::Float4 &actingAngularImpulse, ::Oyster::Math::Float deltaTime )
-{
-	this->rigid.Predict_LeapFrog( outDeltaPos.xyz, outDeltaAxis.xyz, actingLinearImpulse.xyz, actingAngularImpulse.xyz, deltaTime );
-}
-
-void SphericalRigidBody::SetSubscription( ICustomBody::EventAction_BeforeCollisionResponse functionPointer )
-{
-	if( functionPointer )
-	{
-		this->onCollision = functionPointer;
-	}
-	else
-	{
-		this->onCollision = Default::EventAction_BeforeCollisionResponse;
-	}
-}
-
-void SphericalRigidBody::SetSubscription( ICustomBody::EventAction_AfterCollisionResponse functionPointer )
-{
-	if( functionPointer )
-	{
-		this->onCollisionResponse = functionPointer;
-	}
-	else
-	{
-		this->onCollisionResponse = Default::EventAction_AfterCollisionResponse;
-	}
-}
-
-void SphericalRigidBody::SetSubscription( ICustomBody::EventAction_Move functionPointer )
-{
-	if( functionPointer )
-	{
-		this->onMovement = functionPointer;
-	}
-	else
-	{
-		this->onMovement = Default::EventAction_Move;
-	}
-}
-
-void SphericalRigidBody::SetScene( void *scene )
-{
-	this->scene = (Octree*)scene;
-}
-
-void SphericalRigidBody::SetGravity( bool ignore )
-{
-	this->ignoreGravity = ignore;
-	this->gravityNormal = Float3::null;
-}
-
-void SphericalRigidBody::SetGravityNormal( const Float3 &normalizedVector )
-{
-	this->gravityNormal = normalizedVector;
-}
-
-void SphericalRigidBody::SetCustomTag( void *ref )
-{
-	this->customTag = ref;
-}
-
-//void SphericalRigidBody::SetMomentOfInertiaTensor_KeepVelocity( const Float4x4 &localI )
-//{
-//	this->rigid.SetMomentOfInertia_KeepVelocity( localI );
-//}
-//
-//void SphericalRigidBody::SetMomentOfInertiaTensor_KeepMomentum( const Float4x4 &localI )
-//{
-//	this->rigid.SetMomentOfInertia_KeepMomentum( localI );
-//}
-//
-//void SphericalRigidBody::SetMass_KeepVelocity( Float m )
-//{
-//	this->rigid.SetMass_KeepVelocity( m );
-//}
-//
-//void SphericalRigidBody::SetMass_KeepMomentum( Float m )
-//{
-//	this->rigid.SetMass_KeepMomentum( m );
-//}
-//
-//void SphericalRigidBody::SetCenter( const Float3 &worldPos )
-//{
-//	this->rigid.SetCenter( worldPos );
-//	this->body.center = worldPos;
-//}
-//
-//void SphericalRigidBody::SetRotation( const Float4x4 &rotation )
-//{
-//	this->rigid.SetRotation( rotation );
-//}
-//
-//void SphericalRigidBody::SetOrientation( const Float4x4 &orientation )
-//{
-//	this->rigid.SetOrientation( orientation );
-//	this->body.center = orientation.v[3].xyz;
-//}
-//
-//void SphericalRigidBody::SetSize( const Float3 &size )
-//{
-//	this->rigid.SetSize( size );
-//	this->body.radius = 0.5f * Min( Min( size.x, size.y ), size.z ); // inline Min( FloatN )?
-//}
-//
-//void SphericalRigidBody::SetMomentum( const Float3 &worldG )
-//{
-//	this->rigid.SetLinearMomentum( worldG );
-//}

Code/GamePhysics/Implementation/SphericalRigidBody.h

@@ -1,87 +0,0 @@
-#ifndef OYSTER_PHYSICS_SPHERICAL_RIGIDBODY_H
-#define OYSTER_PHYSICS_SPHERICAL_RIGIDBODY_H
-
-#include "..\PhysicsAPI.h"
-#include "RigidBody.h"
-#include "Sphere.h"
-#include "Octree.h"
-
-namespace Oyster { namespace Physics
-{
-	class SphericalRigidBody : public ICustomBody
-	{
-	public:
-		SphericalRigidBody();
-		SphericalRigidBody( const API::SphericalBodyDescription &desc );
-		virtual ~SphericalRigidBody();
-
-		::Utility::DynamicMemory::UniquePointer<ICustomBody> Clone() const;
-		
-		State GetState() const;
-		State & GetState( State &targetMem = State() ) const;
-		void SetState( const State &state );
-		//::Oyster::Math::Float3 GetRigidLinearVelocity() const;
-
-		SubscriptMessage CallSubscription_BeforeCollisionResponse( const ICustomBody *deuter );
-		void CallSubscription_AfterCollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
-		void CallSubscription_Move();
-
-		bool IsAffectedByGravity() const;
-		bool Intersects( const ::Oyster::Collision3D::ICollideable &shape ) const;
-		bool Intersects( const ::Oyster::Collision3D::ICollideable &shape, ::Oyster::Math::Float4 &worldPointOfContact ) const;
-		bool Intersects( const ICustomBody &object, ::Oyster::Math::Float4 &worldPointOfContact ) const;
-
-		void SetTimeOfContact( ::Oyster::Math::Float4 &worldPointOfContact );
-
-		::Oyster::Collision3D::Sphere &	GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const;
-		::Oyster::Math::Float4 &		GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const;
-		::Oyster::Math::Float3 &		GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
-		void *							GetCustomTag() const;
-		//::Oyster::Math::Float3 &		GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
-		//::Oyster::Math::Float4x4 &		GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
-		//::Oyster::Math::Float4x4 &		GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
-		//::Oyster::Math::Float4x4 &		GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
-
-		UpdateState Update( ::Oyster::Math::Float timeStepLength );
-		void Predict( ::Oyster::Math::Float4 &outDeltaPos, ::Oyster::Math::Float4 &outDeltaAxis, const ::Oyster::Math::Float4 &actingLinearImpulse, const ::Oyster::Math::Float4 &actingAngularImpulse, ::Oyster::Math::Float deltaTime );
-
-		void SetScene( void *scene );
-
-		void SetSubscription( EventAction_BeforeCollisionResponse functionPointer );
-		void SetSubscription( EventAction_AfterCollisionResponse functionPointer );
-		void SetSubscription( EventAction_Move functionPointer );
-
-		void SetGravity( bool ignore);
-		void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector );
-		void SetCustomTag( void *ref );
-		//void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI );
-		//void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI );
-		//void SetMass_KeepVelocity( ::Oyster::Math::Float m );
-		//void SetMass_KeepMomentum( ::Oyster::Math::Float m );
-		//void SetCenter( const ::Oyster::Math::Float3 &worldPos );
-		//void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
-		//void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
-		//void SetSize( const ::Oyster::Math::Float3 &size );
-		//void SetMomentum( const ::Oyster::Math::Float3 &worldG );
-
-	private:
-		::Oyster::Physics3D::RigidBody rigid;
-		::Oyster::Math::Float4 deltaPos, deltaAxis;
-		::Oyster::Math::Float3 gravityNormal;
-
-		struct
-		{
-			struct { ::Oyster::Math::Float3 center, axis, reach; } previousSpatial;
-			::Oyster::Math::Float timeOfContact;
-		} collisionRebound;
-
-		EventAction_BeforeCollisionResponse onCollision;
-		EventAction_AfterCollisionResponse onCollisionResponse;
-		EventAction_Move onMovement;
-		Octree *scene;
-		void *customTag;
-		bool ignoreGravity, isForwarded;
-	};
-} }
-
-#endif

Code/GamePhysics/PhysicsAPI.h

@@ -55,35 +55,7 @@ namespace Oyster
 			 * @param numGravityWells: The predicted max number of active gravity wells.
 			 * @param worldSize: The size of acceptable physics space.
 			 ********************************************************/
-			virtual void Init( unsigned int numObjects, unsigned int numGravityWells , const ::Oyster::Math::Float3 &worldSize ) = 0;
+			virtual void Init() = 0;
-
-			/********************************************************
-			 * Sets the time length of each physics update frame.
-			 ********************************************************/
-			virtual void SetFrameTimeLength( float seconds ) = 0;
-			
-			/********************************************************
-			 * Sets the Gravityconstant in the physics that will be
-			 * used in ForceField calculations.
-			 * @param g: Default is the real world Constant::gravity_constant [N(m/kg)^2]
-			 ********************************************************/
-			virtual void SetGravityConstant( float g ) = 0;
-			
-			/********************************************************
-			 * Sets the function that will be called by the engine
-			 * whenever an object is being destroyed for some reason.
-			 * - Because DestroyObject(...) were called.
-			 * - Out of memory forced engine to destroy an object.
-			 * @param functionPointer: If NULL, an empty default function will be set.
-			 ********************************************************/
-			virtual void SetSubscription( EventAction_Destruction functionPointer ) = 0;
-
-			/********************************************************
-			 * Triggers the engine to run next update frame.
-			 * All accumulated forces and changes will be consumed.
-			 * EventAction functions might be called.
-			 ********************************************************/
-			virtual void Update() = 0;
 
 			/********************************************************
 			 * An object in limbo state will be ignored during the physics frame Update.
@@ -106,36 +78,15 @@ namespace Oyster
 			 ********************************************************/
 			virtual void ReleaseFromLimbo( const ICustomBody* objRef ) = 0;
 
-			/********************************************************
-			 * Introduces a new object into the engine.
-			 * @param handle: A pointer along with the responsibility to delete.
-			 ********************************************************/
-			virtual void AddObject( ::Utility::DynamicMemory::UniquePointer<ICustomBody> handle ) = 0;
 
-			/********************************************************
+			// Bullet physics
-			 * Fetches and removes an object from the engine.
+			virtual ICustomBody* AddCollisionSphere(float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
-			 * Will not call the provided EventAction_Destruction method.
+			virtual ICustomBody* AddCollisionBox(::Oyster::Math::Float3 halfSize, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
-			 * @param objRef: A pointer to the ICustomBody representing a physical object.
+			virtual ICustomBody* AddCollisionCylinder(::Oyster::Math::Float3 halfSize, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
-			 * @return A pointer along with the responsibility to delete. NULL if faulty objRef.
-			 ********************************************************/
-			virtual ::Utility::DynamicMemory::UniquePointer<ICustomBody> ExtractObject( const ICustomBody* objRef ) = 0;
 
-			/********************************************************
+			virtual void UpdateWorld() = 0;
-			 * Removes an object from the engine.
-			 * Will call the provided EventAction_Destruction method. Not if objRef is faulty.
-			 * @param objRef: A pointer to the ICustomBody representing a physical object.
-			 ********************************************************/
-			virtual void DestroyObject( const ICustomBody* objRef ) = 0;
 
-			/********************************************************
-			 * TODO: @todo doc
-			 ********************************************************/
-			virtual void AddGravity( const API::Gravity &g ) = 0;
 
-			/********************************************************
-			 * TODO: @todo doc
-			 ********************************************************/
-			virtual void RemoveGravity( const API::Gravity &g ) = 0;
 
 			/********************************************************
 			 * Applies an effect to objects that collide with the set volume.
@@ -146,88 +97,6 @@ namespace Oyster
 			 ********************************************************/
 			virtual void ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void* args, void(hitAction)(ICustomBody*, void*) ) = 0;
 
-			///********************************************************
-			// * Apply force on an object.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param worldPos: Relative to the world origo. (Not relative to object) [m]
-			// * @param worldF: Vector with the direction and magnitude of the force. [N]
-			// ********************************************************/
-			//virtual void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF ) = 0;
-
-			///********************************************************
-			// * Sets the MomentOfInertia tensor matrix of an object without changing it's angular velocity.
-			// * Noticeable effect: The angular momentum will change. Changing the amount of kinetic energy.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param localI: The tensor matrix relative to the axises of the object. @see MomentOfInertia namespace.
-			// ********************************************************/
-			//virtual void SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ) = 0;
-			//
-			///********************************************************
-			// * Sets the MomentOfInertia tensor matrix of an object without changing it's angular momentum.
-			// * Noticeable effect: The angular velocity will change. Can be used to create slow effects.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param localI: The tensor matrix relative to the axises of the object. @see MomentOfInertia namespace.
-			// ********************************************************/
-			//virtual void SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ) = 0;
-			//
-			///********************************************************
-			// * Sets the mass of an object without changing it's linear velocity.
-			// * Noticeable effect: The linear momentum will change. Changing the amount of kinetic energy.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param m: [kg]
-			// ********************************************************/
-			//virtual void SetMass_KeepVelocity( const ICustomBody* objRef, ::Oyster::Math::Float m ) = 0;
-			//
-			///********************************************************
-			// * Sets the mass of an object without changing it's linear velocity.
-			// * Noticeable effect: The linear velocity will change. Can be used to create slow effects.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param m: [kg]
-			// ********************************************************/
-			//virtual void SetMass_KeepMomentum( const ICustomBody* objRef, ::Oyster::Math::Float m ) = 0;
-			//
-			///********************************************************
-			// * Instantly moves an object.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param worldPos: Relative to the world origo. (Not relative to object) [m]
-			// ********************************************************/
-			//virtual void SetCenter( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos ) = 0;
-			//
-			///********************************************************
-			// * Instantly redirects object.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param rotation: New rotation.
-			// ********************************************************/
-			//virtual void SetRotation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &rotation ) = 0;
-			//
-			///********************************************************
-			// * Instantly moves and redirects object.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param orientation: New orientation.
-			// ********************************************************/
-			//virtual void SetOrientation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &orientation ) = 0;
-			//
-			///********************************************************
-			// * Resizes the boundingBox.
-			// * @param objRef: A pointer to the ICustomBody representing a physical object.
-			// * @param size: New size of this [m]
-			// ********************************************************/
-			//virtual void SetSize( const ICustomBody* objRef, const ::Oyster::Math::Float3 &size ) = 0;
-
-			/********************************************************
-			 * Creates a new dynamically allocated object that can be used as a component for more complex ICustomBodies.
-			 * @param desc: @see API::SimpleBodyDescription
-			 * @return A pointer along with the responsibility to delete.
-			 ********************************************************/
-			virtual ::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SimpleBodyDescription &desc ) const = 0;
-
-			/********************************************************
-			 * Creates a new dynamically allocated object that can be used as a component for more complex ICustomBodies.
-			 * @param desc: @see API::SphericalBodyDescription
-			 * @return A pointer along with the responsibility to delete.
-			 ********************************************************/
-			virtual ::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SphericalBodyDescription &desc ) const = 0;
-
 		protected:
 			virtual ~API() {}
 		};
@@ -246,190 +115,37 @@ namespace Oyster
 				SubscriptMessage_player_collision_response
 			};
 
+			
 			typedef SubscriptMessage (*EventAction_BeforeCollisionResponse)( const ICustomBody *proto, const ICustomBody *deuter );
 			typedef void (*EventAction_AfterCollisionResponse)( const ICustomBody *proto, const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
 			typedef void (*EventAction_Move)( const ICustomBody *object );
-			typedef Struct::SimpleBodyDescription SimpleBodyDescription;
-			typedef Struct::SphericalBodyDescription SphericalBodyDescription;
 			typedef Struct::CustomBodyState State;
 
 			virtual ~ICustomBody() {};
 
-			/********************************************************
-			 * Creates a complete copy of the current (type)object.
-			 * @return An ICustomBody pointer along with the responsibility to delete.
-			 ********************************************************/
-			virtual ::Utility::DynamicMemory::UniquePointer<ICustomBody> Clone() const = 0;
-
-			/********************************************************
-			 * @todo TODO: need doc
-			 ********************************************************/
-			virtual SubscriptMessage CallSubscription_BeforeCollisionResponse( const ICustomBody *deuter ) = 0;
-
-			/********************************************************
-			 * @todo TODO: need doc
-			 ********************************************************/
-			virtual void CallSubscription_AfterCollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss ) = 0;
-
-			/********************************************************
-			 * @todo TODO: need doc
-			 ********************************************************/
-			virtual void CallSubscription_Move() = 0;
-
-			/********************************************************
-			 * @todo TODO: need doc
-			 ********************************************************/
 			virtual State GetState() const = 0;
-
-			/********************************************************
-			 * @todo TODO: need doc
-			 ********************************************************/
 			virtual State & GetState( State &targetMem ) const = 0;
-
-			/********************************************************
-			 * @return the linear velocity of the rigid body in a vector.
-			 ********************************************************/
-			//virtual Math::Float3 GetRigidLinearVelocity() const = 0;
-
-			/********************************************************
-			 * @todo TODO: need doc
-			 ********************************************************/
 			virtual void SetState( const State &state ) = 0;
 
-			/********************************************************
+			virtual void SetSubscription(EventAction_AfterCollisionResponse function) = 0;
-			 * @return true if Engine should apply gravity on this object.
+			virtual void SetSubscription(EventAction_Move function) = 0;
-			 ********************************************************/
-			virtual bool IsAffectedByGravity() const = 0;
 
-			/********************************************************
+			virtual void SetLinearVelocity(::Oyster::Math::Float3 velocity) = 0;
-			 * param shape: Any defined sample shape.
+			virtual void SetPosition(::Oyster::Math::Float3 position) = 0;
-			 * @return true if this truly intersects with shape.
+			virtual void SetRotation(::Oyster::Math::Float4 quaternion) = 0;
-			 ********************************************************/
+			virtual void SetRotation(::Oyster::Math::Quaternion quaternion) = 0;
-			virtual bool Intersects( const ::Oyster::Collision3D::ICollideable &shape ) const = 0;
+			virtual void SetRotation(::Oyster::Math::Float3 eulerAngles) = 0;
 
-			/********************************************************
+			::Oyster::Math::Float4x4 GetRotation() const;
-			 * Performs a detailed Intersect test and returns if, when and where.
+			::Oyster::Math::Float4x4 GetOrientation() const;
-			 * @param shape: Any defined sample shape.
+			::Oyster::Math::Float4x4 GetView() const;
-			 * @param worldPointOfContact: Where at timeOfContact, this and object touches eachother.
+			::Oyster::Math::Float4x4 GetView( const ::Oyster::Math::Float3 &offset ) const;
-			 * @return true if this truly intersects with object.
-			 ********************************************************/
-			virtual bool Intersects( const ::Oyster::Collision3D::ICollideable &shape, ::Oyster::Math::Float4 &worldPointOfContact ) const = 0;
-
-			/********************************************************
-			 * Performs a detailed Intersect test and returns if, when and where.
-			 * @param object: What this is intersect testing against.
-			 * @param worldPointOfContact: Where at timeOfContact, this and object touches eachother.
-			 * @return true if this truly intersects with object.
-			 ********************************************************/
-			virtual bool Intersects( const ICustomBody &object, ::Oyster::Math::Float4 &worldPointOfContact ) const = 0;
-
-			/********************************************************
-			 * Sets how far back it needs to be interpolated to not be overlapping worldPointOfContact.
-			 ********************************************************/
-			virtual void SetTimeOfContact( ::Oyster::Math::Float4 &worldPointOfContact ) = 0;
-
-			/********************************************************
-			 * Required by Engine's Collision Search.
-			 * @param targetMem: Provided memory that written into and then returned.
-			 * @return a sphere shape that contains the ICustomBody.
-			 ********************************************************/
-			virtual ::Oyster::Collision3D::Sphere & GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const = 0;
-			
-			/********************************************************
-			 * Required by Engine's Collision Responsing.
-			 * @param worldPos: Should be worldPointOfContact from Intersects( ... )
-			 * @param targetMem: Provided memory that written into and then returned.
-			 * @return a surface normal in worldSpace.
-			 ********************************************************/
-			virtual ::Oyster::Math::Float4 & GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const = 0;
-			
-			/********************************************************
-			 * The gravity normal will have same direction as the total gravity force pulling on this and have the magnitude of 1.0f.
-			 * @param targetMem: Provided memory that written into and then returned.
-			 * @return a normalized vector in worldSpace. Exception: Null vector if no gravity been applied.
-			 ********************************************************/
-			virtual ::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const = 0;
 
 			/********************************************************
 			 * @return the void pointer set by SetCustomTag.
 			 * nullptr if none is set.
 			 ********************************************************/
-			virtual void * GetCustomTag() const = 0;
+			virtual void* GetCustomTag() const = 0;
-
-			///********************************************************
-			// * The world position of this center of gravity.
-			// * @param targetMem: Provided memory that written into and then returned.
-			// * @return a position in worldSpace.
-			// ********************************************************/
-			//virtual ::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const = 0;
-			//
-			///********************************************************
-			// * @param targetMem: Provided memory that written into and then returned.
-			// * @return a copy of this's rotation matrix.
-			// ********************************************************/
-			//virtual ::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0;
-			//
-			///********************************************************
-			// * @param targetMem: Provided memory that written into and then returned.
-			// * @return a copy of this's orientation matrix.
-			// ********************************************************/
-			//virtual ::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0;
-			//
-			///********************************************************
-			// * @param targetMem: Provided memory that written into and then returned.
-			// * @return a copy of this's view matrix.
-			// ********************************************************/
-			//virtual ::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0;
-
-			/********************************************************
-			 * To not be called if is in Engine
-			 * Is called during API::Update
-			 ********************************************************/
-			virtual UpdateState Update( ::Oyster::Math::Float timeStepLength ) = 0;
-
-			/********************************************************
-			 * @todo TODO: add doc
-			 ********************************************************/
-			virtual void Predict( ::Oyster::Math::Float4 &outDeltaPos, ::Oyster::Math::Float4 &outDeltaAxis, const ::Oyster::Math::Float4 &actingLinearImpulse, const ::Oyster::Math::Float4 &actingAngularImpulse, ::Oyster::Math::Float deltaTime ) = 0;
-			
-			/********************************************************
-			 * Sets which scene this ICustomBody is within.
-			 * Reserved to only be used by the scene.
-			 * @todo TODO: create an IScene interface
-			 ********************************************************/
-			virtual void SetScene( void *scene ) = 0;
-
-			/********************************************************
-			 * Sets the function that will be called by the engine
-			 * whenever a collision occurs.
-			 * @param functionPointer: If NULL, an empty default function will be set.
-			 ********************************************************/
-			virtual void SetSubscription( EventAction_BeforeCollisionResponse functionPointer ) = 0;
-
-			/********************************************************
-			 * Sets the function that will be called by the engine
-			 * whenever a collision has finished.
-			 * @param functionPointer: If NULL, an empty default function will be set.
-			 ********************************************************/
-			virtual void SetSubscription( EventAction_AfterCollisionResponse functionPointer ) = 0;
-
-			/********************************************************
-			 * Sets the function that will be called by the engine
-			 * whenever an object have moved.
-			 * @param functionPointer: If NULL, an empty default function will be set.
-			 ********************************************************/
-			virtual void SetSubscription( EventAction_Move functionPointer ) = 0;
-
-			/********************************************************
-			 * @param ignore: True if Engine should not apply Gravity.
-			 ********************************************************/
-			virtual void SetGravity( bool ignore) = 0;
-
-			/********************************************************
-			 * Used by Engine
-			 * @param normalizedVector: Should have same direction as the pullinggravity.
-			 ********************************************************/
-			virtual void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector ) = 0;
 
 			/********************************************************
 			 * Not used by the engine itself. Just a quality of life feature
@@ -437,60 +153,6 @@ namespace Oyster
 			 * @param ref: Anything castable to a void pointer, the engine won't care.
 			 ********************************************************/
 			virtual void SetCustomTag( void *ref ) = 0;
-
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetMomentOfInertiaTensor_KeepVelocity(...) instead
-			// ********************************************************/
-			//virtual void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI ) = 0;
-			//
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetMomentOfInertiaTensor_KeepMomentum(...)
-			// ********************************************************/
-			//virtual void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI ) = 0;
-			//
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetMass_KeepVelocity(...)
-			// ********************************************************/
-			//virtual void SetMass_KeepVelocity( ::Oyster::Math::Float m ) = 0;
-			//
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetMass_KeepMomentum(...)
-			// ********************************************************/
-			//virtual void SetMass_KeepMomentum( ::Oyster::Math::Float m ) = 0;
-			//
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetCenter(...)
-			// ********************************************************/
-			//virtual void SetCenter( const ::Oyster::Math::Float3 &worldPos ) = 0;
-			//
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetRotation(...)
-			// ********************************************************/
-			//virtual void SetRotation( const ::Oyster::Math::Float4x4 &rotation ) = 0;
-			//
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetOrientation(...)
-			// ********************************************************/
-			//virtual void SetOrientation( const ::Oyster::Math::Float4x4 &orientation ) = 0;
-
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::SetSize(...)
-			// ********************************************************/
-			//virtual void SetSize( const ::Oyster::Math::Float3 &size ) = 0;
-
-			///********************************************************
-			// * To not be called if is in Engine
-			// * Use API::?? @todo TODO: 
-			// ********************************************************/
-			//virtual void SetMomentum( const ::Oyster::Math::Float3 &worldG ) = 0;
 		};
 	}
 }

Code/GamePhysics/PhysicsStructs-Impl.h

@@ -10,53 +10,14 @@ namespace Oyster
 	{
 		namespace Struct
 		{
-			inline SimpleBodyDescription::SimpleBodyDescription()
+			inline CustomBodyState::CustomBodyState( ::Oyster::Math::Float mass, ::Oyster::Math::Float restitutionCoeff, ::Oyster::Math::Float staticFrictionCoeff, ::Oyster::Math::Float dynamicFrictionCoeff, const ::Oyster::Math::Float3 &centerPos, const ::Oyster::Math::Quaternion& quaternion)
-			{
-				this->rotation = ::Oyster::Math::Float3::null;
-				this->centerPosition = ::Oyster::Math::Float3::null;
-				this->size = ::Oyster::Math::Float3( 1.0f );
-				this->mass = 6.0f;
-				this->restitutionCoeff = 1.0f;
-				this->frictionCoeff_Dynamic = 0.5f;
-				this->frictionCoeff_Static = 0.5f;
-				this->inertiaTensor = ::Oyster::Physics3D::MomentOfInertia();
-				this->subscription_onCollision = NULL;
-				this->subscription_onCollisionResponse = NULL;
-				this->subscription_onMovement = NULL;
-				this->ignoreGravity = false;
-			}
-
-			inline SphericalBodyDescription::SphericalBodyDescription()
-			{
-				this->rotation = ::Oyster::Math::Float3::null;
-				this->centerPosition = ::Oyster::Math::Float3::null;
-				this->radius = 0.5f;
-				this->mass = 10.0f;
-				this->restitutionCoeff = 1.0f;
-				this->frictionCoeff_Dynamic = 0.5f;
-				this->frictionCoeff_Static = 0.5f;
-				this->subscription_onCollision = NULL;
-				this->subscription_onCollisionResponse = NULL;
-				this->subscription_onMovement = NULL;
-				this->ignoreGravity = false;
-			}
-
-			inline CustomBodyState::CustomBodyState( ::Oyster::Math::Float mass, ::Oyster::Math::Float restitutionCoeff, ::Oyster::Math::Float staticFrictionCoeff, ::Oyster::Math::Float kineticFrictionCoeff, const ::Oyster::Physics3D::MomentOfInertia &inertiaTensor, const ::Oyster::Math::Float3 &reach, const ::Oyster::Math::Float3 &centerPos, const ::Oyster::Math::Float3 &rotation, const ::Oyster::Math::Float3 &linearMomentum, const ::Oyster::Math::Float3 &angularMomentum, const ::Oyster::Math::Float3 &gravityNormal )
 			{
 				this->mass = mass;
 				this->restitutionCoeff = restitutionCoeff;
 				this->staticFrictionCoeff = staticFrictionCoeff;
-				this->kineticFrictionCoeff = kineticFrictionCoeff;
+				this->dynamicFrictionCoeff = dynamicFrictionCoeff;
-				this->inertiaTensor = inertiaTensor;
-				this->reach = reach;
 				this->centerPos = centerPos;
-				this->angularAxis = rotation;
+				this->quaternion = quaternion;
-				this->linearMomentum = linearMomentum;
-				this->angularMomentum = angularMomentum;
-				this->linearImpulse = this->angularImpulse = ::Oyster::Math::Float3::null;
-				this->deltaPos = this->deltaAxis = ::Oyster::Math::Float3::null;
-				this->isSpatiallyAltered = this->isDisturbed = this->isForwarded = false;
-				this->gravityNormal = gravityNormal;
 			}
 
 			inline CustomBodyState & CustomBodyState::operator = ( const CustomBodyState &state )
@@ -64,483 +25,34 @@ namespace Oyster
 				this->mass = state.mass;
 				this->restitutionCoeff = state.restitutionCoeff;
 				this->staticFrictionCoeff = state.staticFrictionCoeff;
-				this->kineticFrictionCoeff = state.kineticFrictionCoeff;
+				this->dynamicFrictionCoeff = state.dynamicFrictionCoeff;
-				this->inertiaTensor = state.inertiaTensor;
-				this->reach = state.reach;
 				this->centerPos = state.centerPos;
-				this->angularAxis = state.angularAxis;
+				this->quaternion = state.quaternion;
-				this->linearMomentum = state.linearMomentum;
+
-				this->angularMomentum = state.angularMomentum;
-				this->linearImpulse = state.linearImpulse;
-				this->angularImpulse = state.angularImpulse;
-				this->deltaPos = state.deltaPos;
-				this->deltaAxis = state.deltaAxis;
-				this->isSpatiallyAltered = state.isSpatiallyAltered;
-				this->isDisturbed = state.isDisturbed;
-				this->isForwarded = state.isForwarded;
-				this->gravityNormal = state.gravityNormal;
 				return *this;
 			}
 
-			inline const ::Oyster::Math::Float CustomBodyState::GetMass() const
-			{
-				return this->mass;
-			}
-
-			inline const ::Oyster::Math::Float CustomBodyState::GetRestitutionCoeff() const
-			{
-				return this->restitutionCoeff;
-			}
-
-			inline const ::Oyster::Math::Float CustomBodyState::GetFrictionCoeff_Static() const
-			{
-				return this->staticFrictionCoeff;
-			}
-
-			inline const ::Oyster::Math::Float CustomBodyState::GetFrictionCoeff_Kinetic() const
-			{
-				return this->kineticFrictionCoeff;
-			}
-
-			inline const ::Oyster::Physics3D::MomentOfInertia & CustomBodyState::GetMomentOfInertia() const
-			{
-				return this->inertiaTensor;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetReach() const
-			{
-				return this->reach;
-			}
-
-			inline ::Oyster::Math::Float3 CustomBodyState::GetSize() const
-			{
-				return 2.0f * this->GetReach();
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetCenterPosition() const
-			{
-				return this->centerPos;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetAngularAxis() const
-			{
-				return this->angularAxis;
-			}
 
 			inline ::Oyster::Math::Float4x4 CustomBodyState::GetRotation() const
 			{
-				return ::Oyster::Math3D::RotationMatrix( this->GetAngularAxis() );
+				return ::Oyster::Math3D::RotationMatrix( this->quaternion );
 			}
 
 			inline ::Oyster::Math::Float4x4 CustomBodyState::GetOrientation() const
 			{
-				return ::Oyster::Math3D::OrientationMatrix( this->angularAxis, this->centerPos );
+				return ::Oyster::Math3D::OrientationMatrix( this->quaternion, this->centerPos );
-			}
-
-			inline ::Oyster::Math::Float4x4 CustomBodyState::GetOrientation( const ::Oyster::Math::Float3 &offset ) const
-			{
-				return ::Oyster::Math3D::OrientationMatrix( this->angularAxis, (this->centerPos + offset) );
 			}
 
 			inline ::Oyster::Math::Float4x4 CustomBodyState::GetView() const
 			{
-				return ::Oyster::Math3D::ViewMatrix( this->angularAxis, this->centerPos );
+				return ::Oyster::Math3D::ViewMatrix( this->quaternion, this->centerPos );
 			}
 
 			inline ::Oyster::Math::Float4x4 CustomBodyState::GetView( const ::Oyster::Math::Float3 &offset ) const
 			{
-				return ::Oyster::Math3D::ViewMatrix( this->angularAxis, (this->centerPos + offset) );
+				return ::Oyster::Math3D::ViewMatrix( this->quaternion, (this->centerPos + offset) );
 			}
 
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetLinearMomentum() const
-			{
-				return this->linearMomentum;
-			}
-
-			inline ::Oyster::Math::Float3 CustomBodyState::GetLinearMomentum( const ::Oyster::Math::Float3 &at ) const
-			{
-				::Oyster::Math::Float3 offset = at - this->centerPos;
-				if( offset.Dot(offset) > 0.0f )
-				{
-					return this->linearMomentum + ::Oyster::Physics3D::Formula::TangentialLinearMomentum( this->angularMomentum, offset );
-				}
-				return this->linearMomentum;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetAngularMomentum() const
-			{
-				return this->angularMomentum;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetLinearImpulse() const
-			{
-				return this->linearImpulse;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetAngularImpulse() const
-			{
-				return this->angularImpulse;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetForward_DeltaPos() const
-			{
-				return this->deltaPos;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetForward_DeltaAxis() const
-			{
-				return this->deltaAxis;
-			}
-
-			inline const ::Oyster::Math::Float3 & CustomBodyState::GetGravityNormal() const
-			{
-				return this->gravityNormal;
-			}
-
-			inline void CustomBodyState::SetMass_KeepMomentum( ::Oyster::Math::Float m )
-			{
-				this->mass = m;
-			}
-
-			inline void CustomBodyState::SetMass_KeepVelocity( ::Oyster::Math::Float m )
-			{
-				if( m != 0.0f )
-				{ // sanity block!
-					this->linearMomentum *= (m / this->mass);
-					this->mass = m;
-				}
-			}
-
-			inline void CustomBodyState::SetRestitutionCoeff( ::Oyster::Math::Float e )
-			{
-				this->restitutionCoeff = e;
-			}
-
-			inline void CustomBodyState::SetFrictionCoeff( ::Oyster::Math::Float staticU, ::Oyster::Math::Float kineticU )
-			{
-				this->staticFrictionCoeff = staticU;
-				this->kineticFrictionCoeff = kineticU;
-			}
-
-			inline void CustomBodyState::SetMomentOfInertia_KeepMomentum( const ::Oyster::Physics3D::MomentOfInertia &tensor )
-			{
-				this->inertiaTensor = tensor;
-			}
-
-			inline void CustomBodyState::SetMomentOfInertia_KeepVelocity( const ::Oyster::Physics3D::MomentOfInertia &tensor )
-			{
-				::Oyster::Math::Quaternion rotation = ::Oyster::Math3D::Rotation(this->angularAxis);
-				::Oyster::Math::Float3 w = this->inertiaTensor.CalculateAngularVelocity( rotation, this->angularMomentum );
-				this->inertiaTensor = tensor;
-				this->angularMomentum = this->inertiaTensor.CalculateAngularMomentum( rotation, w );
-			}
-		
-			inline void CustomBodyState::SetSize( const ::Oyster::Math::Float3 &size )
-			{
-				this->SetReach( 0.5f * size );
-			}
-
-			inline void CustomBodyState::SetReach( const ::Oyster::Math::Float3 &halfSize )
-			{
-				this->reach = halfSize;
-				this->reach = ::Utility::Value::Max( this->reach, ::Oyster::Math::Float3::null );
-				this->isSpatiallyAltered = this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetCenterPosition( const ::Oyster::Math::Float3 &centerPos )
-			{
-				this->centerPos = centerPos;
-				this->isSpatiallyAltered = this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float3 &angularAxis )
-			{
-				this->angularAxis = angularAxis;
-				this->isSpatiallyAltered = this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetOrientation( const ::Oyster::Math::Float3 &angularAxis, const ::Oyster::Math::Float3 &translation )
-			{
-				this->angularAxis = angularAxis ;
-				this->centerPos = translation;
-				this->isSpatiallyAltered = this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetLinearMomentum( const ::Oyster::Math::Float3 &g )
-			{
-				this->linearMomentum = g;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetAngularMomentum( const ::Oyster::Math::Float3 &h )
-			{
-				this->angularMomentum = h;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetLinearImpulse( const ::Oyster::Math::Float3 &j )
-			{
-				this->linearImpulse = j;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetAngularImpulse( const ::Oyster::Math::Float3 &j )
-			{
-				this->angularImpulse = j;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::SetGravityNormal( const ::Oyster::Math::Float3 &gravityNormal )
-			{
-				this->gravityNormal = gravityNormal;
-			}
-
-			inline void CustomBodyState::AddRotation( const ::Oyster::Math::Float3 &angularAxis )
-			{
-				this->angularAxis += angularAxis;
-				this->isSpatiallyAltered = this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::AddTranslation( const ::Oyster::Math::Float3 &deltaPos )
-			{
-				this->centerPos += deltaPos;
-				this->isSpatiallyAltered = this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::ApplyLinearImpulse( const ::Oyster::Math::Float3 &j )
-			{
-				this->linearImpulse += j;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::ApplyAngularImpulse( const ::Oyster::Math::Float3 &j )
-			{
-				this->angularImpulse += j;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::ApplyImpulse( const ::Oyster::Math::Float3 &j, const ::Oyster::Math::Float3 &at, const ::Oyster::Math::Float3 &normal )
-			{
-				::Oyster::Math::Float3 offset = at - this->centerPos;
-				if( offset.Dot(offset) > 0.0f )
-				{
-					::Oyster::Math::Float3 deltaAngularImpulse = ::Oyster::Physics3D::Formula::AngularMomentum( j, offset );
-
-					this->linearImpulse -= ::Oyster::Physics3D::Formula::TangentialLinearMomentum( deltaAngularImpulse, offset );
-					this->angularImpulse += deltaAngularImpulse;
-				}
-				this->linearImpulse += j;
-				this->isDisturbed = true;
-			}
-
-			inline void CustomBodyState::ApplyForwarding( const ::Oyster::Math::Float3 &deltaPos, const ::Oyster::Math::Float3 &deltaAxis )
-			{
-				this->deltaPos += deltaPos;
-				this->deltaAxis += deltaAxis;
-				this->isDisturbed = this->isForwarded = true;
-			}
-
-			inline bool CustomBodyState::IsSpatiallyAltered() const
-			{
-				return this->isSpatiallyAltered;
-			}
-
-			inline bool CustomBodyState::IsDisturbed() const
-			{
-				return this->isDisturbed;
-			}
-
-			inline bool CustomBodyState::IsForwarded() const
-			{
-				return this->isForwarded;
-			}
-
-			inline GravityWell::GravityWell( )
-			{
-				this->position	= ::Oyster::Math::Float3::null;
-				this->mass		= 0.0f;
-			}
-			
-			inline GravityWell::GravityWell( const GravityWell &gravityWell )
-			{
-				this->position	= gravityWell.position;
-				this->mass		= gravityWell.mass;
-			}
-
-			inline GravityWell & GravityWell::operator = ( const GravityWell &gravityWell )
-			{
-				this->position	= gravityWell.position;
-				this->mass		= gravityWell.mass;
-
-				return *this;
-			}
-
-			inline bool GravityWell::operator == ( const GravityWell &gravity ) const
-			{
-				if( this->position == gravity.position )
-				if( this->mass == gravity.mass )
-				{
-					return true;
-				}
-				return false;
-			}
-
-			inline bool GravityWell::operator != ( const GravityWell &gravity ) const
-			{
-				if( this->position == gravity.position )
-				if( this->mass == gravity.mass )
-				{
-					return false;
-				}
-				return true;
-			}
-
-			inline GravityDirected::GravityDirected( )
-			{
-				this->impulse = ::Oyster::Math::Float3::null;
-			}
-
-			inline GravityDirected::GravityDirected( const GravityDirected &gravityDirected )
-			{
-				this->impulse = gravityDirected.impulse;
-			}
-
-			inline GravityDirected & GravityDirected::operator = ( const GravityDirected &gravityDirected )
-			{
-				this->impulse = gravityDirected.impulse;
-
-				return *this;
-			}
-
-			inline bool GravityDirected::operator == ( const GravityDirected &gravity ) const
-			{
-				return this->impulse == gravity.impulse;
-			}
-
-			inline bool GravityDirected::operator != ( const GravityDirected &gravity ) const
-			{
-				return this->impulse != gravity.impulse;
-			}
-
-			inline GravityDirectedField::GravityDirectedField( )
-			{
-				this->normalizedDirection	= ::Oyster::Math::Float3::null;
-				this->mass					= 0.0f;
-				this->magnitude				= 0.0f;
-			}
-
-			inline GravityDirectedField::GravityDirectedField( const GravityDirectedField &gravityDirectedField )
-			{
-				this->normalizedDirection	= gravityDirectedField.normalizedDirection;
-				this->mass					= gravityDirectedField.mass;
-				this->magnitude				= gravityDirectedField.magnitude;
-			}
-
-			inline GravityDirectedField & GravityDirectedField::operator = ( const GravityDirectedField &gravityDirectedField )
-			{
-				this->normalizedDirection	= gravityDirectedField.normalizedDirection;
-				this->mass					= gravityDirectedField.mass;
-				this->magnitude				= gravityDirectedField.magnitude;
-
-				return *this;
-			}
-
-			inline bool GravityDirectedField::operator == ( const GravityDirectedField &gravity ) const
-			{
-				if( this->normalizedDirection == gravity.normalizedDirection )
-				if( this->mass == gravity.mass )
-				if( this->magnitude == gravity.magnitude )
-				{
-					return true;
-				}
-				return false;
-			}
-
-			inline bool GravityDirectedField::operator != ( const GravityDirectedField &gravity ) const
-			{
-				if( this->normalizedDirection == gravity.normalizedDirection )
-				if( this->mass == gravity.mass )
-				if( this->magnitude == gravity.magnitude )
-				{
-					return false;
-				}
-				return true;
-			}
-
-			inline Gravity::Gravity()
-			{
-				this->gravityType = GravityType_Undefined;
-			}
-
-			inline Gravity::Gravity( const Gravity &gravity )
-			{
-				this->gravityType = gravity.gravityType;
-
-				switch( gravity.gravityType )
-				{
-				case GravityType_Well:
-					this->well = gravity.well;
-					break;
-				case GravityType_Directed:
-					this->directed = gravity.directed;
-					break;
-				case GravityType_DirectedField:
-					this->directedField = gravity.directedField;
-					break;
-				default: break;
-				}
-			}
-		
-			inline Gravity & Gravity::operator = ( const Gravity &gravity )
-			{
-				this->gravityType = gravity.gravityType;
-
-				switch( gravity.gravityType )
-				{
-				case GravityType_Well:
-					this->well = gravity.well;
-					break;
-				case GravityType_Directed:
-					this->directed = gravity.directed;
-					break;
-				case GravityType_DirectedField:
-					this->directedField = gravity.directedField;
-					break;
-				default: break;
-				}
-
-				return *this;
-			}
-
-			inline bool Gravity::operator == ( const Gravity &gravity ) const
-			{
-				if( this->gravityType == gravity.gravityType )
-				{
-					switch( this->gravityType )
-					{
-					case GravityType_Well:			return this->well == gravity.well;
-					case GravityType_Directed:		return this->directed == gravity.directed;
-					case GravityType_DirectedField:	return this->directedField == gravity.directedField;
-					default: return true;
-					}
-				}
-				return false;
-			}
-
-			inline bool Gravity::operator != ( const Gravity &gravity ) const
-			{
-				if( this->gravityType == gravity.gravityType )
-				{
-					switch( this->gravityType )
-					{
-					case GravityType_Well:			return this->well != gravity.well;
-					case GravityType_Directed:		return this->directed != gravity.directed;
-					case GravityType_DirectedField:	return this->directedField != gravity.directedField;
-					default: return false;
-					}
-				}
-				return true;
-			}
 		}
 	} 
 }

Code/GamePhysics/PhysicsStructs.h

@@ -5,211 +5,40 @@
 #include "PhysicsAPI.h"
 #include "Inertia.h"
 
-namespace Oyster { namespace Physics
+namespace Oyster 
-{
+{ 
-	namespace Struct
+	namespace Physics
 	{
-		struct SimpleBodyDescription
+		namespace Struct
 		{
-			::Oyster::Math::Float3 rotation;
+			struct CustomBodyState
-			::Oyster::Math::Float3 centerPosition;
+			{
-			::Oyster::Math::Float3 size;
+			public:
-			::Oyster::Math::Float mass;
+				// Default constructor
-			::Oyster::Math::Float restitutionCoeff;
+				CustomBodyState( ::Oyster::Math::Float mass						= 1.0f,
-			::Oyster::Math::Float frictionCoeff_Static;
+								 ::Oyster::Math::Float restitutionCoeff			= 0.5f,
-			::Oyster::Math::Float frictionCoeff_Dynamic;
+								 ::Oyster::Math::Float staticFrictionCoeff		= 1.0f,
-			::Oyster::Physics3D::MomentOfInertia inertiaTensor;
+								 ::Oyster::Math::Float dynamicFrictionCoeff		= 1.0f,
-			::Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse subscription_onCollision;
+								 const ::Oyster::Math::Float3 &centerPos		= ::Oyster::Math::Float3::null,
-			::Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse subscription_onCollisionResponse;
+								 const ::Oyster::Math::Quaternion &quaternion	= ::Oyster::Math::Quaternion(::Oyster::Math::Float3(0, 0, 0), 1));
-			::Oyster::Physics::ICustomBody::EventAction_Move subscription_onMovement;
-			bool ignoreGravity;
 
-			SimpleBodyDescription();
+				// Assignment operator
-		};
+				CustomBodyState & operator = ( const CustomBodyState &state );
 
-		struct SphericalBodyDescription
+				// Get functions that calculate matrices that do not exist as variables
-		{
+				::Oyster::Math::Float4x4	 GetRotation() const;
-			::Oyster::Math::Float3 rotation;
+				::Oyster::Math::Float4x4	 GetOrientation() const;
-			::Oyster::Math::Float3 centerPosition;
+				::Oyster::Math::Float4x4	 GetView() const;
-			::Oyster::Math::Float radius;
+				::Oyster::Math::Float4x4	 GetView( const ::Oyster::Math::Float3 &offset ) const;
-			::Oyster::Math::Float mass;
-			::Oyster::Math::Float restitutionCoeff;
-			::Oyster::Math::Float frictionCoeff_Static;
-			::Oyster::Math::Float frictionCoeff_Dynamic;
-			::Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse subscription_onCollision;
-			::Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse subscription_onCollisionResponse;
-			::Oyster::Physics::ICustomBody::EventAction_Move subscription_onMovement;
-			bool ignoreGravity;
-
-			SphericalBodyDescription();
-		};
-
-		struct CustomBodyState
-		{
-		public:
-			CustomBodyState( ::Oyster::Math::Float mass						= 1.0f,
-							 ::Oyster::Math::Float restitutionCoeff			= 1.0f,
-							 ::Oyster::Math::Float staticFrictionCoeff		= 1.0f,
-							 ::Oyster::Math::Float kineticFrictionCoeff		= 1.0f,
-							 const ::Oyster::Physics3D::MomentOfInertia &inertiaTensor = ::Oyster::Physics3D::MomentOfInertia(),
-							 const ::Oyster::Math::Float3 &reach			= ::Oyster::Math::Float3::null,
-							 const ::Oyster::Math::Float3 &centerPos		= ::Oyster::Math::Float3::null,
-							 const ::Oyster::Math::Float3 &rotation			= ::Oyster::Math::Float3::null,
-							 const ::Oyster::Math::Float3 &linearMomentum	= ::Oyster::Math::Float3::null,
-							 const ::Oyster::Math::Float3 &angularMomentum	= ::Oyster::Math::Float3::null, 
-							 const ::Oyster::Math::Float3 &gravityNormal	= ::Oyster::Math::Float3::null);
-
-			CustomBodyState & operator = ( const CustomBodyState &state );
-
-			const ::Oyster::Math::Float		 GetMass() const;
-			const ::Oyster::Math::Float		 GetRestitutionCoeff() const;
-			const ::Oyster::Math::Float		 GetFrictionCoeff_Static() const;
-			const ::Oyster::Math::Float		 GetFrictionCoeff_Kinetic() const;
-			const ::Oyster::Physics3D::MomentOfInertia & GetMomentOfInertia() const;
-			const ::Oyster::Math::Float3 &	 GetReach() const;
-				  ::Oyster::Math::Float3	 GetSize() const;
-			const ::Oyster::Math::Float3 &	 GetCenterPosition() const;
-			const ::Oyster::Math::Float3 &	 GetAngularAxis() const;
-				  ::Oyster::Math::Float4x4	 GetRotation() const;
-				  ::Oyster::Math::Float4x4	 GetOrientation() const;
-				  ::Oyster::Math::Float4x4	 GetOrientation( const ::Oyster::Math::Float3 &offset ) const;
-				  ::Oyster::Math::Float4x4	 GetView() const;
-				  ::Oyster::Math::Float4x4	 GetView( const ::Oyster::Math::Float3 &offset ) const;
-			const ::Oyster::Math::Float3 &	 GetLinearMomentum() const;
-				  ::Oyster::Math::Float3	 GetLinearMomentum( const ::Oyster::Math::Float3 &at ) const;
-			const ::Oyster::Math::Float3 &	 GetAngularMomentum() const;
-			const ::Oyster::Math::Float3 &	 GetLinearImpulse() const;
-			const ::Oyster::Math::Float3 &	 GetAngularImpulse() const;
-			const ::Oyster::Math::Float3 &	 GetForward_DeltaPos() const;
-			const ::Oyster::Math::Float3 &	 GetForward_DeltaAxis() const;
-			const ::Oyster::Math::Float3 &	 GetGravityNormal() const;
 			
-			void SetMass_KeepMomentum( ::Oyster::Math::Float m );
+				// Variables for state
-			void SetMass_KeepVelocity( ::Oyster::Math::Float m );
+				::Oyster::Math::Float mass, restitutionCoeff, staticFrictionCoeff, dynamicFrictionCoeff;
-			void SetRestitutionCoeff( ::Oyster::Math::Float e );
+				::Oyster::Math::Float3 reach, centerPos;
-			void SetFrictionCoeff( ::Oyster::Math::Float staticU, ::Oyster::Math::Float kineticU );
+				::Oyster::Math::Quaternion quaternion;
-			void SetMomentOfInertia_KeepMomentum( const ::Oyster::Physics3D::MomentOfInertia &tensor );
+			};	
-			void SetMomentOfInertia_KeepVelocity( const ::Oyster::Physics3D::MomentOfInertia &tensor );
+		}
-			void SetSize( const ::Oyster::Math::Float3 &size );
+	} 
-			void SetReach( const ::Oyster::Math::Float3 &halfSize );
+}
-			void SetCenterPosition( const ::Oyster::Math::Float3 &centerPos );
-			void SetRotation( const ::Oyster::Math::Float3 &angularAxis );
-			//void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
-			//void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
-			void SetOrientation( const ::Oyster::Math::Float3 &angularAxis, const ::Oyster::Math::Float3 &translation );
-			void SetLinearMomentum( const ::Oyster::Math::Float3 &g );
-			void SetAngularMomentum( const ::Oyster::Math::Float3 &h );
-			void SetLinearImpulse( const ::Oyster::Math::Float3 &j );
-			void SetAngularImpulse( const ::Oyster::Math::Float3 &j );
-			void SetGravityNormal( const ::Oyster::Math::Float3 &gravityNormal );
-
-			void AddRotation( const ::Oyster::Math::Float3 &angularAxis );
-			void AddTranslation( const ::Oyster::Math::Float3 &deltaPos );
-
-			void ApplyLinearImpulse( const ::Oyster::Math::Float3 &j );
-			void ApplyAngularImpulse( const ::Oyster::Math::Float3 &j );
-			void ApplyImpulse( const ::Oyster::Math::Float3 &j, const ::Oyster::Math::Float3 &at, const ::Oyster::Math::Float3 &normal );
-			void ApplyForwarding( const ::Oyster::Math::Float3 &deltaPos, const ::Oyster::Math::Float3 &deltaAxis );
-
-			bool IsSpatiallyAltered() const;
-			bool IsDisturbed() const;
-			bool IsForwarded() const;
-
-			::Oyster::Math::Float3 linearMomentum;
-
-		private:
-			::Oyster::Math::Float mass, restitutionCoeff, staticFrictionCoeff, kineticFrictionCoeff;
-			::Oyster::Physics3D::MomentOfInertia inertiaTensor;
-			::Oyster::Math::Float3 reach, centerPos, angularAxis;
-			::Oyster::Math::Float3 angularMomentum;
-			::Oyster::Math::Float3 linearImpulse, angularImpulse;
-			::Oyster::Math::Float3 deltaPos, deltaAxis; // Forwarding data sum
-			::Oyster::Math::Float3 gravityNormal;
-
-			bool isSpatiallyAltered, isDisturbed, isForwarded;
-		};
-
-		/**
-		###############################################################################
-		Can't define structs inside structs in a union therefor they are declared here.
-		###############################################################################
-		*/
-		struct GravityWell
-		{
-			::Oyster::Math::Float3 position;
-			::Oyster::Math::Float mass;
-
-			GravityWell( );
-			GravityWell( const GravityWell &gravityWell );
-			GravityWell & operator = ( const GravityWell &gravityWell );
-
-			bool operator == ( const GravityWell &gravity ) const;
-			bool operator != ( const GravityWell &gravity ) const;
-		};
-
-		struct GravityDirected
-		{
-			::Oyster::Math::Float3 impulse;
-
-			GravityDirected( );
-			GravityDirected( const GravityDirected &gravityDirected );
-			GravityDirected & operator = ( const GravityDirected &gravityDirected );
-
-			bool operator == ( const GravityDirected &gravity ) const;
-			bool operator != ( const GravityDirected &gravity ) const;
-		};
-
-		struct GravityDirectedField
-		{
-			::Oyster::Math::Float3 normalizedDirection;
-			::Oyster::Math::Float mass;
-			::Oyster::Math::Float magnitude;
-
-			GravityDirectedField( );
-			GravityDirectedField( const GravityDirectedField &gravityDirectedField );
-			GravityDirectedField & operator = ( const GravityDirectedField &gravityDirectedField );
-
-			bool operator == ( const GravityDirectedField &gravity ) const;
-			bool operator != ( const GravityDirectedField &gravity ) const;
-		};
-
-		struct Gravity
-		{
-			enum GravityType
-			{
-				GravityType_Undefined		= -1,
-				GravityType_Well			= 0,
-				GravityType_Directed		= 1,
-				GravityType_DirectedField	= 2,
-			} gravityType;
-
-			union
-			{
-				struct
-				{
-					GravityWell well;
-				};
-
-				struct
-				{
-					GravityDirected directed;
-				};
-
-				struct
-				{
-					GravityDirectedField directedField;
-				};
-			};
-
-			Gravity( );
-			Gravity( const Gravity &gravity );
-			Gravity & operator = ( const Gravity &gravity );
-
-			bool operator == ( const Gravity &gravity ) const;
-			bool operator != ( const Gravity &gravity ) const;
-		};
-	}
-} }
 
 
 #include "PhysicsStructs-Impl.h"

Code/Misc/DynamicArray.h

@@ -44,6 +44,11 @@ namespace Utility
 			unsigned int Size() const;
 			unsigned int Capacity() const;
 
+			bool IsEmpty() const;
+
+			T* begin();
+			T* end();
+
 		private:
 			void Expand(int elements = 0);
 
@@ -112,7 +117,7 @@ namespace Utility
 	
 			template <typename T> const T& DynamicArray<T>::operator[](unsigned int index) const
 			{
-				assert(index < this->size);
+				assert((int)index < this->size);
 		
 				return this->data[index];
 			}
@@ -165,7 +170,7 @@ namespace Utility
 	
 			template <typename T> void DynamicArray<T>::Remove(unsigned int index)
 			{
-				assert(index > this->size);
+				assert(index > (unsigned int) this->size);
 
 				T* temp = new T[this->capacity - 1];
 		
@@ -181,7 +186,8 @@ namespace Utility
 	
 			template <typename T> void DynamicArray<T>::Clear()
 			{
-				delete [] this->data;
+				if(this->data)
+					delete [] this->data;
 
 				this->data = 0;
 				this->size = 0;
@@ -227,6 +233,11 @@ namespace Utility
 				return (unsigned int)this->capacity;
 			}
 
+			template <typename T> bool DynamicArray<T>::IsEmpty() const
+			{
+				return (this->size == 0);
+			}
+
 			template <typename T> void DynamicArray<T>::Expand(int elements)
 			{
 				if(elements < 1) return;
@@ -248,6 +259,18 @@ namespace Utility
 				}
 			}
 
+			template <typename T> T* DynamicArray<T>::begin()
+			{
+				if(this->size == 0) return 0;
+				return &this->data[0];
+			}
+
+			template <typename T> T* DynamicArray<T>::end()
+			{
+				if(this->size == 0) return 0;
+				return ((&this->data[this->size - 1]) + 1);
+			}
+
 		#pragma endregion
 	}
 }

Code/Misc/Misc.vcxproj

@@ -152,8 +152,10 @@
     <ClCompile Include="Resource\OResourceHandler.cpp" />
     <ClCompile Include="Resource\OResource.cpp" />
     <ClCompile Include="Resource\ResourceManager.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="Thread\OysterMutex.cpp" />
     <ClCompile Include="Thread\OysterThread_Impl.cpp" />
@@ -172,8 +174,10 @@
     <ClInclude Include="Resource\OysterResource.h" />
     <ClInclude Include="Resource\OResource.h" />
     <ClInclude Include="Resource\ResourceManager.h">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
     </ClInclude>
     <ClInclude Include="ThreadSafeQueue.h" />
     <ClInclude Include="Thread\IThreadObject.h" />

Code/Misc/Resource/ResourceManager.cpp

@@ -108,7 +108,7 @@ void SaveResource( std::map<std::wstring, ResourceData*>& resources, ResourceDat
 }
 bool Release(std::map<std::wstring, ResourceData*>& resources, ResourceData* resource)
 {
-	if(resource->referenceCount.Decref() == 0)
+	if(resource->referenceCount.Decref() < 1)
 	{
 		const wchar_t* temp = FindResourceKey(resources, resource->resource);
 
@@ -123,7 +123,7 @@ bool Release(std::map<std::wstring, ResourceData*>& resources, ResourceData* res
 				resource->resource = 0;
 			break;
 
-			case Oyster::Resource::ResourceType_UNKNOWN:
+			case Oyster::Resource::ResourceType_CUSTOM:
 				resource->unloadFnc(resource->resource);
 				resource->resource = 0;
 			break;
@@ -137,6 +137,13 @@ bool Release(std::map<std::wstring, ResourceData*>& resources, ResourceData* res
 }
 ResourceData* Load(/*Out*/ResourceData* targetMem, /*in*/const wchar_t source[], /*in*/ResourceType type)
 {
+	targetMem->resource = 0;
+	targetMem->loadFnc = 0;
+	targetMem->unloadFnc = 0;
+	targetMem->resourceID = 0;
+	targetMem->resourcetype = type;
+	targetMem->resourceSize = 0;
+
 	std::string sOut;
 	bool success = false;
 
@@ -182,13 +189,20 @@ ResourceData* Load(/*Out*/ResourceData* targetMem, /*in*/const wchar_t source[],
 }
 ResourceData* Load(/*Out*/ResourceData* targetMem, /*in*/const wchar_t source[], LoadFunction loadFnc, UnloadFunction unloadFnc)
 {
+	targetMem->resource = 0;
+	targetMem->loadFnc = 0;
+	targetMem->unloadFnc = 0;
+	targetMem->resourceID = 0;
+	targetMem->resourcetype = ResourceType_CUSTOM;
+	targetMem->resourceSize = 0;
+
 	if(loadFnc)	
 	{
 		targetMem->resource = loadFnc(source);
 		if(targetMem->resource)
 		{
 			targetMem->resourceSize = 0;
-			targetMem->resourcetype = ResourceType_UNKNOWN;
+			targetMem->resourcetype = ResourceType_CUSTOM;
 			targetMem->loadFnc = loadFnc;
 			targetMem->unloadFnc = unloadFnc;
 		}
@@ -208,7 +222,7 @@ ResourceData* Reload(std::map<std::wstring, ResourceData*> resources, ResourceDa
 				return Load(resource, filename, resource->loadFnc, resource->unloadFnc); 
 		break;
 
-		case Oyster::Resource::ResourceType_UNKNOWN:
+		case Oyster::Resource::ResourceType_CUSTOM:
 		{
 			resource->unloadFnc(resource->resource);
 
@@ -270,7 +284,7 @@ HRESOURCE ResourceManager::LoadResource(const wchar_t filename[], LoadFunction l
 	{
 		return 0;
 	}
-	if(!loadFnc)	
+	if(!loadFnc || !unloadFnc)	
 	{
 		return 0;
 	}
@@ -278,6 +292,8 @@ HRESOURCE ResourceManager::LoadResource(const wchar_t filename[], LoadFunction l
 	ResourceData *t = FindResource(this->resources, filename);
 	if(t)	
 	{
+		t->loadFnc = loadFnc;
+		t->unloadFnc = unloadFnc;
 		if(force)
 		{
 			return ResourceManager::ReloadResource(filename);
@@ -292,7 +308,7 @@ HRESOURCE ResourceManager::LoadResource(const wchar_t filename[], LoadFunction l
 	else
 	{
 		t = Load(new ResourceData(), filename, loadFnc, unloadFnc );
-		if(t)
+		if(t && t->resource)
 		{
 			t->resourceID = (customId);
 			SaveResource(this->resources, t, filename, true);
@@ -300,6 +316,7 @@ HRESOURCE ResourceManager::LoadResource(const wchar_t filename[], LoadFunction l
 		else
 		{
 			delete t;
+			t = 0;
 		}
 	}
 	if(!t)
@@ -333,24 +350,20 @@ void ResourceManager::Clean()
 	for (i; i != last; i++)
 	{
 		//Remove all the references
-		while (!Release(this->resources, i->second));
+		while (!Release(resources, i->second));
 	}
 	resources.clear();
 }
 void ResourceManager::ReleaseResource(const HRESOURCE& resourceData)
 {
-	ResourceData *t = FindResource(this->resources, resourceData);
+	const wchar_t* temp = FindResourceKey(resources, resourceData);
-	if(t)
+	
+	if(temp)
 	{
+		ResourceData *t = FindResource(this->resources, resourceData);
 		if(Release(resources, t))
 		{
-			const wchar_t* temp = 0;
+			resources.erase(temp);
-			if((temp = FindResourceKey(resources, resourceData)))
-			{
-				std::wstring ws = std::wstring(temp);
-				delete resources[ws];
-				resources.erase(ws);
-			}
 		}
 	}
 }
@@ -361,7 +374,6 @@ void ResourceManager::ReleaseResource(const wchar_t filename[])
 	{
 		if(Release(resources, t))
 		{
-			delete resources[filename];
 			resources.erase(filename);
 		}
 	}

Code/Misc/Resource/ResourceManager.h

@@ -29,10 +29,8 @@ namespace Oyster
 			ResourceType_Byte_UNICODE,				/**< Handle can be interpeted as char[] or char* */
 			ResourceType_Byte_UTF16LE,				/**< Handle can be interpeted as char[] or char* */
 
-			ResourceType_COUNT,						/**< Handle can be interpeted as ? */
+			ResourceType_CUSTOM,					/**< Handle can be interpeted as whatever */
-
+			ResourceType_INVALID,					/**< Handle can be interpeted as whatever */
-			ResourceType_UNKNOWN = -1,				/**< Handle can be interpeted as void* */
-			ResourceType_INVALID = -2,				/**< Invalid or non existing resource */
 		};
 		
 		/** A resource handler interface to interact with when loading resources. 

Code/Misc/Thread/OysterThread_Impl.cpp

@@ -42,15 +42,10 @@ using namespace Utility::DynamicMemory;
 	};
 	struct ThreadData
 	{
-		OYSTER_THREAD_STATE	state;									//<! The current thread state.
+		OYSTER_THREAD_STATE	state;		//<! The current thread state.
-		OYSTER_THREAD_PRIORITY prio;								//<! The thread priority
+		OYSTER_THREAD_PRIORITY prio;	//<! The thread priority
-		//IThreadObject *owner;										//<! The worker object.
+		OwnerContainer ownerObj;		//
-		//Oyster::Callback::OysterCallback<bool, void> ownerObj;	//
+		int msec;						//<! A timer in miliseconds.
-		OwnerContainer ownerObj;									//
-		std::atomic<int> msec;										//<! A timer in miliseconds.
-
-		//std::timed_mutex threadFunctionLock;
-		std::mutex threadStopMutex;
 	};
 	
 	/** A typical Oyster thread function */
@@ -58,7 +53,6 @@ using namespace Utility::DynamicMemory;
 
 	struct RefData
 	{
-		std::mutex threadWaitFunctionLock;
 		bool isCreated;
 		bool isAlive;
 		ThreadData *threadData;
@@ -79,11 +73,30 @@ using namespace Utility::DynamicMemory;
 		{
 			if(!threadData) return OYSTER_THREAD_ERROR_SUCCESS;
 
-			this->threadData->state = OYSTER_THREAD_STATE_DEAD;
+			if(std::this_thread::get_id() != this->workerThread.get_id())
-			
-			if(this->workerThread.joinable())
 			{
-				this->workerThread.join();
+				//this->threadData->threadDataAcces.lock();
+				//{
+					this->threadData->state = OYSTER_THREAD_STATE_DEAD;
+			
+					if(this->workerThread.joinable())
+					{
+						this->workerThread.join();
+					}
+
+					this->isCreated = false;
+					delete this->threadData;
+					this->threadData = 0;
+				//} this->threadData->threadDataAcces.unlock();
+			}
+			else
+			{
+				this->threadData->state = OYSTER_THREAD_STATE_DEAD;
+				if(this->workerThread.joinable())
+				{
+					this->workerThread.join();
+				}
+
 				this->isCreated = false;
 				delete this->threadData;
 				this->threadData = 0;
@@ -102,12 +115,10 @@ using namespace Utility::DynamicMemory;
 				this->threadData->state = OYSTER_THREAD_STATE_IDLE;
 			threadData->ownerObj = worker;
 			threadData->prio = OYSTER_THREAD_PRIORITY_2;
+			threadData->msec = 0;
 
 			workerThread = std::thread(fnc, this->threadData);
 
-			//if(detach) 
-			//	this->workerThread.detach();
-
 			isCreated = true;
 
 			return OYSTER_THREAD_ERROR_SUCCESS;
@@ -145,6 +156,9 @@ using namespace Utility::DynamicMemory;
 	public:
 		static void CheckPriority(ThreadData* w)
 		{
+			
+				Oyster::Thread::OYSTER_THREAD_PRIORITY temp = w->prio;
+
 			switch (w->prio)
 			{
 				case Oyster::Thread::OYSTER_THREAD_PRIORITY_1:
@@ -190,16 +204,18 @@ using namespace Utility::DynamicMemory;
 
 			while (w->state == OYSTER_THREAD_STATE_NORMAL)		
 			{
-				CheckPriority(w);
+				//while (!w->threadDataAcces.try_lock());
-				if(!DoWork(w)) break;
+
-				CheckStatus(w);
+					CheckPriority(w);
+					if(!DoWork(w)) break;
+					CheckStatus(w);
+
+				//w->threadDataAcces.unlock();
 			}
 
 			if(w->ownerObj.value.obj)	w->ownerObj.value.obj->ThreadExit();
 
 			w->state = OYSTER_THREAD_STATE_DEAD;
-
-			//delete w;
 		}
 	};
 
@@ -247,79 +263,114 @@ OYSTER_THREAD_ERROR OysterThread::Create(ThreadFnc worker, bool start, bool deta
 
 OYSTER_THREAD_ERROR OysterThread::Start()
 {
-	if(!this->privateData->data->threadData->ownerObj)
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-		return OYSTER_THREAD_ERROR_ThreadHasNoWorker;
+	//this->privateData->data->threadData->threadDataAcces.lock();{
 
-	if(this->privateData->data->threadData->state == OYSTER_THREAD_STATE_DEAD)
+		if(!this->privateData->data->threadData->ownerObj)
-		return OYSTER_THREAD_ERROR_ThreadIsDead;
+			val = OYSTER_THREAD_ERROR_ThreadHasNoWorker;
 
-	this->privateData->data->threadData->state = OYSTER_THREAD_STATE_NORMAL;
+		if(this->privateData->data->threadData->state == OYSTER_THREAD_STATE_DEAD)
+			val = OYSTER_THREAD_ERROR_ThreadIsDead;
 
-	return OYSTER_THREAD_ERROR_SUCCESS;
+		this->privateData->data->threadData->state = OYSTER_THREAD_STATE_NORMAL;
+
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+
+	return val;
 }
 OYSTER_THREAD_ERROR OysterThread::Stop()
 {
-	this->privateData->data->threadData->state = OYSTER_THREAD_STATE_IDLE;
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-	return OYSTER_THREAD_ERROR_SUCCESS;
+	//this->privateData->data->threadData->threadDataAcces.lock(); {
+		this->privateData->data->threadData->state = OYSTER_THREAD_STATE_IDLE;
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+
+	return val;
 }
 OYSTER_THREAD_ERROR OysterThread::Stop(int msec)
 {
-	this->privateData->data->threadData->msec = msec;
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-	return OYSTER_THREAD_ERROR_SUCCESS;
+	//this->privateData->data->threadData->threadDataAcces.lock(); {
+		this->privateData->data->threadData->msec = msec;
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+	return val;
 }
 OYSTER_THREAD_ERROR OysterThread::Resume()
 {
-	if(this->privateData->data->threadData->state == OYSTER_THREAD_STATE_DEAD)
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-		return OYSTER_THREAD_ERROR_ThreadIsDead;
+	//this->privateData->data->threadData->threadDataAcces.lock(); {
+		if(this->privateData->data->threadData->state == OYSTER_THREAD_STATE_DEAD)
+			val = OYSTER_THREAD_ERROR_ThreadIsDead;
 
-	this->privateData->data->threadData->state = OYSTER_THREAD_STATE_NORMAL;
+		this->privateData->data->threadData->state = OYSTER_THREAD_STATE_NORMAL;
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
 
-	return OYSTER_THREAD_ERROR_SUCCESS;
+	return val;
 }
 OYSTER_THREAD_ERROR OysterThread::SetWorker(IThreadObject* worker)
 {
-	this->privateData->data->threadData->ownerObj.value = worker; 
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-	this->privateData->data->threadData->ownerObj.type = Oyster::Callback::CallbackType_Object;
+	//this->privateData->data->threadData->threadDataAcces.lock();{
 
-	this->privateData->data->threadData->msec = 0;
+		this->privateData->data->threadData->ownerObj.value = worker; 
+		this->privateData->data->threadData->ownerObj.type = Oyster::Callback::CallbackType_Object;
 
-	return OYSTER_THREAD_ERROR_SUCCESS;;
+		this->privateData->data->threadData->msec = 0;
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+
+	return val;;
 }
 OYSTER_THREAD_ERROR OysterThread::SetWorker(ThreadFnc worker)
 {
-	this->privateData->data->threadData->ownerObj.value = worker; 
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-	this->privateData->data->threadData->ownerObj.type = Oyster::Callback::CallbackType_Function; 
+	//this->privateData->data->threadData->threadDataAcces.lock();{
 
-	this->privateData->data->threadData->msec = 0;
+		this->privateData->data->threadData->ownerObj.value = worker; 
+		this->privateData->data->threadData->ownerObj.type = Oyster::Callback::CallbackType_Function; 
 
-	return OYSTER_THREAD_ERROR_SUCCESS;;
+		this->privateData->data->threadData->msec = 0;
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+
+	return val;;
 }
 OYSTER_THREAD_ERROR OysterThread::Terminate()
 {
 	if(this->privateData)
 		return this->privateData->Terminate();
+
 	return OYSTER_THREAD_ERROR_SUCCESS;
 }
 OYSTER_THREAD_ERROR OysterThread::Wait()
 {
-	if(this->privateData->data->threadData->state == OYSTER_THREAD_STATE_DEAD)
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-		return OYSTER_THREAD_ERROR_ThreadIsDead;
 
-	if(	this->privateData->data->workerThread.get_id() == std::this_thread::get_id())	
+	//this->privateData->data->threadData->threadDataAcces.lock();{
-	  return OYSTER_THREAD_ERROR_ThreadCannotWaintOnItselfe;
 
-	return OYSTER_THREAD_ERROR_SUCCESS;
+		if(this->privateData->data->threadData->state == OYSTER_THREAD_STATE_DEAD)
+			val = OYSTER_THREAD_ERROR_ThreadIsDead;
+
+		if(	this->privateData->data->workerThread.get_id() == std::this_thread::get_id())	
+			val = OYSTER_THREAD_ERROR_ThreadCannotWaintOnItselfe;
+
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+
+	return val;
 }
 OYSTER_THREAD_ERROR OysterThread::Wait(int msec)
 {
-	if(this->privateData->data->workerThread.get_id() == std::this_thread::get_id())	
+	OYSTER_THREAD_ERROR val = OYSTER_THREAD_ERROR_SUCCESS;
-		return OYSTER_THREAD_ERROR_ThreadCannotWaintOnItselfe;
+
-	
+	//this->privateData->data->threadData->threadDataAcces.lock();{
-	return OYSTER_THREAD_ERROR_SUCCESS;
+		if(this->privateData->data->workerThread.get_id() == std::this_thread::get_id())	
+			val = OYSTER_THREAD_ERROR_ThreadCannotWaintOnItselfe;
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
+	return val;
 }
 OYSTER_THREAD_ERROR OysterThread::Swap(const OysterThread* other)
 {
-	this->privateData->data->workerThread.swap(other->privateData->data->workerThread);
+	//this->privateData->data->threadData->threadDataAcces.lock();{
+		this->privateData->data->workerThread.swap(other->privateData->data->workerThread);
+	//} this->privateData->data->threadData->threadDataAcces.unlock();
 	return OYSTER_THREAD_ERROR_SUCCESS;
 }
 

Code/Misc/ThreadSafeQueue.h

@@ -34,12 +34,15 @@ namespace Utility
 			virtual bool IsEmpty();
 			virtual void Swap( IQueue<Type> &queue );
 
+			virtual void Clear();
+
 		private:
 			class Node
 			{
 			public:
 				Type item;
 				Node *next;
+				Node(){ this->next = NULL; };
 				Node(Type item){ this->item = item; this->next = NULL; };
 				~Node() {};
 			};
@@ -215,6 +218,15 @@ namespace Utility
 			stdMutex.unlock();
 		}		
 
+		template < typename Type > 
+		void ThreadSafeQueue<Type>::Clear()
+		{
+			while (!IsEmpty())
+			{
+				Pop();
+			}
+		}
+
 
 	}
 }

Code/Misc/Utilities-Impl.h

@@ -374,7 +374,191 @@ namespace Utility
 			return (this->_ptr != NULL)  ?	true : false;
 		}
 #pragma endregion
-		
+
+	}
+
+	namespace Thread
+	{
+#pragma region ThreadSafeSmartPointer
+		template<typename T> void ThreadSafeSmartPointer<T>::Destroy()
+		{
+			delete this->_rc.load();
+			this->_rc = NULL;
+
+			//Use default function for memory deallocation.
+			SafeDeleteInstance<T>(this->_ptr.load());
+
+			this->_ptr = NULL;
+		}
+		template<typename T> ThreadSafeSmartPointer<T>::ThreadSafeSmartPointer()
+				:_rc(0), _ptr(0)
+			{ }
+		template<typename T> ThreadSafeSmartPointer<T>::ThreadSafeSmartPointer(UniquePointer<T>& p)
+				:_ptr(p.Release())
+		{ 
+			this->_rc = new ReferenceCount();
+			this->_rc->Incref();
+		}
+		template<typename T> ThreadSafeSmartPointer<T>::ThreadSafeSmartPointer(T* p)
+			:_ptr(p)
+		{ 
+			this->_rc.store = new ReferenceCount();
+			this->_rc->Incref();
+		}
+		template<typename T> ThreadSafeSmartPointer<T>::ThreadSafeSmartPointer(const ThreadSafeSmartPointer& d)
+			:_ptr(d._ptr), _rc(d._rc)
+		{
+			if(this->_rc)
+				this->_rc->Incref();
+		}
+		template<typename T> ThreadSafeSmartPointer<T>::~ThreadSafeSmartPointer()
+		{
+			this->Release();
+		}
+		template<typename T> ThreadSafeSmartPointer<T>& ThreadSafeSmartPointer<T>::operator= (const ThreadSafeSmartPointer<T>& p)
+		{
+			if (this != &p)
+			{
+				//Last to go?
+				if(this->_rc.load() && this->_rc.load()->Decref() == 0)
+				{
+					//Call child specific
+					Destroy();
+				}
+
+				this->_ptr.store(p._ptr.load());
+				this->_rc.store(p._rc.load());
+				if(this->_rc.load())	this->_rc.load()->Incref();
+			}
+			return *this;
+		}
+		template<typename T> ThreadSafeSmartPointer<T>& ThreadSafeSmartPointer<T>::operator= (UniquePointer<T>& p)
+		{
+			//Last to go?
+			if(this->_rc)
+			{
+				if(this->_rc->Decref() == 0)
+				{
+					//Call child specific
+					Destroy();
+					this->_rc = new ReferenceCount();
+				}
+			}
+			else
+			{
+				if(p) this->_rc = new ReferenceCount();
+			}
+
+			if(this->_rc)
+				this->_rc->Incref();
+
+			this->_ptr = p.Release();
+
+			return *this;
+		}
+		template<typename T> ThreadSafeSmartPointer<T>& ThreadSafeSmartPointer<T>::operator= (T* p)
+		{
+			if (this->_ptr != p)
+			{
+				//Last to go?
+				if(this->_rc.load())
+				{
+					if(this->_rc.load()->Decref() == 0)
+					{
+						//Call child specific
+						Destroy();
+						if(p)	this->_rc = new ReferenceCount();
+					}
+				}
+				else if(p)
+				{
+					this->_rc = new ReferenceCount();
+				}
+
+				this->_ptr = p;
+
+				if(p)	this->_rc.load()->Incref();
+				else	this->_rc = 0;
+			}
+			return *this;
+		}
+		template<typename T> inline bool ThreadSafeSmartPointer<T>::operator== (const ThreadSafeSmartPointer<T>& d) const
+		{
+			return d._ptr == this->_ptr;
+		}
+		template<typename T> inline bool ThreadSafeSmartPointer<T>::operator== (const T& p) const
+		{
+			return &p == this->_ptr;
+		}
+		template<typename T> inline bool ThreadSafeSmartPointer<T>::operator!= (const ThreadSafeSmartPointer<T>& d) const
+		{
+			return d._ptr != this->_ptr;
+		}
+		template<typename T> inline bool ThreadSafeSmartPointer<T>::operator!= (const T& p) const
+		{
+			return &p != this->_ptr;
+		}
+		template<typename T> inline T& ThreadSafeSmartPointer<T>::operator* ()
+		{
+			return *this->_ptr;
+		}
+		template<typename T> inline const T& ThreadSafeSmartPointer<T>::operator* () const
+		{
+			return *this->_ptr;
+		}
+		template<typename T> inline T* ThreadSafeSmartPointer<T>::operator-> ()
+		{
+			return this->_ptr;
+		}
+		template<typename T> inline const T* ThreadSafeSmartPointer<T>::operator-> () const
+		{
+			return this->_ptr;
+		}
+		template<typename T> inline ThreadSafeSmartPointer<T>::operator T* () const
+		{
+			return this->_ptr;
+		}
+		template<typename T> inline ThreadSafeSmartPointer<T>::operator const T* () const
+		{
+			return this->_ptr;
+		}
+		template<typename T> inline ThreadSafeSmartPointer<T>::operator T& () const
+		{
+			return *this->_ptr;
+		}
+		template<typename T> inline ThreadSafeSmartPointer<T>::operator bool() const
+		{
+			return (this->_ptr != 0);
+		}
+		template<typename T> inline T* ThreadSafeSmartPointer<T>::Get()
+		{
+			return this->_ptr;
+		}
+		template<typename T> inline T* ThreadSafeSmartPointer<T>::Get() const
+		{
+			return this->_ptr;
+		}
+		template<typename T> int ThreadSafeSmartPointer<T>::Release()
+		{
+			int returnVal = 0;
+			
+			if(this->_rc.load() && ((returnVal = this->_rc.load()->Decref()) == 0))
+			{
+				Destroy();
+			}
+			return returnVal;
+		}
+		template<typename T> int ThreadSafeSmartPointer<T>::ReleaseDummy()
+		{
+			int val = this->_rc->Decref();
+			this->_rc->Incref();
+			return val;
+		}
+		template<typename T> inline bool ThreadSafeSmartPointer<T>::IsValid() const
+		{
+			return (this->_ptr != NULL)  ?	true : false;
+		}
+#pragma endregion
 	}
 }
 

Code/Misc/Utilities.cpp

@@ -300,7 +300,7 @@ namespace Utility
 
 		//To wstring
 
-		::std::wstring & StringToWString( const ::std::string &str, ::std::wstring &wstr )
+		::std::wstring & StringToWstring( const ::std::string &str, ::std::wstring &wstr )
 		{
 			const char *orig = str.c_str();
 

Code/Misc/Utilities.h

@@ -408,7 +408,59 @@ namespace Utility
 
 	namespace Thread
 	{
-		//Utilities for threading
+		using namespace DynamicMemory;
+		//! Wrapper to manage references on a pointer.
+		template<typename T> struct ThreadSafeSmartPointer
+		{
+			private:
+				std::atomic<ReferenceCount*>	_rc;
+				std::atomic<T*>					_ptr;
+
+				/** Destroys the pointer and returns the memory allocated. */
+				void Destroy();
+
+			public:
+				ThreadSafeSmartPointer();
+				ThreadSafeSmartPointer(UniquePointer<T>& up);
+				ThreadSafeSmartPointer(T* p);
+				ThreadSafeSmartPointer(const ThreadSafeSmartPointer& d);
+				virtual~ThreadSafeSmartPointer();
+				ThreadSafeSmartPointer<T>& operator= (const ThreadSafeSmartPointer<T>& p);
+				ThreadSafeSmartPointer<T>& operator= (UniquePointer<T>& p);
+				ThreadSafeSmartPointer<T>& operator= (T* p);
+				bool operator== (const ThreadSafeSmartPointer<T>& d) const;
+				bool operator== (const T& p) const;
+				bool operator!= (const ThreadSafeSmartPointer<T>& d) const;
+				bool operator!= (const T& p) const;
+				T& operator* ();
+				const T& operator* () const;
+				T* operator-> ();
+				const T* operator-> () const;
+				operator T* () const;
+				operator const T* () const;
+				operator T& () const;
+				operator bool() const;
+				
+				/**
+				*	Returns the connected pointer 
+				*/
+				T* Get();
+				T* Get() const;
+
+				/**
+				*	Releases one reference of the pointer and set value to null, making the current ThreadSafeSmartPointer invalid.
+				*/
+				int Release();
+				/**
+				*	Only test to release to check reference count.
+				*/
+				int ReleaseDummy();
+
+				/** Checks if the pointer is valid (not NULL)
+				*	Returns true for valid, else false. 
+				*/
+				bool IsValid() const;
+		};
 	}
 }
 

Code/Network/NetworkAPI/CustomNetProtocol.cpp

@@ -4,42 +4,31 @@
 #include "CustomNetProtocol.h"
 #include <map>
 #include "Translator.h"
-#include "Utilities.h"
+#include <DynamicArray.h>
 using namespace Oyster::Network;
 using namespace Utility::DynamicMemory;
 
 
 struct CustomNetProtocol::PrivateData
 {
-	std::map<int, NetAttributeContainer> attributes;		//...Im an idiot
+	//std::map<int, NetAttributeContainer> attributes;		//...Im an idiot
-	Utility::DynamicMemory::ReferenceCount *c;
+	DynamicArray<NetAttributeContainer> attributes;		//...Im an idiot
-
+	
 	PrivateData()
-	{
+	{  }
-		//this->attributes = new std::map<int, NetAttributeContainer>(); 
-		this->c = new ReferenceCount();
-		c->Incref();
-	}
 
 	~PrivateData()
 	{
-		delete c;
+		attributes.Clear();
-		c = 0;
-		for (auto i = attributes.begin(); i != attributes.end(); i++)
-		{
-			RemoveAttribute(i->first);
-		}
-		attributes.clear();
 	}
-	void RemoveAttribute(int ID)
+	void RemoveAttribute(NetAttributeContainer* i)
 	{
-		auto i = attributes.find(ID);
+		if(!i) return;
-		if(i == attributes.end()) return;
 
-		switch (i->second.type)
+		switch (i->type)
 		{
 			case NetAttributeType_CharArray:
-				delete [] i->second.value.netCharPtr;
+				delete [] i->value.netCharPtr;
 			break;
 		}
 	}
@@ -47,55 +36,42 @@ struct CustomNetProtocol::PrivateData
 	//Do network stuff
 };
 
-
 CustomNetProtocol::CustomNetProtocol()
 {
 	this->privateData = new PrivateData();
 }
-CustomNetProtocol::CustomNetProtocol(const CustomNetProtocol& o)
+CustomNetProtocol::CustomNetProtocol(CustomNetProtocol& o)
 {
-	this->privateData = o.privateData;
+	this->privateData = new PrivateData();
-	if(this->privateData)
+	this->privateData->attributes = o.privateData->attributes;
-	{
-		this->privateData->c = o.privateData->c;
-		this->privateData->c->Incref();
-	}
 }
-const CustomNetProtocol& CustomNetProtocol::operator=(const CustomNetProtocol& o)
+const CustomNetProtocol& CustomNetProtocol::operator=(CustomNetProtocol& o)
 {
-	if(this->privateData && this->privateData->c)
+	if(this->privateData) 
 	{
-		if(this->privateData->c->Decref() == 0)
+		delete this->privateData;
-		{
+		this->privateData = 0;
-			delete this->privateData;
-		}
-	}
-
-	this->privateData = o.privateData;
-	if(this->privateData)
-	{
-		this->privateData->c = o.privateData->c;
-		this->privateData->c->Incref();
 	}
+	this->privateData = new PrivateData();
+	this->privateData->attributes = o.privateData->attributes;
 	return *this;
 }
 CustomNetProtocol::~CustomNetProtocol()
 {
-	if(this->privateData && this->privateData->c)
+	delete this->privateData;
-	{
+	this->privateData = 0;
-		if(this->privateData->c->Decref() == 0)
-		{
-			delete this->privateData;
-		}
-	}
 }
 NetAttributeContainer& CustomNetProtocol::operator[](int ID)
 {
-	if(this->privateData->attributes.find(ID) == this->privateData->attributes.end())
+	//if(!this->privateData) this->privateData = new PrivateData();
+	if((unsigned int)ID >= this->privateData->attributes.Size())
 	{
-		this->privateData->attributes[ID];
+		NetAttributeContainer temp;
-		this->privateData->attributes[ID].type = NetAttributeType_UNKNOWN;
+		
-		memset(&this->privateData->attributes[ID].value, 0, sizeof(NetAttributeValue));
+		temp.type = NetAttributeType_UNKNOWN;
+		memset(&temp.value, 0, sizeof(NetAttributeValue));
+
+		this->privateData->attributes.Push(ID, temp);
 	}
 
 	return this->privateData->attributes[ID];
@@ -134,4 +110,115 @@ void CustomNetProtocol::Set(int ID, std::string s)
 const NetAttributeContainer& CustomNetProtocol::Get(int id)
 {
 	return this->privateData->attributes[id];
-}
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////
+//// Created by [Dennis Andersen] [2013]
+///////////////////////////////////////////////////////////////////////
+//#include "CustomNetProtocol.h"
+//#include <map>
+//#include "Translator.h"
+//#include <DynamicArray.h>
+//using namespace Oyster::Network;
+//using namespace Utility::DynamicMemory;
+//
+//
+//
+//struct CustomNetProtocol::PrivateData
+//{
+//	Utility::DynamicMemory::DynamicArray<NetAttributeContainer> attributes;		//...Im an idiot
+//	
+//	PrivateData()
+//	{  }
+//
+//	~PrivateData()
+//	{
+//		for (unsigned int i = 0; i < attributes.Size(); i++)
+//		{
+//			RemoveAttribute(i);
+//		}
+//
+//		attributes.Clear();
+//	}
+//	void RemoveAttribute(int i)
+//	{
+//		switch (attributes[i].type)
+//		{
+//			case NetAttributeType_CharArray:
+//				delete [] attributes[i].value.netCharPtr;
+//			break;
+//		}
+//	}
+//
+//	//Do network stuff
+//};
+//
+//
+//CustomNetProtocol::CustomNetProtocol()
+//{
+//	this->privateData = new PrivateData();
+//}
+//CustomNetProtocol::CustomNetProtocol(const CustomNetProtocol& o)
+//{
+//	this->privateData = o.privateData;
+//}
+//const CustomNetProtocol& CustomNetProtocol::operator=(const CustomNetProtocol& o)
+//{
+//	this->privateData = o.privateData;
+//	return *this;
+//}
+//CustomNetProtocol::~CustomNetProtocol()
+//{
+//}
+//NetAttributeContainer& CustomNetProtocol::operator[](int ID)
+//{
+//	if(ID >= this->privateData->attributes.Size())
+//		this->privateData->attributes.Resize(
+//	if(this->privateData->attributes.find(ID) == this->privateData->attributes.end())
+//	{
+//		this->privateData->attributes[ID];
+//		this->privateData->attributes[ID].type = NetAttributeType_UNKNOWN;
+//		memset(&this->privateData->attributes[ID].value, 0, sizeof(NetAttributeValue));
+//	}
+//
+//	return this->privateData->attributes[ID];
+//}
+//
+//void CustomNetProtocol::Set(int ID, Oyster::Network::NetAttributeValue val, Oyster::Network::NetAttributeType type)
+//{
+//	this->privateData->attributes[ID].type = type;
+//
+//	switch (type)
+//	{
+//		case Oyster::Network::NetAttributeType_Bool:
+//		case Oyster::Network::NetAttributeType_Char:
+//		case Oyster::Network::NetAttributeType_UnsignedChar:
+//		case Oyster::Network::NetAttributeType_Short:
+//		case Oyster::Network::NetAttributeType_UnsignedShort:
+//		case Oyster::Network::NetAttributeType_Int:
+//		case Oyster::Network::NetAttributeType_UnsignedInt:
+//		case Oyster::Network::NetAttributeType_Int64:
+//		case Oyster::Network::NetAttributeType_UnsignedInt64:
+//		case Oyster::Network::NetAttributeType_Float:
+//		case Oyster::Network::NetAttributeType_Double:
+//			this->privateData->attributes[ID].value = val;
+//		break;
+//	}
+//}
+//void CustomNetProtocol::Set(int ID, std::string s)
+//{
+//	if(s.size() == 0) return;
+//
+//	this->privateData->attributes[ID].type = Oyster::Network::NetAttributeType_CharArray;
+//
+//	this->privateData->attributes[ID].value.netCharPtr = new char[s.size() + 1];
+//	memcpy(&this->privateData->attributes[ID].value.netCharPtr[0], &s[0], s.size() + 1);
+//}
+//const NetAttributeContainer& CustomNetProtocol::Get(int id)
+//{
+//	return this->privateData->attributes[id];
+//}

Code/Network/NetworkAPI/CustomNetProtocol.h

@@ -4,7 +4,11 @@
 #ifndef NETWORK_CUSTOM_NETWORK_PROTOCOL_H
 #define NETWORK_CUSTOM_NETWORK_PROTOCOL_H
 
+//needs to have dll-interface to be used by clients of class 'Oyster::Network::NetworkSession'
+#pragma warning(disable : 4251)
+
 #include <string>
+#include "Utilities.h"
 //#include <vld.h>
 #include "NetworkAPI_Preprocessor.h"
 
@@ -65,12 +69,60 @@ namespace Oyster
 			{
 				NetAttributeType type;
 				NetAttributeValue value;
-				NetAttributeContainer() { type = NetAttributeType_UNKNOWN; }
+				NetAttributeContainer() 
+				{ type = NetAttributeType_UNKNOWN; }
+				~NetAttributeContainer() 
+				{ 
+					if (this->type == NetAttributeType_CharArray)
+					{
+						delete this->value.netCharPtr;
+						this->value.netCharPtr = 0;
+					}
+				}
+				NetAttributeContainer(NetAttributeContainer& p) 
+				{ 
+					type = p.type; 
+					if(type == NetAttributeType_CharArray && p.value.netCharPtr)
+					{
+						int len = 0;
+						if((len = strlen(p.value.netCharPtr)) == 0) return;
+						len++;
+						value.netCharPtr = new char[len];
+						memcpy(&value.netCharPtr[0], &p.value.netCharPtr[0], sizeof(p.value.netCharPtr[0]) * len);
+					}
+					else
+					{
+						value = p.value;
+					}
+				}
+				const NetAttributeContainer& operator=(const NetAttributeContainer& p) 
+				{ 
+					if(this->type == NetAttributeType_CharArray)
+					{
+						delete this->value.netCharPtr;
+						this->value.netCharPtr = 0;
+					}
+
+					type = p.type; 
+					if(type == NetAttributeType_CharArray && p.value.netCharPtr)
+					{
+						int len = 0;
+						if((len = strlen(p.value.netCharPtr)) == 0) return *this;
+						len++;
+						value.netCharPtr = new char[len];
+						memcpy(&value.netCharPtr[0], &p.value.netCharPtr[0], sizeof(p.value.netCharPtr[0]) * len);
+					}
+					else
+					{
+						value = p.value;
+					}
+					return *this;
+				}
 			};
 			class CustomNetProtocol;
 			struct CustomProtocolObject
 			{
-				virtual CustomNetProtocol* GetProtocol() = 0;
+				virtual CustomNetProtocol GetProtocol() = 0;
 			};
 
 			class NET_API_EXPORT CustomNetProtocol
@@ -78,8 +130,8 @@ namespace Oyster
 			public:
 				CustomNetProtocol();
 				~CustomNetProtocol();
-				CustomNetProtocol(const CustomNetProtocol& o);
+				CustomNetProtocol(CustomNetProtocol& o);
-				const CustomNetProtocol& operator=(const CustomNetProtocol& o);
+				const CustomNetProtocol& operator=(CustomNetProtocol& o);
 
 				NetAttributeContainer& operator[](int ID);
 				void Set(int id, Oyster::Network::NetAttributeValue val, Oyster::Network::NetAttributeType type);
@@ -88,6 +140,8 @@ namespace Oyster
 
 			private:
 				struct PrivateData;
+				//Utility::DynamicMemory::SmartPointer<PrivateData> privateData;
+				//Utility::Thread::ThreadSafeSmartPointer<PrivateData> privateData;
 				PrivateData* privateData;
 
 				friend class Translator;

Code/Network/NetworkAPI/NetworkClient.cpp

@@ -19,6 +19,7 @@
 #include "../../Misc/Packing/Packing.h"
 
 #include <queue>
+#include <WinSock2.h>
 
 using namespace Oyster::Network;
 using namespace Oyster::Thread;
@@ -61,9 +62,10 @@ struct NetworkClient::PrivateData : public IThreadObject
 	}
 	~PrivateData()
 	{ 
+		this->thread.Terminate();
+
 		ShutdownWinSock();
 		this->connection.Disconnect();
-		this->thread.Terminate();
 		this->owner = 0;
 		this->parent = 0;
 	}
@@ -83,12 +85,13 @@ struct NetworkClient::PrivateData : public IThreadObject
 
 		if(!this->sendQueue.IsEmpty())
 		{
-			SmartPointer<OysterByte> temp = new OysterByte();
+			//printf("\t(%i)\n", this->sendQueue.Size());
+			OysterByte temp;
 			CustomNetProtocol p = this->sendQueue.Pop();
 			this->translator.Pack(temp, p);
 			errorCode = this->connection.Send(temp);
 
-			if(errorCode != 0)
+			if(errorCode != 0 && errorCode != WSAEWOULDBLOCK)
 			{
 				CEA parg;
 				parg.type = CEA::EventType_ProtocolFailedToSend;
@@ -204,7 +207,11 @@ struct NetworkClient::PrivateData : public IThreadObject
 			CEA parg;
 			parg.type = CEA::EventType_ProtocolRecieved;
 			parg.data.protocol = protocol;
-			NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e = { this->parent, parg };
+			NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e;
+			e.sender = this->parent;
+			e.args.data.protocol = parg.data.protocol;
+			e.args.type = parg.type;
+			
 			this->recieveQueue.Push(e);
 		}
 	}
@@ -247,9 +254,6 @@ void NetworkClient::Update()
 
 		this->DataRecieved(temp);
 
-	//--------- Deprecate --------- 
-		this->NetworkCallback(temp.args.data.protocol);
-	//------------------------------
 	}
 }
 
@@ -291,18 +295,23 @@ bool NetworkClient::Connect(unsigned short port, const char serverIP[])
 
 void NetworkClient::Disconnect()
 {
-	privateData->connection.Disconnect();
+	if(!privateData) return;
+
 	privateData->thread.Terminate();
+	privateData->connection.Disconnect();
+	this->privateData->sendQueue.Clear();
+	this->privateData->recieveQueue.Clear();
+
 }
 
 void NetworkClient::Send(CustomProtocolObject& protocol)
 {
-	this->privateData->sendQueue.Push(*protocol.GetProtocol());
+	this->privateData->sendQueue.Push(protocol.GetProtocol());
 }
 
-void NetworkClient::Send(CustomNetProtocol* protocol)
+void NetworkClient::Send(CustomNetProtocol& protocol)
 {
-	this->privateData->sendQueue.Push(*protocol);
+	this->privateData->sendQueue.Push(protocol);
 }
 
 void NetworkClient::SetOwner(NetworkSession* owner)
@@ -329,8 +338,8 @@ void NetworkClient::DataRecieved(NetEvent<NetworkClient*, ClientEventArgs> e)
 	}
 }
 
-void NetworkClient::NetworkCallback(Oyster::Network::CustomNetProtocol& p)
+//void NetworkClient::NetworkCallback(Oyster::Network::CustomNetProtocol& p)
-{}
+//{}
 
 std::string NetworkClient::GetIpAddress()
 {

Code/Network/NetworkAPI/NetworkClient.h

@@ -36,7 +36,33 @@ namespace Oyster
 					{
 						struct { Oyster::Network::CustomNetProtocol protocol; };
 						void * nothing;
+						EventData(){}
+						EventData(Oyster::Network::CustomNetProtocol& o) 
+						{ 
+							protocol = o; 
+						}
+						const EventData& operator=(EventData& o)
+						{
+							protocol = o.protocol;
+							return *this;
+						}
+						const EventData& operator=(Oyster::Network::CustomNetProtocol& o) 
+						{ 
+							protocol = o; return *this; 
+						}
 					} data;
+					ClientEventArgs(){}
+					ClientEventArgs(ClientEventArgs& o)
+					{ 
+						type = o.type; 
+						data = o.data; 
+					}
+					const ClientEventArgs& operator=(ClientEventArgs& o)
+					{ 
+						type = o.type; 
+						data = o.data; 
+						return *this; 
+					}
 				};
 				typedef void(*ClientEventFunction)(NetEvent<NetworkClient*, ClientEventArgs> e);
 
@@ -75,7 +101,7 @@ namespace Oyster
 				/**
 				*	
 				*/
-				void Send(CustomNetProtocol* protocol);
+				void Send(CustomNetProtocol& protocol);
 
 				/**
 				*	
@@ -101,7 +127,7 @@ namespace Oyster
 				*	Do not use this furthermore, instead use void DataRecieved(NetEvent<NetworkClient*, ClientEventArgs> e);
 				*	@see DataRecieved
 				*/
-				virtual void NetworkCallback(Oyster::Network::CustomNetProtocol& p);
+				//virtual void NetworkCallback(Oyster::Network::CustomNetProtocol& p);
 
 				virtual std::string GetIpAddress();
 

Code/Network/NetworkAPI/NetworkServer.cpp

@@ -261,7 +261,7 @@ NetworkSession const* NetworkServer::ReleaseMainSession()
 	return temp;
 }
 
-bool NetworkServer::IsStarted() const
+bool NetworkServer::IsRunning() const
 {
 	return this->privateData->isRunning;
 }

Code/Network/NetworkAPI/NetworkServer.h

@@ -77,7 +77,7 @@ namespace Oyster
 				/**	
 				*	
 				*/
-				bool IsStarted() const;
+				bool IsRunning() const;
 
 				/**
 				*	

Code/Network/NetworkAPI/NetworkSession.cpp

@@ -26,7 +26,15 @@ struct NetworkSession::PrivateSessionData
 	{}
 };
 
-
+int FindClient(NetClientList& list, NetClient c)
+{
+	for (unsigned int i = 0; i < list.Size(); i++)
+	{
+		if(c == list[i])
+			return i;
+	}
+	return -1;
+}
 
 NetworkSession::NetworkSession()
 	:	data(new PrivateSessionData())
@@ -125,7 +133,7 @@ NetClient NetworkSession::Detach(const NetworkClient* client)
 
 		for (unsigned int i = 0; i < this->clients.Size(); i++)
 		{
-			if(this->clients[i] && this->clients[0]->GetID() == client->GetID())
+			if(this->clients[i] && this->clients[i]->GetID() == client->GetID())
 			{
 				val = this->clients[i];
 				this->clients[i] = 0;
@@ -188,7 +196,7 @@ bool NetworkSession::Send(Oyster::Network::CustomNetProtocol& protocol)
 	{
 		if(this->clients[i])
 		{
-			this->clients[i]->Send(&protocol);
+			this->clients[i]->Send(protocol);
 			returnValue = true;
 		}
 	}
@@ -202,7 +210,7 @@ bool NetworkSession::Send(Oyster::Network::CustomNetProtocol& protocol, int ID)
 	{
 		if(this->clients[i] && this->clients[i]->GetID() == ID)
 		{
-			this->clients[i]->Send(&protocol);
+			this->clients[i]->Send(protocol);
 			return true;
 		}
 	}
@@ -237,5 +245,8 @@ void NetworkSession::SetOwner(NetworkSession* owner)
 void NetworkSession::ClientConnectedEvent(NetClient client)
 {
 	this->Attach(client);
+
+	if(FindClient(this->clients, client) == -1)
+		NetworkSession::Attach(client);
 }
 

Code/Network/NetworkAPI/Translator.cpp

@@ -8,17 +8,18 @@
 #include "../../Misc/Utilities.h"
 #include "../NetworkDependencies/Messages/MessageHeader.h"
 #include "../NetworkDependencies/OysterByte.h"
-
+#include <DynamicArray.h>
 
 using namespace Oyster::Network;
 using namespace ::Messages;
 using namespace Utility::DynamicMemory;
 using namespace std;
 
+
+//TODO: Fix this uggly hack
 struct MyCastingStruct
 {
-	std::map<int, NetAttributeContainer> attributes;
+	Utility::DynamicMemory::DynamicArray<NetAttributeContainer> attributes;
-	Utility::DynamicMemory::ReferenceCount *c;
 };
 
 // TODO: Check if the package has been packed correctly.
@@ -43,7 +44,7 @@ struct Translator::PrivateData
 		//Find all the data types
 		for(; it != end; it++)
 		{
-			headerString.push_back(it->second.type);
+			headerString.push_back(it->type);
 		}
 
 		message.PackShort(headerString.size(), bytes);
@@ -68,40 +69,40 @@ struct Translator::PrivateData
 			switch((int)headerString.at(i))
 			{
 			case NetAttributeType_Bool:
-				message.PackBool(it->second.value.netBool, bytes);
+				message.PackBool(it->value.netBool, bytes);
 				break;
 			case NetAttributeType_Char:
-				message.PackChar(it->second.value.netChar, bytes);
+				message.PackChar(it->value.netChar, bytes);
 				break;
 			case NetAttributeType_UnsignedChar:
-				message.PackUnsignedChar(it->second.value.netUChar, bytes);
+				message.PackUnsignedChar(it->value.netUChar, bytes);
 				break;
 			case NetAttributeType_Short:
-				message.PackShort(it->second.value.netShort, bytes);
+				message.PackShort(it->value.netShort, bytes);
 				break;
 			case NetAttributeType_UnsignedShort:
-				message.PackUnsignedShort(it->second.value.netUShort, bytes);
+				message.PackUnsignedShort(it->value.netUShort, bytes);
 				break;
 			case NetAttributeType_Int:
-				message.PackInt(it->second.value.netInt, bytes);
+				message.PackInt(it->value.netInt, bytes);
 				break;
 			case NetAttributeType_UnsignedInt:
-				message.PackUnsignedInt(it->second.value.netUInt, bytes);
+				message.PackUnsignedInt(it->value.netUInt, bytes);
 				break;
 			case NetAttributeType_Int64:
-				message.PackInt64(it->second.value.netInt64, bytes);
+				message.PackInt64(it->value.netInt64, bytes);
 				break;
 			case NetAttributeType_UnsignedInt64:
-				message.PackUnsignedInt64(it->second.value.netUInt64, bytes);
+				message.PackUnsignedInt64(it->value.netUInt64, bytes);
 				break;
 			case NetAttributeType_Float:
-				message.PackFloat(it->second.value.netFloat, bytes);
+				message.PackFloat(it->value.netFloat, bytes);
 				break;
 			case NetAttributeType_Double:
-				message.PackDouble(it->second.value.netDouble, bytes);
+				message.PackDouble(it->value.netDouble, bytes);
 				break;
 			case NetAttributeType_CharArray:
-				message.PackStr(it->second.value.netCharPtr, bytes);
+				message.PackStr(it->value.netCharPtr, bytes);
 				break;
 			default:
 				numberOfUnknownTypes++;
@@ -215,6 +216,7 @@ const Translator& Translator::operator=(const Translator& obj)
 
 void Translator::Pack(OysterByte &bytes, CustomNetProtocol& protocol)
 {
+
 	privateData->headerString.clear();
 
 	privateData->PackHeader(bytes, protocol);

Code/OysterGraphics/Core/Core.cpp

@@ -15,6 +15,11 @@ IDXGISwapChain* Core::swapChain = NULL;
 
 std::stringstream Core::log;
 
+Oyster::Resource::ResourceManager Core::loader;
+
+std::wstring Core::modelPath;
+std::wstring Core::texturePath;
+
 ID3D11RenderTargetView* Core::backBufferRTV = NULL;
 
 ID3D11UnorderedAccessView* Core::backBufferUAV = NULL;

Code/OysterGraphics/Core/Core.h

@@ -7,6 +7,7 @@
 #include "Dx11Includes.h"
 #include <sstream>
 #include "OysterMath.h"
+#include "../Misc/Resource/ResourceManager.h"
 //#include <vld.h>
 
 namespace Oyster
@@ -25,6 +26,10 @@ namespace Oyster
 
 			static std::stringstream log;
 
+			static Resource::ResourceManager loader;
+
+			static std::wstring modelPath, texturePath;
+
 			//BackBufferRTV
 			static ID3D11RenderTargetView* backBufferRTV;
 			//BackBufferUAV