GameServer - Merged with GameLogic, some stuff is broken

Code/DanBias.sln

@@ -37,16 +37,28 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NetworkAPI", "Network\Netwo
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GameProtocols", "Game\GameProtocols\GameProtocols.vcxproj", "{DA2AA800-ED64-4649-8B3B-E7F1E3968B78}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DanBiasServerLauncher", "Game\DanBiasServerLauncher\DanBiasServerLauncher.vcxproj", "{060B1890-CBF3-4808-BA99-A4776222093B}"
+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
@@ -55,204 +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
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|Win32.Build.0 = Release|Win32
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{060B1890-CBF3-4808-BA99-A4776222093B}.RelWithDebInfo|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
@@ -266,6 +512,8 @@ Global
 		{B1195BB9-B3A5-47F0-906C-8DEA384D1520} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 		{8690FDDF-C5B7-4C42-A337-BD5243F29B85} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 		{DA2AA800-ED64-4649-8B3B-E7F1E3968B78} = {20720CA7-795C-45AD-A302-9383A6DD503A}
+		{060B1890-CBF3-4808-BA99-A4776222093B} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 		{143BD516-20A1-4890-A3E4-F8BFD02220E7} = {20720CA7-795C-45AD-A302-9383A6DD503A}
+		{666FEA52-975F-41CD-B224-B19AF3C0ABBA} = {20720CA7-795C-45AD-A302-9383A6DD503A}
 	EndGlobalSection
 EndGlobal

Code/Game/DanBiasGame/DanBiasGame.vcxproj

@@ -205,6 +205,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" />
@@ -219,6 +223,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

@@ -17,6 +17,9 @@
 #include "vld.h"
 #include "GameClientRecieverFunc.h"
 
+#include "../Misc/EventHandler/EventHandler.h"
+using namespace Oyster::Event;
+
 namespace DanBias
 {
 
@@ -138,8 +141,6 @@ namespace DanBias
 	
 	HRESULT DanBiasGame::Update(float deltaTime)
 	{
-
-
 		m_data->inputObj->Update();
 
 		if(m_data->serverOwner)

Code/Game/DanBiasGame/GameClientRecieverFunc.h

@@ -82,6 +82,20 @@ namespace DanBias
 						((Client::GameState*)gameClientState)->Protocol(&protocolData);
 				}
 				break;
+			case protocol_Gameplay_ObjectPositionRotation:
+				{
+
+					Client::GameClientState::ObjPos protocolData;
+					protocolData.object_ID = p[1].value.netInt;
+					for(int i = 0; i< 16; i++)
+					{
+						protocolData.worldPos[i] = p[i+2].value.netFloat;
+					}
+
+					if(dynamic_cast<Client::GameState*>(gameClientState))
+						((Client::GameState*)gameClientState)->Protocol(&protocolData);
+				}
+				break;
 			case protocol_Lobby_Create:
 				{
 					if(dynamic_cast<Client::LobbyState*>(gameClientState))

Code/Game/DanBiasGame/GameClientState/C_Object.cpp

@@ -1,4 +1,87 @@
 #include "C_Object.h"
 using namespace DanBias::Client;
+void C_Object::Init(ModelInitData modelInit)
+{
+	position = modelInit.position;
+	rotation = modelInit.rotation;
+	scale = modelInit.scale;
+	id = modelInit.id;
+	model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
+	model->Visible = modelInit.visible;
+	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;
 
-
+	model->WorldMatrix = world;
+}
+void C_Object::setWorld(Oyster::Math::Float4x4 world)
+{
+	model->WorldMatrix = 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 id;
+}
+void C_Object::Render()
+{
+	Oyster::Graphics::API::RenderModel(*(model));
+}
+void C_Object::Release()
+{
+	Oyster::Graphics::API::DeleteModel(model);
+}

Code/Game/DanBiasGame/GameClientState/C_Object.h

@@ -10,21 +10,40 @@ 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; 
+	Oyster::Graphics::Model::Model *model;
+	int id;
+	void updateWorld();
 public:
 
-	virtual void Init(ModelInitData modelInit) = 0;
+	virtual void Init(ModelInitData modelInit);
-	virtual void setPos(Oyster::Math::Float4x4 world) = 0;
 	
-	virtual void Render() = 0;
+	void setWorld(Oyster::Math::Float4x4 world);
-	virtual void Release() = 0;
+	Oyster::Math::Float4x4 getWorld() const;
-	virtual int GetId() = 0;
+	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();
+	virtual void Release();
+	virtual int GetId() const;
 };};};
 #endif

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

@@ -1,15 +1,7 @@
 #include "C_DynamicObj.h"
 #include "DllInterfaces/GFXAPI.h"
 using namespace DanBias::Client;
-struct  C_DynamicObj::myData
+
-{
-	myData(){}
-	Oyster::Graphics::Model::Model *model;
-	int ID;
-	// light
-	// sound
-	// effect
-}privData;
 C_DynamicObj::C_DynamicObj(void)
 {
 }
@@ -21,28 +13,5 @@ C_DynamicObj::~C_DynamicObj(void)
 }
 void C_DynamicObj::Init(ModelInitData modelInit)
 {
-	// load models
+	C_Object::Init(modelInit);
-	privData = new myData();
-	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
-	privData->model->Visible = modelInit.visible;
-	privData->ID = modelInit.id;
-}
-void C_DynamicObj::setPos(Oyster::Math::Float4x4 world)
-{
-	privData->model->WorldMatrix  = world;
-}
-
-void C_DynamicObj::Render()
-{
-	Oyster::Graphics::API::RenderModel(*(privData->model));
-}
-void C_DynamicObj::Release()
-{
-	Oyster::Graphics::API::DeleteModel(privData->model);
-	delete privData; 
-}
-int C_DynamicObj::GetId()
-{
-	return privData->ID;
 }

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

@@ -8,16 +8,10 @@ namespace DanBias
 class C_DynamicObj : public C_Object
 {
 private:
-	struct myData;
-	myData* privData;
 public:
 	C_DynamicObj(void);
 	virtual ~C_DynamicObj(void);
 	void Init(ModelInitData modelInit);
-	void setPos(Oyster::Math::Float4x4 world);
 
-	void Render();
-	void Release();
-	int GetId();
 };};};
 #endif

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

@@ -2,20 +2,11 @@
 #include "DllInterfaces/GFXAPI.h"
 using namespace DanBias::Client;
 
-struct  C_Player::myData
-{
-	myData(){}
-	Oyster::Math3D::Float4x4 view;
-	Oyster::Math3D::Float4x4 proj; 
-	Oyster::Graphics::Model::Model *model;
-	Oyster::Math3D::Float4 lookDir;
-	int ID;
-}privData;
-
 C_Player::C_Player(void)
+	:C_DynamicObj()
 {
-}
 
+}
 
 C_Player::~C_Player(void)
 {
@@ -24,29 +15,5 @@ C_Player::~C_Player(void)
 
 void C_Player::Init(ModelInitData modelInit)
 {
-	// load models
+	C_Object::Init(modelInit);
-	privData = new myData();
-	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
-	privData->model->Visible = modelInit.visible;
-	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()
-{
-		Oyster::Graphics::API::RenderModel(*(privData->model));
-}
-void C_Player::Release()
-{
-	Oyster::Graphics::API::DeleteModel(privData->model);
-	delete privData; 
-}
-int C_Player::GetId()
-{
-	return privData->ID;
 }

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

@@ -1,25 +1,17 @@
 #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();
-	int GetId();
 
 };};};
 #endif

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

@@ -3,49 +3,15 @@
 #include "DllInterfaces/GFXAPI.h"
 using namespace DanBias::Client;
 
-struct  C_StaticObj::myData
-{
-	myData(){}
-	Oyster::Graphics::Model::Model *model;
-	int ID;
-	// light
-	// sound
-	// effect
-}privData;
 C_StaticObj::C_StaticObj(void)
 {
+
 }
-
-
 C_StaticObj::~C_StaticObj(void)
 {
 	
 }
 void C_StaticObj::Init(ModelInitData modelInit)
 {
-	// load models
+	C_Object::Init(modelInit);
-	privData = new myData();
-	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
-	privData->model->Visible = modelInit.visible;
-	privData->ID = modelInit.id;
-
-}
-void C_StaticObj::setPos(Oyster::Math::Float4x4 world)
-{
-	privData->model->WorldMatrix  = world;
-}
-
-void C_StaticObj::Render()
-{
-	Oyster::Graphics::API::RenderModel(*(privData->model));
-}
-void C_StaticObj::Release()
-{
-	Oyster::Graphics::API::DeleteModel(privData->model);
-	delete privData; 
-}
-int C_StaticObj::GetId()
-{
-	return privData->ID;
 }

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

@@ -8,16 +8,10 @@ namespace DanBias
 class C_StaticObj : public C_Object 
 {
 private:
-	struct myData;
-	myData* privData;
 public:
 	C_StaticObj(void);
 	virtual ~C_StaticObj(void);
 	void Init(ModelInitData modelInit);
-	void setPos(Oyster::Math::Float4x4 world);
 
-	void Render();
-	void Release();
-	int GetId();
 };};};
 #endif

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

@@ -2,13 +2,6 @@
 #include "DllInterfaces/GFXAPI.h"
 using namespace DanBias::Client;
 
-struct  C_UIobject::myData
-{
-	myData(){}
-	Oyster::Graphics::Model::Model *model;
-	int ID;
-}privData;
-
 C_UIobject::C_UIobject(void)
 {
 }
@@ -19,29 +12,5 @@ C_UIobject::~C_UIobject(void)
 }
 void C_UIobject::Init(ModelInitData modelInit)
 {
-	// load models
+	C_Object::Init(modelInit);
-	privData = new myData();
-	privData->model = Oyster::Graphics::API::CreateModel(modelInit.modelPath);
-	privData->model->WorldMatrix = modelInit.world;
-	privData->model->Visible = modelInit.visible;
-	privData->ID = modelInit.id;
-
-}
-void C_UIobject::setPos(Oyster::Math::Float4x4 world)
-{
-	privData->model->WorldMatrix  = world;
-}
-
-void C_UIobject::Render()
-{
-	Oyster::Graphics::API::RenderModel(*(privData->model));
-}
-void C_UIobject::Release()
-{
-	Oyster::Graphics::API::DeleteModel(privData->model);
-	delete privData; 
-}
-int C_UIobject::GetId()
-{
-	return privData->ID;
 }

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

@@ -8,16 +8,11 @@ namespace DanBias
 		class C_UIobject : public C_Object 
 		{
 		private:
-			struct myData;
+
-			myData* privData;
 		public:
 			C_UIobject(void);
 			virtual ~C_UIobject(void);
 			void Init(ModelInitData modelInit);
 			void setPos(Oyster::Math::Float4x4 world);
-
-			void Render();
-			void Release();
-			int GetId();
 };};};
 #endif

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,20 +1,17 @@
 #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"
 #include <GameServerAPI.h>
 
 using namespace DanBias::Client;
-
+using namespace Oyster::Math;
 struct  GameState::myData
 {
 	myData(){}
-	Oyster::Math3D::Float4x4 view;
+	//std::vector<C_Object*> object;
-	Oyster::Math3D::Float4x4 proj; 
+	int modelCount;
-	std::vector<C_Object*> object;
 	Oyster::Network::NetworkClient* nwClient;
 	gameStateState state;
 	
@@ -53,152 +50,230 @@ bool GameState::Init(Oyster::Network::NetworkClient* nwClient)
 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;
 	int id = 100; 
 
-// add world model
+	// 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
+	// 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 
+	// 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.position = Oyster::Math::Float3(0, 320, 0);
+	modelData.modelPath = L"char_still_sizeref.dan";
+	modelData.id = id++;
+	// load models
+	this->dynamicObjects.Push(new C_DynamicObj());
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
+
+	// add player model 2
+	modelData.position = Oyster::Math::Float3(50, 320, 0);
+	modelData.modelPath = L"char_still_sizeref.dan";
+	modelData.id = id++;
+	// load models
+	this->dynamicObjects.Push(new C_DynamicObj());
+	this->dynamicObjects[this->dynamicObjects.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)
 {
-	Oyster::Math::Float3 dir = Oyster::Math::Float3(0,0,1);
+	GameLogic::LevelLoader levelLoader;
-	Oyster::Math::Float3 up =Oyster::Math::Float3(0,1,0);
+	std::vector<Utility::DynamicMemory::SmartPointer<GameLogic::ObjectTypeHeader>> objects; 
-	Oyster::Math::Float3 pos = Oyster::Math::Float3(0, 0, 20);
+	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)
+{
+	Float3 dir = Float3(0,0,1);
+	Float3 up = Float3(0,1,0);
+	Float3 pos = Float3(0, 0, 20);
 	camera->LookAt(pos, dir, up);
-	camera->SetLens(3.14f/2, 1024/768, 1, 1000);
+	camera->SetLens(pi/4, 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();
+	Oyster::Graphics::API::SetProjection(camera->Proj());
-	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);
-	privData->view = Oyster::Math3D::InverseOrientationMatrix(privData->view);
 	return true;
 }
 void GameState::InitiatePlayer(int id, std::wstring modelName, Oyster::Math::Float4x4 world)
@@ -208,15 +283,18 @@ void GameState::InitiatePlayer(int id, std::wstring modelName, Oyster::Math::Flo
 	ModelInitData modelData;
 	C_Object* obj;
 	modelData.visible = true;
-	modelData.world = world;
+	//modelData.world = world;
+	modelData.position = Oyster::Math::Float3(world[12], world[13], world[14]);
+	modelData.rotation = Oyster::Math::Quaternion(Oyster::Math::Float3(0,0,0), 1);
+	modelData.scale =  Oyster::Math::Float3(1,1,1);
 	modelData.modelPath = modelName;
 	modelData.id = myId;
 	
 	obj =  new C_Player();
-	privData->object.push_back(obj);
+	this->dynamicObjects.Push(obj);
-	privData->object[privData->object.size() -1 ]->Init(modelData);
+	this->dynamicObjects[this->dynamicObjects.Size() -1 ]->Init(modelData);
+
 	
-	//printf("Move message recieved!");
 	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]));
@@ -238,7 +316,7 @@ void GameState::InitiatePlayer(int id, std::wstring modelName, Oyster::Math::Flo
 	camera->setLook(objForward);
 				
 	up *= 2;
-	objForward *= -3;
+	objForward *= 3;
 	Oyster::Math::Float3 cameraPos = up + pos + objForward;
 	camera->SetPosition(cameraPos);
 
@@ -282,25 +360,28 @@ GameClientState::ClientState GameState::Update(float deltaTime, InputClass* KeyI
 bool GameState::Render()
 {
 	Oyster::Graphics::API::SetView(camera->View());
-	//Oyster::Graphics::API::SetProjection(camera->Proj());
+
-	//Oyster::Graphics::API::SetView(privData->view);
-	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();
 	delete privData->object[i];
 	privData->object[i] = NULL;
-	}
+	}*/
 
 	delete privData;  
 	privData = NULL;
@@ -355,7 +436,7 @@ void GameState::readKeyInput(InputClass* KeyInput)
 
 
 	//send delta mouse movement 
-	if (KeyInput->IsMousePressed())
+	//if (KeyInput->IsMousePressed())
 	{
 		camera->Yaw(-KeyInput->GetYaw());
 		camera->Pitch(KeyInput->GetPitch());
@@ -440,13 +521,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 )
@@ -457,22 +542,24 @@ 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);
 
-			if(pos->object_ID == myId) // playerobj
-			{
-				//printf("Move message recieved!");
-				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();
+			//dynamicObjects[i]->setPos(Float3(world[12], world[13], world[14]));
-				Oyster::Math::Float3 cameraUp = camera->GetUp();
+			dynamicObjects[i]->setWorld(world);
+
+			if(dynamicObjects[i]->GetId() == myId) // playerobj
+			{
+				Float3 right =		Float3(world[0], world[1], world[2]);
+				Float3 up =			Float3(world[4], world[5], world[6]);
+				Float3 objForward = Float3(world[8], world[9], world[10]);
+				Float3 pos =		Float3(world[12], world[13], world[14]);
+
+				Float3 cameraLook = camera->GetLook();
+				Float3 cameraUp = camera->GetUp();
 				
 			
 
@@ -482,16 +569,16 @@ void GameState::Protocol( ObjPos* pos )
 				Oyster::Math::Float3 newLook = up.Cross(right);
 				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();
 			}
 		}
 	}
@@ -507,28 +594,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

@@ -4,6 +4,11 @@
 #include "OysterMath.h"
 #include <string>
 #include "Camera.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
@@ -30,12 +35,16 @@ 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();

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

@@ -54,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"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;
 }

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;
+
-	privData->object[0] = new C_DynamicObj();
+	modelData.position = Oyster::Math::Float3(2,2,2);
+	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;
 }

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/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);
 	}
 	
@@ -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

@@ -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;
 }
@@ -98,14 +99,18 @@ bool Game::NewFrame()
 		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->level->level->dynamicObjects.Size(); i++)
+	{
+		gameInstance.onMoveFnc(this->level->level->dynamicObjects[i]);
 	}
 	
-	//gameInstance.onMoveFnc(this->level);
 
 	return true;
 }
@@ -132,9 +137,9 @@ void Game::SetSubscription(GameEvent::ObjectDisabledFunction functionPointer)
 
 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);
+	//API::Instance().SetFrameTimeLength(this->frameTime);
 	this->initiated = true;
 	return true;
 }

Code/Game/GameLogic/Game.h

@@ -36,6 +36,8 @@ namespace GameLogic
 			int GetTeamID() const									override;
 			PLAYER_STATE GetState() const							override;
 			Oyster::Math::Float3 GetPosition()						override;
+			Oyster::Math::Quaternion GetRotation()					override;
+			Oyster::Math::Float3 GetScale()							override;
 			Oyster::Math::Float4x4 GetOrientation()					override; 
 			int GetID() const										override;
 			OBJECT_TYPE GetObjectType()	const						override;
@@ -50,6 +52,8 @@ namespace GameLogic
 			LevelData();
 			~LevelData();
 			Oyster::Math::Float3 GetPosition()						override;
+			Oyster::Math::Quaternion GetRotation()					override;
+			Oyster::Math::Float3 GetScale()							override;
 			Oyster::Math::Float4x4 GetOrientation()					override; 
 			int GetID() const										override;
 			OBJECT_TYPE GetObjectType()	const						override;

Code/Game/GameLogic/GameAPI.h

@@ -36,10 +36,22 @@ namespace GameLogic
 		public:
 			/********************************************************
 			* Gets players position
-			* @param playerID: ID of the player whos position you want
+			* @return Returns the players position
 			********************************************************/
 			virtual Oyster::Math::Float3 GetPosition() = 0;
 
+			/********************************************************
+			* Gets players rotation as quaternion
+			* @return Returns a quaternion
+			********************************************************/
+			virtual Oyster::Math::Quaternion GetRotation() = 0;
+
+			/********************************************************
+			* Gets players position
+			* @return Returns the player scale
+			********************************************************/
+			virtual Oyster::Math::Float3 GetScale() = 0;
+
 			/********************************************************
 			* Gets players current orientation
 			* @param playerID: ID of the player whos position you want

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

@@ -20,6 +20,14 @@ Oyster::Math::Float3 Game::LevelData::GetPosition()
 	//return this->level->GetCenter();
 	return Oyster::Math::Float3();
 }
+Oyster::Math::Quaternion Game::LevelData::GetRotation()
+{
+	return Oyster::Math::Quaternion();
+}
+Oyster::Math::Float3 Game::LevelData::GetScale()
+{
+	return Oyster::Math::Float3();
+}
 Oyster::Math::Float4x4 Game::LevelData::GetOrientation()
 {
 	//return this->level->GetOrientation();

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,628,-25);
-	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 = 60;
-	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)
 {
@@ -48,6 +48,14 @@ Oyster::Math::Float3 Game::PlayerData::GetPosition()
 {
 	return this->player->GetPosition();
 }
+Oyster::Math::Quaternion Game::PlayerData::GetRotation()
+{
+	return this->player->GetRotation();
+}
+Oyster::Math::Float3 Game::PlayerData::GetScale()
+{
+	return this->player->GetScale();
+}
 Oyster::Math::Float4x4 Game::PlayerData::GetOrientation()
 {
 	return this->player->GetOrientation();

Code/Game/GameLogic/Level.cpp

@@ -14,98 +14,138 @@ Level::Level(void)
 Level::~Level(void)
 {
 	delete this->levelObj;
-	this->levelObj = 0;
+	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;
+	int staticObjCount = 0;
+	int dynamicObjCount = 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;	
+
+				// collision shape
+				// radius, rotation in world, position in world, mass, restitution, static and dynamic friction
+				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);
+				
+				// add rigidbody to the logical obj
+				// Object::DefaultCollisionBefore, Object::DefaultCollisionAfter for now, gamelogic will take care of this
+				// set object_type to objID 
+				this->staticObjects.Push(new StaticObject(rigidBody,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+
+				this->staticObjects[staticObjCount]->objectID = modelCount++;
+				rigidBody->SetCustomTag(this->staticObjects[staticObjCount]);
+			}
+			break;
+		case ObjectType::ObjectType_Dynamic:
+			{
+				ObjectHeader* staticObjData = ((ObjectHeader*)obj);
+				staticObjData->ModelFile;
+
+				ICustomBody* rigidBody_Dynamic;			
+
+				rigidBody_Dynamic = 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);
+
+				this->dynamicObjects.Push(new DynamicObject(rigidBody_Dynamic,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
+				this->dynamicObjects[dynamicObjCount]->objectID = modelCount++;
+				rigidBody_Dynamic->SetCustomTag(this->dynamicObjects[dynamicObjCount]);
+			}
+			break;
+		case ObjectType::ObjectType_Light:
+			// read on client
+			break;
+		default:
+			break;
+		}
+	}
 }
 void Level::InitiateLevel(float radius)
 {
-	//float heading = Utility::Value::Radian(180.0f);
-	//float attitude = Utility::Value::Radian(0.0f);
-	//float bank = Utility::Value::Radian(0);
-	//
-	//double c1 = cos(heading/2);
-	//double s1 = sin(heading/2);
-	//double c2 = cos(attitude/2);
-	//double s2 = sin(attitude/2);
-	//double c3 = cos(bank/2);
-	//double s3 = sin(bank/2);
-	//double c1c2 = c1*c2;
-	//double s1s2 = s1*s2;
-	//double w =c1c2*c3 - s1s2*s3;
-	//double x =c1c2*s3 + s1s2*c3;
-	//double y =s1*c2*c3 + c1*s2*s3;
-	//double z =c1*s2*c3 - s1*c2*s3;
-	//double angle = 2 * acos(w);
-	//
-	//double norm = x*x+y*y+z*z;
-	//if (norm < 0.001) { // when all euler angles are zero angle =0 so
-	//	// we can set axis to anything to avoid divide by zero
-	//	x=1;
-	//	y=z=0;
-	//} else {
-	//	norm = sqrt(norm);
-	//	x /= norm;
-	//	y /= norm;
-	//	z /= norm;
-	//}
-
 	int idCount = 100;
-
+	// add level sphere
-// add level sphere
+	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);
-	API::SphericalBodyDescription sbDesc;
+	levelObj = new StaticObject(rigidBody, LevelCollisionBefore, LevelCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_WORLD);
-	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);
-	
-	this->levelObj = new StaticObject(rigidBody, LevelCollisionBefore, LevelCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_WORLD);
 	this->levelObj->objectID = idCount++;
-	rigidBody->SetCustomTag(this->levelObj);
+	rigidBody->SetCustomTag(levelObj);
-	
-/*
-// 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;
 
 	int nrOfBoxex = 5;
 	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);
 
-		DynamicObject *box = new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX);
+		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox,Object::DefaultCollisionBefore, Object::DefaultCollisionAfter, OBJECT_TYPE::OBJECT_TYPE_BOX));
-		box->objectID = idCount++;
+		this->dynamicObjects[i]->objectID = idCount++;
-		this->dynamicObjects.Push(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().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);
-		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 ++)
+	{
+		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]);	
@@ -113,64 +153,24 @@ void Level::InitiateLevel(float radius)
 	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().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);
-		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]);
+		rigidBody_TestBox->SetCustomTag(this->dynamicObjects[i]);
-	}
-	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);
+
-	DynamicObject *cry = 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));
-	cry->objectID = idCount++;
-	this->dynamicObjects.Push(cry);
 	rigidBody_Crystal->SetCustomTag(this->dynamicObjects[nrOfBoxex]);
-
+	// add 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);
-// add house
-	API::SimpleBodyDescription sbDesc_House;
-	//sbDesc_House.centerPosition = Oyster::Math::Float4(212, 212, 0, 0);
-	sbDesc_House.centerPosition = Oyster::Math::Float4(-50, 290, 0, 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)

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,6 +37,16 @@ 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;

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);
@@ -45,11 +46,6 @@ namespace GameLogic
 			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);
 
@@ -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);
 
+			start = 0;
 			LevelLoaderInternal::FormatVersion version;
-			memcpy(&version, &buffer[0], sizeof(version));
+			memcpy(&version, &buf[0], sizeof(version));
+			start += 4;
 
-			memcpy(&volume.geoType, &buf[8], sizeof(volume.geoType));
+			memcpy(&volume.geoType, &buf[start], sizeof(volume.geoType));
-			//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,84 +15,54 @@ 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();
-	this->currPhysicsState = this->rigidBody->GetState();
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 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();
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 Object::Object(Oyster::Physics::ICustomBody *rigidBody, OBJECT_TYPE type)
 {
-	Oyster::Physics::API::Instance().AddObject(rigidBody);
 	this->rigidBody = rigidBody;
 	this->type = type;
 	this->objectID = GID();
-	this->currPhysicsState = this->rigidBody->GetState();
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 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();
-	this->currPhysicsState = this->rigidBody->GetState();
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 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();
-	this->currPhysicsState = this->rigidBody->GetState();
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 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;
 	this->objectID = GID();
-	this->currPhysicsState = this->rigidBody->GetState();
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 void Object::ApplyLinearImpulse(Oyster::Math::Float3 force)
 {
-	newPhysicsState.ApplyLinearImpulse(force);
+	
 }
 
 
@@ -118,84 +88,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))
 {
@@ -206,7 +109,19 @@ Oyster::Math::Float3 Object::GetPosition()
 {
 	Oyster::Physics::ICustomBody::State state; 
 	state = this->rigidBody->GetState();
-	return state.GetCenterPosition();
+	return state.centerPos;
+}
+Oyster::Math::Quaternion Object::GetRotation() 
+{
+	Oyster::Physics::ICustomBody::State state; 
+	state = this->rigidBody->GetState();
+	return state.quaternion;
+}
+Oyster::Math::Float3 Object::GetScale() 
+{
+	Oyster::Physics::ICustomBody::State state; 
+	state = this->rigidBody->GetState();
+	return Float3();
 }
 Oyster::Math::Float4x4 Object::GetOrientation() 
 {

Code/Game/GameLogic/Object.h

@@ -25,12 +25,14 @@ namespace GameLogic
 		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);
 		~Object(void);
 
-		// API overrides
+		OBJECT_TYPE GetObjectType() const			override;
-		OBJECT_TYPE GetObjectType() const;
+		int GetID() const							override;
-		int GetID() const;
+		Oyster::Math::Float3 GetPosition()			override;
-		Oyster::Math::Float3 GetPosition();
+		Oyster::Math::Quaternion GetRotation()		override;
-		Oyster::Math::Float4x4 GetOrientation();
+		Oyster::Math::Float3 GetScale()				override;
+		Oyster::Math::Float4x4 GetOrientation()		override;
 
+		void setID(int id);
 
 		Oyster::Physics::ICustomBody* GetRigidBody();
 		void ApplyLinearImpulse(Oyster::Math::Float3 force);
@@ -44,14 +46,12 @@ 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);
 	
-	public: //TODO: Hax This should be private when level is dynamic
+	public: //HACK: This should be private when level is dynamic
 		OBJECT_TYPE type;
 		int objectID;
 
 	protected:
 		Oyster::Physics::ICustomBody *rigidBody;
-		Oyster::Physics::ICustomBody::State newPhysicsState;
-		Oyster::Physics::ICustomBody::State currPhysicsState;
 
 		static const Game* gameInstance;
 		Oyster::Math::Float3 currLook;

Code/Game/GameLogic/Player.cpp

@@ -70,12 +70,11 @@ void Player::EndFrame()
 	Object::EndFrame();
 	// rotate 
 
-	Oyster::Math::Float3 up = currPhysicsState.GetOrientation().v[1];
+	//Oyster::Math::Float3 up = currPhysicsState.GetOrientation().v[1];
-	Oyster::Math::Float3 deltaAxis = up * (-dx * 0.02) ;
+	//Oyster::Math::Float3 deltaAxis = up * (-dx * 0.02) ;
+
+	//currPhysicsState.AddRotation(deltaAxis);
 	
-	currPhysicsState.AddRotation(deltaAxis);
-	dx = 0; 
-	this->newPhysicsState = this->currPhysicsState;
 }
 
 void Player::Move(const PLAYER_MOVEMENT &movement)
@@ -106,32 +105,32 @@ void Player::Move(const PLAYER_MOVEMENT &movement)
 
 void Player::MoveForward()
 {
-	Oyster::Math::Float3 forward = currPhysicsState.GetOrientation().v[2];
+	Oyster::Math::Float3 forward = this->rigidBody->GetState().GetOrientation().v[2];
 	//Oyster::Math::Float3 forward = lookDir;
-	newPhysicsState.ApplyLinearImpulse(forward * (MOVE_FORCE * this->gameInstance->GetFrameTime()));
+	rigidBody->SetLinearVelocity( 10 * forward.GetNormalized() );
 }
 void Player::MoveBackwards()
 {
-	Oyster::Math::Float3 forward = currPhysicsState.GetOrientation().v[2];
+	Oyster::Math::Float3 forward = this->rigidBody->GetState().GetOrientation().v[2];
 	//Oyster::Math::Float3 forward = lookDir;
-	newPhysicsState.ApplyLinearImpulse(-forward * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	rigidBody->SetLinearVelocity( 10 * -forward.GetNormalized() );
 }
 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 = this->rigidBody->GetState().GetOrientation().v[2];
-	//Oyster::Math::Float3 forward = lookDir;
-	Oyster::Math::Float3 r = (-currPhysicsState.GetGravityNormal()).Cross(forward);
-	newPhysicsState.ApplyLinearImpulse(-r * MOVE_FORCE * this->gameInstance->GetFrameTime());
 
+	//Oyster::Math::Float3 forward = lookDir;
+	Oyster::Math::Float3 r = (-this->rigidBody->GetState().centerPos.Normalize()).Cross(forward);
+	rigidBody->SetLinearVelocity(r * 10);
 }
 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 = this->rigidBody->GetState().GetOrientation().v[2];
 	//Oyster::Math::Float3 forward = lookDir;
-	Oyster::Math::Float3 r = (-currPhysicsState.GetGravityNormal()).Cross(forward);	//Still get zero
+	Oyster::Math::Float3 r = (-this->rigidBody->GetState().centerPos.Normalize()).Cross(forward);
-	newPhysicsState.ApplyLinearImpulse(r * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	rigidBody->SetLinearVelocity(-r * 10);
 }
 
 void Player::UseWeapon(const WEAPON_FIRE &usage)
@@ -144,7 +143,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)
@@ -161,8 +160,8 @@ void Player::Rotate(const Oyster::Math3D::Float4 lookDir)
 
 void Player::Jump()
 {
-	Oyster::Math::Float3 up = currPhysicsState.GetOrientation().v[1];
+	Oyster::Math::Float3 up = this->rigidBody->GetState().GetOrientation().v[1];
-	newPhysicsState.ApplyLinearImpulse(up * MOVE_FORCE * this->gameInstance->GetFrameTime());
+	//newPhysicsState.ApplyLinearImpulse(up * MOVE_FORCE * this->gameInstance->GetFrameTime());
 }
 
 bool Player::IsWalking()
@@ -180,11 +179,11 @@ bool Player::IsIdle()
 
 Oyster::Math::Float3 Player::GetPosition() const
 {
-	return (Oyster::Math::Float3)currPhysicsState.GetCenterPosition();
+	return (Oyster::Math::Float3) this->rigidBody->GetState().centerPos;
 }
 Oyster::Math::Float4x4 Player::GetOrientation() const 
 {
-	return this->currPhysicsState.GetOrientation();
+	return this->rigidBody->GetState().GetOrientation();
 }
 Oyster::Math::Float3 Player::GetLookDir() const
 {

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/GameProtocols/ObjectProtocols.h

@@ -288,6 +288,76 @@ namespace GameLogic
 		Oyster::Network::CustomNetProtocol protocol;
 	};
 	
+	struct Protocol_ObjectPositionRotation :public Oyster::Network::CustomProtocolObject
+	{
+		short object_ID;
+		float position[3]; 
+		float rotation[3]; 
+		
+		Protocol_ObjectPositionRotation()
+		{
+			this->protocol[0].value = protocol_Gameplay_ObjectPositionRotation;
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;		
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
+		//POSITION	
+			this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[4].type = Oyster::Network::NetAttributeType_Float;
+		//ROTATION
+			this->protocol[5].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[6].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[7].type = Oyster::Network::NetAttributeType_Float;
+
+			this->object_ID = 0;
+			memset(&this->position[0], 0, sizeof(float) * 3);
+			memset(&this->rotation[0], 0, sizeof(float) * 3);
+		}
+		Protocol_ObjectPositionRotation(Oyster::Network::CustomNetProtocol& p)
+		{
+			this->object_ID = p[1].value.netShort;
+		//POSITION
+			this->position[0] = p[2].value.netFloat;
+			this->position[1] = p[3].value.netFloat;
+			this->position[2] = p[4].value.netFloat;
+		//ROTATION
+			this->rotation[0] = p[5].value.netFloat;
+			this->rotation[1] = p[6].value.netFloat;
+			this->rotation[2] = p[7].value.netFloat;
+		}
+		Protocol_ObjectPositionRotation(float p[3], float r[3], int id)
+		{
+			this->protocol[0].value = protocol_Gameplay_ObjectPositionRotation;
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
+		//POSITION
+			this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[4].type = Oyster::Network::NetAttributeType_Float;
+		//ROTATION
+			this->protocol[5].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[6].type = Oyster::Network::NetAttributeType_Float;
+			this->protocol[7].type = Oyster::Network::NetAttributeType_Float;
+
+			object_ID = id;
+			memcpy(&this->position[0], &p[0], sizeof(float) * 3);
+			memcpy(&this->rotation[0], &r[0], sizeof(float) * 3);
+		}
+		Oyster::Network::CustomNetProtocol GetProtocol() override
+		{
+			this->protocol[1].value = this->object_ID;
+			this->protocol[2].value = this->position[0];
+			this->protocol[3].value = this->position[1];
+			this->protocol[4].value = this->position[2];
+			this->protocol[5].value = this->rotation[0];
+			this->protocol[6].value = this->rotation[1];
+			this->protocol[7].value = this->rotation[2];
+			return protocol;		 
+		}	
+
+	private:
+		Oyster::Network::CustomNetProtocol protocol;
+	};
+
 	//#define protocol_Gameplay_ObjectEnabled			356
 	struct Protocol_ObjectEnable :public Oyster::Network::CustomProtocolObject
 	{

Code/Game/GameProtocols/ProtocolIdentificationID.h

@@ -56,17 +56,17 @@
 #define protocol_Gameplay_ObjectPosition			353
 #define protocol_Gameplay_ObjectScale				354
 #define protocol_Gameplay_ObjectRotation			355
-#define protocol_Gameplay_ObjectEnabled				356
+#define protocol_Gameplay_ObjectPositionRotation	356
-#define protocol_Gameplay_ObjectDisabled			357
+#define protocol_Gameplay_ObjectEnabled				357
-#define protocol_Gameplay_ObjectCreate				358
+#define protocol_Gameplay_ObjectDisabled			358
-#define protocol_Gameplay_ObjectCreatePlayer		359
+#define protocol_Gameplay_ObjectCreate				359
-#define protocol_Gameplay_ObjectJoinTeam			360
+#define protocol_Gameplay_ObjectCreatePlayer		360
-#define protocol_Gameplay_ObjectLeaveTeam			361
+#define protocol_Gameplay_ObjectJoinTeam			361
-
+#define protocol_Gameplay_ObjectLeaveTeam			362
-#define protocol_Gameplay_ObjectWeaponCooldown		362
+#define protocol_Gameplay_ObjectWeaponCooldown		363
-#define protocol_Gameplay_ObjectWeaponEnergy		363
+#define protocol_Gameplay_ObjectWeaponEnergy		364
-#define protocol_Gameplay_ObjectRespawn				364
+#define protocol_Gameplay_ObjectRespawn				365
-#define protocol_Gameplay_ObjectDie					365
+#define protocol_Gameplay_ObjectDie					366
 #define protocol_GameplayMAX							399
 
 

Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp

@@ -94,54 +94,11 @@ namespace DanBias
 		//bandwidth.
 		//if( dt >= GameSession::gameSession->networkFrameTime )
 		//{
-			GameSession::gameSession->networkTimer.reset();
+		//	GameSession::gameSession->networkTimer.reset();
 			int id = movedObject->GetID();
-			Protocol_ObjectPosition p(movedObject->GetPosition(), id);
+			//Protocol_ObjectPosition p(movedObject->GetPosition(), id);
-			//if(id != 1)
+			Protocol_ObjectPositionRotation p(movedObject->GetPosition(), movedObject->GetRotation(), id);
 			GameSession::gameSession->Send(p.GetProtocol());
-
-
-			/*
-			if(dynamic_cast<GameLogic::ILevelData*>(obj))
-			{
-				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)
-					{
-						int id = obj->GetID();
-						Oyster::Math::Float4x4 world = obj->GetOrientation();
-						Protocol_ObjectPosition p(world, id);
-						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());
-					}
-				}
-			}
-			*/
 		//}
 		
 	}

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,296 +19,233 @@ 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 );
-					Float rSquared = d.Dot( d );
-					if( rSquared != 0.0 )
-					{
-						Float force = Physics3D::Formula::ForceField( this->gravityConstant, state.GetMass(), this->gravity[i].well.mass, rSquared );
-						gravityImpulse += (this->updateFrameLength * force / ::std::sqrt(rSquared)) * d;
-					}
-					break;
-				}
-			case Gravity::GravityType_Directed:
-				gravityImpulse += Float4( this->gravity[i].directed.impulse, 0.0f );
-				break;
-//			case Gravity::GravityType_DirectedField:
-//				//this->gravity[i].directedField.
-//				//! TODO: @todo rethink
-//				break;
-			default: break;
 		}
 	}
 
-		if( gravityImpulse != gravityImpulse ) // debug: trap
+	int numManifolds = this->dynamicsWorld->getDispatcher()->getNumManifolds();
-				const char *breakpoint = "This should never happen";
+	for (int i=0;i<numManifolds;i++)
-
-		if( gravityImpulse != Float4::null )
 	{
-			state.ApplyLinearImpulse( gravityImpulse.xyz );
+		btPersistentManifold* contactManifold =  this->dynamicsWorld->getDispatcher()->getManifoldByIndexInternal(i);
-			state.SetGravityNormal( gravityImpulse.GetNormalized().xyz );
+		const btCollisionObject* obA = contactManifold->getBody0();
-			(*proto)->SetState( state );
+		const btCollisionObject* obB = contactManifold->getBody1();
-		}
 
-		// Step 2: Apply Collision Response
+		ICustomBody* bodyA = (ICustomBody*)obA->getUserPointer();
-		this->worldScene.Visit( *proto, OnPossibleCollision );
+		ICustomBody* bodyB = (ICustomBody*)obB->getUserPointer();
-	}
 
-	proto = updateList.begin();
+		dynamic_cast<SimpleRigidBody*>(bodyA)->CallSubscription_AfterCollisionResponse(bodyA, bodyB, 0.0f);
-	for( ; proto != updateList.end(); ++proto )
+		dynamic_cast<SimpleRigidBody*>(bodyB)->CallSubscription_AfterCollisionResponse(bodyB, bodyA, 0.0f);
+
+		int numContacts = contactManifold->getNumContacts();
+		for (int j=0;j<numContacts;j++)
 		{
-		(*proto)->GetState( state );
+			btManifoldPoint& pt = contactManifold->getContactPoint(j);
-		Float3 lM = state.GetLinearMomentum();
+			if (pt.getDistance()<0.f)
-
-		//LinearAlgebra3D::InterpolateAxisYToNormal_UsingNlerp(state.SetOrientation(, Float4(state.GetGravityNormal(), 0.0f), 1.0f);
-
-
-		if( abs(lM.x) < this->epsilon )
 			{   
-			state.linearMomentum.x = 0;
+				const btVector3& ptA = pt.getPositionWorldOnA();
+				const btVector3& ptB = pt.getPositionWorldOnB();
+				const btVector3& normalOnB = pt.m_normalWorldOnB;
 			}
-		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 );
-//	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 Physics
+	{
 		namespace Default
 		{
 			void EventAction_Destruction( ::Utility::DynamicMemory::UniquePointer<::Oyster::Physics::ICustomBody> proto )
@@ -470,4 +264,5 @@ namespace Oyster { namespace Physics
 			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->onMovement = Default::EventAction_Move;
 
-	this->collisionRebound.previousSpatial.center = this->rigid.centerPos;
+	this->state.centerPos = Float3(0.0f, 0.0f, 0.0f);
-	this->collisionRebound.previousSpatial.axis = this->rigid.axis;
+	this->state.quaternion = Quaternion(Float3(0.0f, 0.0f, 0.0f), 1.0f);
-	this->collisionRebound.previousSpatial.reach = this->rigid.boundingReach;
+	this->state.dynamicFrictionCoeff = 0.0f;
-	this->collisionRebound.timeOfContact = 1.0f;
+	this->state.staticFrictionCoeff = 0.0f;
+	this->state.mass = 0.0f;
+	this->state.restitutionCoeff = 0.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();
+	delete this->motionState;
-	this->rigid.SetRotation( desc.rotation );
+	this->motionState = NULL;
-	this->rigid.centerPos				= desc.centerPosition;
+	delete this->collisionShape;
-	this->rigid.SetSize( desc.size );
+	this->collisionShape = NULL;
-	this->rigid.restitutionCoeff		= desc.restitutionCoeff;
+	delete this->rigidBody;
-	this->rigid.frictionCoeff_Static	= desc.frictionCoeff_Static;
+	this->rigidBody = NULL;
-	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 );
 }
 
 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 
 { 
+	namespace Physics
+	{
 		class SimpleRigidBody : public ICustomBody
 		{
 		public:
 			SimpleRigidBody();
-		SimpleRigidBody( const API::SimpleBodyDescription &desc );
 			virtual ~SimpleRigidBody();
 
-		::Utility::DynamicMemory::UniquePointer<ICustomBody> Clone() const;
-		
 			State GetState() const;
-		State & GetState( State &targetMem ) const;
+			State& GetState( State &targetMem ) const;
 			void SetState( const State &state );
-		//::Oyster::Math::Float3 GetRigidLinearVelocity() const;
 
-		SubscriptMessage CallSubscription_BeforeCollisionResponse( const ICustomBody *deuter );
+			void SetCollisionShape(btCollisionShape* shape);
-		void CallSubscription_AfterCollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
+			void SetMotionState(btDefaultMotionState* motionState);
+			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();
 
-		bool IsAffectedByGravity() const;
+			btCollisionShape* GetCollisionShape() const;
-		bool Intersects( const ::Oyster::Collision3D::ICollideable &shape ) const;
+			btDefaultMotionState* GetMotionState() const;
-		bool Intersects( const ::Oyster::Collision3D::ICollideable &shape, ::Oyster::Math::Float4 &worldPointOfContact ) const;
+			btRigidBody* GetRigidBody() 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* GetCustomTag() const;
-		//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;
+			btCollisionShape* collisionShape;
-		::Oyster::Math::Float4 deltaPos, deltaAxis;
+			btDefaultMotionState* motionState;
-		::Oyster::Math::Float3 gravityNormal;
+			btRigidBody* rigidBody;
 
-		struct
+			Struct::CustomBodyState state;
-		{
-			struct { ::Oyster::Math::Float3 center, axis, reach; } previousSpatial;
-			::Oyster::Math::Float timeOfContact;
-		} collisionRebound;
 
-		EventAction_BeforeCollisionResponse onCollision;
+			EventAction_AfterCollisionResponse afterCollision;
-		EventAction_AfterCollisionResponse onCollisionResponse;
 			EventAction_Move onMovement;
 
-		Octree *scene;
 			void *customTag;
-		bool ignoreGravity, isForwarded;
 		};
-} }
+	} 
+}
 
 #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,489 +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::ApplyFriction( const ::Oyster::Math::Float3 &j )
-			{
-				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,212 +5,40 @@
 #include "PhysicsAPI.h"
 #include "Inertia.h"
 
-namespace Oyster { namespace Physics
+namespace Oyster 
 { 
+	namespace Physics
+	{
 		namespace Struct
 		{
-		struct SimpleBodyDescription
-		{
-			::Oyster::Math::Float3 rotation;
-			::Oyster::Math::Float3 centerPosition;
-			::Oyster::Math::Float3 size;
-			::Oyster::Math::Float mass;
-			::Oyster::Math::Float restitutionCoeff;
-			::Oyster::Math::Float frictionCoeff_Static;
-			::Oyster::Math::Float frictionCoeff_Dynamic;
-			::Oyster::Physics3D::MomentOfInertia inertiaTensor;
-			::Oyster::Physics::ICustomBody::EventAction_BeforeCollisionResponse subscription_onCollision;
-			::Oyster::Physics::ICustomBody::EventAction_AfterCollisionResponse subscription_onCollisionResponse;
-			::Oyster::Physics::ICustomBody::EventAction_Move subscription_onMovement;
-			bool ignoreGravity;
-
-			SimpleBodyDescription();
-		};
-
-		struct SphericalBodyDescription
-		{
-			::Oyster::Math::Float3 rotation;
-			::Oyster::Math::Float3 centerPosition;
-			::Oyster::Math::Float radius;
-			::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:
+				// Default constructor
 				CustomBodyState( ::Oyster::Math::Float mass						= 1.0f,
-							 ::Oyster::Math::Float restitutionCoeff			= 1.0f,
+								 ::Oyster::Math::Float restitutionCoeff			= 0.5f,
 								 ::Oyster::Math::Float staticFrictionCoeff		= 1.0f,
-							 ::Oyster::Math::Float kineticFrictionCoeff		= 1.0f,
+								 ::Oyster::Math::Float dynamicFrictionCoeff		= 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::Quaternion &quaternion	= ::Oyster::Math::Quaternion(::Oyster::Math::Float3(0, 0, 0), 1));
-							 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);
 
+				// Assignment operator
 				CustomBodyState & operator = ( const CustomBodyState &state );
 
-			const ::Oyster::Math::Float		 GetMass() const;
+				// Get functions that calculate matrices that do not exist as variables
-			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 CustomBodyState::ApplyFriction( const ::Oyster::Math::Float3 &j);
-			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/EventHandler/EventButton.h

@@ -0,0 +1,261 @@
+///////////////////////
+// Sam Svensson 2013 //
+///////////////////////
+
+#ifndef MISC_EVENT_BUTTON_H
+#define MISC_EVENT_BUTTON_H
+
+#include "IEventButton.h"
+
+namespace Oyster
+{
+	namespace Event
+	{
+		template <typename Owner>
+		struct ButtonEvent
+		{
+			ButtonState state;
+			IEventButton* sender;
+			Owner owner;
+			void* userData;
+		};
+
+		template <typename Owner>
+		class EventButton : public IEventButton
+		{
+		protected:
+			//typedef for callback function pointer
+			typedef void (*EventFunc)(Oyster::Event::ButtonEvent<Owner>& e);
+
+			struct PrivData
+			{
+				PrivData() : ID(currID++){}
+
+				static unsigned int currID;
+				const unsigned int ID;
+
+				ButtonState previousState;
+				Owner owner;
+				EventFunc eventCallback;
+				void* userData;
+				bool enabled;
+			};
+			
+			
+			PrivData privData;
+
+		private:
+			//Implement this in the inherited classes for collision against that shape.
+			virtual bool Collision(InputClass *input) = 0;
+
+		public:
+			EventButton();
+			EventButton(Owner owner);
+			EventButton(EventFunc func);
+			EventButton(EventFunc func, Owner owner);
+			EventButton(EventFunc func, Owner owner, void* userData);
+			~EventButton();
+
+			void Update(InputClass *input);
+
+			//Send event to callback function
+			void SendEvent(ButtonState state);
+			
+			//Set
+			void SetUserData(void* data);
+			void SetEventFunc(EventFunc func);
+			void SetOwner(Owner owner);
+			
+			//Get
+			bool Enabled();
+			unsigned int GetID();
+			//EventFunc GetFunctionPointer();
+			Owner GetOwner();
+
+			bool operator ==(const EventButton<Owner>& obj);
+
+		};
+		
+		template <typename Owner>
+		unsigned int EventButton<Owner>::PrivData::currID = 0;
+
+		template <typename Owner>
+		EventButton<Owner>::EventButton()
+		{
+			this->privData.eventCallback = NULL;
+			this->privData.userData = NULL;
+			this->privData.previousState = ButtonState_None;
+			this->privData.enabled = true;
+		}
+
+		template <typename Owner>
+		EventButton<Owner>::EventButton(Owner owner)
+		{
+			this->privData.owner = owner;
+			this->privData.eventCallback = NULL;
+			this->privData.userData = NULL;
+			this->privData.previousState = ButtonState_None;
+			this->privData.enabled = true;
+		}
+
+		template <typename Owner>
+		EventButton<Owner>::EventButton(EventFunc func)
+		{
+			this->privData.eventCallback = func;
+			this->privData.userData = NULL;
+			this->privData.previousState = ButtonState_None;
+			this->privData.enabled = true;
+		}
+
+		template <typename Owner>
+		EventButton<Owner>::EventButton(EventFunc func, Owner owner)
+		{
+			this->privData.owner = owner;
+			this->privData.eventCallback = func;
+			this->privData.userData = NULL;
+			this->privData.previousState = ButtonState_None;
+			this->privData.enabled = true;
+		}
+		
+		template <typename Owner>
+		EventButton<Owner>::EventButton(EventFunc func, Owner owner, void* userData)
+		{
+			this->privData.owner = owner;
+			this->privData.eventCallback = func;
+			this->privData.userData = userData;
+			this->privData.previousState = ButtonState_None;
+			this->privData.enabled = true;
+		}
+
+		template <typename Owner>
+		EventButton<Owner>::~EventButton()
+		{}
+		
+		//Checks for collision and 
+		template <typename Owner>
+		void EventButton<Owner>::Update(InputClass *input)
+		{
+			if(this->privData.enabled)
+			{
+				ButtonState currentState = ButtonState_None;
+
+				if(Collision(input))
+				{
+					if(input->IsMousePressed())
+					{
+						//Change state when the mouse button is pressed
+						switch(this->privData.previousState)
+						{
+						case ButtonState_None:
+							currentState = ButtonState_Hover;
+							break;
+
+						case ButtonState_Hover:
+						case ButtonState_Released:
+							currentState = ButtonState_Pressed;
+							break;
+
+						case ButtonState_Pressed:
+						case ButtonState_Down:
+							currentState = ButtonState_Down;
+							break;
+						default:
+							break;
+						}
+					}
+					else
+					{
+						//Change state when the mouse button is NOT pressed
+						switch(this->privData.previousState)
+						{
+						case ButtonState_None:
+						case ButtonState_Hover:
+						case ButtonState_Released:
+							currentState = ButtonState_Hover;
+							break;
+
+						case ButtonState_Pressed:
+						case ButtonState_Down:
+							currentState = ButtonState_Released;
+							break;
+						default:
+							break;
+						}
+					}
+				}
+
+				//Only call the callback function when the state has changed.
+				if(this->privData.previousState != currentState)
+					SendEvent(currentState);
+
+				this->privData.previousState = currentState;
+			}
+		}
+
+		template <typename Owner>
+		void EventButton<Owner>::SendEvent(ButtonState state)
+		{
+			if(privData.eventCallback != NULL)
+			{
+				Oyster::Event::ButtonEvent<Owner> event;
+				event.state = state;
+				event.sender = this;
+				event.owner = privData.owner;
+				event.userData = privData.userData;
+				privData.eventCallback(event);
+			}
+		}
+		
+		template <typename Owner>
+		void EventButton<Owner>::SetUserData(void* data)
+		{
+			this->privData.userData = data;
+		}
+
+		template <typename Owner>
+		void EventButton<Owner>::SetEventFunc(EventFunc func)
+		{
+			this->privData.EventFunc = EventFunc;
+		}
+
+		template <typename Owner>
+		void EventButton<Owner>::SetOwner(Owner owner)
+		{
+			this->privData.owner = owner;
+		}
+		
+		template <typename Owner>
+		bool EventButton<Owner>::Enabled()
+		{
+			return this->privData.enabled;
+		}
+
+		template <typename Owner>
+		unsigned int EventButton<Owner>::GetID()
+		{
+			return this->privData.ID;
+		}
+
+		/* Something is wrong, can't return EventFunc
+		template <typename Owner>
+		EventFunc EventButton<Owner>::GetFunctionPointer()
+		{
+			return this->privData.eventCallback;
+		}*/
+
+		template <typename Owner>
+		Owner EventButton<Owner>::GetOwner()
+		{
+			return this->privData.owner;
+		}
+		
+		template <typename Owner>
+		bool EventButton<Owner>::operator ==(const EventButton<Owner>& obj)
+		{
+			return (this->privData.ID == obj.privData.ID);
+		}
+	}
+}
+
+
+#endif

Code/Misc/EventHandler/EventButtonCircle.h

@@ -0,0 +1,64 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#ifndef MISC_EVENT_BUTTON_CIRCLE_H
+#define MISC_EVENT_BUTTON_CIRCLE_H
+
+#include "EventButton.h"
+#include "../../Input/L_inputClass.h"
+
+namespace Oyster
+{
+	namespace Event
+	{
+		template <typename Owner>
+		class EventButtonCircle : public EventButton<Owner>
+		{
+		public:
+			EventButtonCircle() 
+				: EventButton(), xPos(0), yPos(0), radius(0)
+			{}
+			EventButtonCircle(Owner owner, float xPos, float yPos, float radius) 
+				: EventButton(owner), xPos(xPos), yPos(yPos), radius(radius)
+			{}
+			EventButtonCircle(void (*EventFunc)( Oyster::Event::ButtonEvent<Owner>& e), float xPos, float yPos, float radius) 
+				: EventButton(EventFunc), xPos(xPos), yPos(yPos), radius(radius)
+			{}
+			EventButtonCircle(void (*EventFunc)( Oyster::Event::ButtonEvent<Owner>& e), Owner owner, float xPos, float yPos, float radius) 
+				: EventButton(EventFunc, owner), xPos(xPos), yPos(yPos), radius(radius)
+			{}
+			EventButtonCircle(void (*EventFunc)( Oyster::Event::ButtonEvent<Owner>& e), Owner owner, void* userData, float xPos, float yPos, float radius) 
+				: EventButton(EventFunc, owner, userData), xPos(xPos), yPos(yPos), radius(radius)
+			{}
+			~EventButtonCircle()
+			{}
+
+			//Circle vs point collision
+			bool Collision(InputClass* inputObject)
+			{
+				//Should come from the InputClass
+				float xMouse = 2, yMouse = 2;
+
+				float xDiff = xMouse - xPos;
+				float yDiff = yMouse - yPos;
+
+				float length = (xDiff * xDiff) + (yDiff * yDiff);
+
+				if(length <= radius*radius)
+				{
+					return true;
+				}
+
+				return false;
+			}
+
+		private:
+			float xPos, yPos;
+			float radius;
+
+		};
+	}
+}
+
+#endif

Code/Misc/EventHandler/EventButtonCollection.cpp

@@ -0,0 +1,51 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#include "EventButtonCollection.h"
+
+#include "../../Input/L_inputClass.h"
+
+using namespace Oyster::Event;
+
+EventButtonCollection::EventButtonCollection() 
+	: collectionState(EventCollectionState_Enabled)
+{
+}
+
+EventButtonCollection::~EventButtonCollection()
+{
+	int size = buttons.size();
+	for(int i = 0; i < size; i++)
+	{
+		delete buttons[i];
+		buttons[i] = NULL;
+	}
+}
+
+void EventButtonCollection::Update(InputClass* inputObject)
+{
+	if(this->collectionState == EventCollectionState_Enabled)
+	{
+		for(int i = 0; i < (int)buttons.size(); i++)
+		{
+			buttons[i]->Update(inputObject);
+		}
+	}
+}
+
+EventCollectionState EventButtonCollection::GetState() const
+{
+	return collectionState;
+}
+
+void EventButtonCollection::SetState(const EventCollectionState state)
+{
+	collectionState = state;
+}
+
+void EventButtonCollection::Clear()
+{
+	buttons.clear();
+	collectionState = EventCollectionState_Enabled;
+}

Code/Misc/EventHandler/EventButtonCollection.h

@@ -0,0 +1,58 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#ifndef MISC_EVENT_BUTTON_COLLECTION_H
+#define MISC_EVENT_BUTTON_COLLECTION_H
+
+#include "../../Input/L_inputClass.h"
+
+#include "../DynamicArray.h"
+
+#include "IEventButton.h"
+#include "EventButton.h"
+
+#include <vector>
+
+namespace Oyster
+{
+	namespace Event
+	{
+		enum EventCollectionState
+		{
+			EventCollectionState_Disabled,
+			EventCollectionState_Enabled,
+
+			EventCollectionState_Count,
+			EventCollectionState_Unknown = -1,
+		};
+
+		class EventButtonCollection
+		{
+		public:
+			EventButtonCollection();
+			~EventButtonCollection();
+
+			void Update(InputClass* inputObject);
+
+			template <typename Owner>
+			void AddButton(EventButton<Owner>* button)
+			{
+				buttons.push_back(button);
+			}
+
+			EventCollectionState GetState() const;
+			void SetState(const EventCollectionState state);
+
+			//Clear all buttons and reset the state.
+			void Clear();
+
+		private:
+			std::vector<IEventButton*> buttons;
+			EventCollectionState collectionState;
+
+		};
+	}
+}
+
+#endif

Code/Misc/EventHandler/EventButtonRectangle.h

@@ -0,0 +1,60 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#ifndef MISC_EVENT_BUTTON_RECTANGLE_H
+#define MISC_EVENT_BUTTON_RECTANGLE_H
+
+#include "EventButton.h"
+#include "../../Input/L_inputClass.h"
+
+namespace Oyster
+{
+	namespace Event
+	{
+		template <typename Owner>
+		class EventButtonRectangle : public EventButton<Owner>
+		{
+		public:
+			EventButtonRectangle() 
+				: EventButton(), xPos(0), yPos(0), halfWidth(0), halfHeight(0)
+			{}
+			EventButtonRectangle(Owner owner, float xPos, float yPos, float halfWidth, float halfHeight) 
+				: EventButton(owner), xPos(xPos), yPos(yPos), halfWidth(halfWidth), halfHeight(halfHeight)
+			{}
+			EventButtonRectangle(void (*EventFunc)( Oyster::Event::ButtonEvent<Owner>& e), float xPos, float yPos, float halfWidth, float halfHeight) 
+				: EventButton(EventFunc), xPos(xPos), yPos(yPos), halfWidth(halfWidth), halfHeight(halfHeight)
+			{}
+			EventButtonRectangle(void (*EventFunc)( Oyster::Event::ButtonEvent<Owner>& e), Owner owner, float xPos, float yPos, float halfWidth, float halfHeight) 
+				: EventButton(EventFunc, owner), xPos(xPos), yPos(yPos), halfWidth(halfWidth), halfHeight(halfHeight)
+			{}
+			EventButtonRectangle(void (*EventFunc)( Oyster::Event::ButtonEvent<Owner>& e), Owner owner, void* userData, float xPos, float yPos, float halfWidth, float halfHeight) 
+				: EventButton(EventFunc, owner, userData), xPos(xPos), yPos(yPos), halfWidth(halfWidth), halfHeight(halfHeight)
+			{}
+			~EventButtonRectangle()
+			{}
+
+			//Circle vs point collision
+			bool Collision(InputClass* inputObject)
+			{
+				//Should come from the InputClass
+				float xMouse = 1, yMouse = 0;
+
+				if(xMouse >= xPos - halfWidth && xMouse <= xPos + halfWidth
+					&& yMouse >= yPos - halfHeight && yMouse <= yPos + halfHeight)
+				{
+					return true;
+				}
+
+				return false;
+			}
+
+		private:
+			float xPos, yPos;
+			float halfWidth, halfHeight;
+
+		};
+	}
+}
+
+#endif

Code/Misc/EventHandler/EventHandler.cpp

@@ -0,0 +1,47 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#include "EventHandler.h"
+
+using namespace Oyster::Event;
+
+Oyster::Event::EventHandler EvtHandler;
+
+EventHandler& EventHandler::Instance()
+{
+	return EvtHandler;
+}
+
+EventHandler::EventHandler()
+{
+}
+
+EventHandler::~EventHandler()
+{
+	int size = collections.size();
+	for(int i = 0; i < size; i++)
+	{
+		delete collections[i];
+	}
+}
+
+void EventHandler::Update(InputClass* inputObject)
+{
+	for(int i = 0; i < (int)collections.size(); i++)
+	{
+		collections.at(i)->Update(inputObject);
+	}
+}
+
+void EventHandler::AddCollection(EventButtonCollection& collection)
+{
+	collections.push_back(&collection);
+}
+
+EventButtonCollection& EventHandler::CreateCollection()
+{
+	EventButtonCollection* temp = new EventButtonCollection;
+	collections.push_back(temp);
+	return *temp;
+}

Code/Misc/EventHandler/EventHandler.h

@@ -0,0 +1,41 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#ifndef MISC_EVENT_HANDLER_H
+#define MISC_EVENT_HANDLER_H
+
+#include "../../Input/L_inputClass.h"
+
+#include "EventButtonCollection.h"
+#include "EventButton.h"
+#include "EventButtonCircle.h"
+#include "EventButtonRectangle.h"
+
+#include <vector>
+
+namespace Oyster
+{
+	namespace Event
+	{
+		class EventHandler
+		{
+		public:
+			EventHandler();
+			~EventHandler();
+
+			static EventHandler& Instance();
+
+			void Update(InputClass* inputObject);
+
+			void AddCollection(EventButtonCollection& collection);
+			EventButtonCollection& CreateCollection();
+
+		private:
+			std::vector<EventButtonCollection*> collections;
+
+		};
+	}
+}
+
+#endif

Code/Misc/EventHandler/IEventButton.h

@@ -0,0 +1,41 @@
+//////////////////////////////////////
+// Created by Pontus Fransson 2014  //
+//////////////////////////////////////
+
+#ifndef MISC_IEVENT_BUTTON
+#define MISC_IEVENT_BUTTON
+
+class InputClass;
+
+namespace Oyster
+{
+	namespace Event
+	{
+		enum ButtonState
+		{
+			ButtonState_None,
+			ButtonState_Hover,
+			ButtonState_Pressed,
+			ButtonState_Down,
+			ButtonState_Released,
+		};
+
+		class IEventButton
+		{
+		public:
+			virtual ~IEventButton(){}
+
+			virtual void Update(InputClass *input){}
+
+			virtual void SendEvent(ButtonState state){}
+
+			struct ButtonEvent;
+			virtual void SetEventFunc(void (*EventFunc)( ButtonEvent e )){}
+			
+			virtual unsigned int GetID(){ return -1; }
+		
+		};
+	}
+}
+
+#endif

Code/Misc/Misc.vcxproj

@@ -146,6 +146,8 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="EventHandler\EventButtonCollection.cpp" />
+    <ClCompile Include="EventHandler\EventHandler.cpp" />
     <ClCompile Include="Packing\Packing.cpp" />
     <ClCompile Include="Resource\Loaders\ByteLoader.cpp" />
     <ClCompile Include="Resource\Loaders\CustomLoader.cpp" />
@@ -164,6 +166,12 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DynamicArray.h" />
+    <ClInclude Include="EventHandler\EventButton.h" />
+    <ClInclude Include="EventHandler\EventButtonCircle.h" />
+    <ClInclude Include="EventHandler\EventButtonCollection.h" />
+    <ClInclude Include="EventHandler\EventButtonRectangle.h" />
+    <ClInclude Include="EventHandler\EventHandler.h" />
+    <ClInclude Include="EventHandler\IEventButton.h" />
     <ClInclude Include="GID.h" />
     <ClInclude Include="IQueue.h" />
     <ClInclude Include="OysterCallback.h" />

Code/Misc/Misc.vcxproj.filters

@@ -51,6 +51,12 @@
     <ClCompile Include="Packing\Packing.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="EventHandler\EventButtonCollection.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="EventHandler\EventHandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Utilities.h">
@@ -116,5 +122,23 @@
     <ClInclude Include="Packing\Packing.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="EventHandler\EventButton.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="EventHandler\EventButtonCollection.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="EventHandler\EventHandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="EventHandler\IEventButton.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="EventHandler\EventButtonCircle.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="EventHandler\EventButtonRectangle.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Code/OysterPhysics3D/RigidBody.cpp

@@ -13,7 +13,7 @@ using namespace ::Utility::Value;
 RigidBody::RigidBody( )
 { // by Dan Andersson
 	this->centerPos = Float4::standard_unit_w;
-	this->axis = Float4::null;
+	this->quaternion = Quaternion(Float3(0, 0, 0), 1);
 	this->boundingReach = Float4( 0.5f, 0.5f, 0.5f, 0.0f );
 	this->momentum_Linear = Float4::null;
 	this->momentum_Angular = Float4::null;
@@ -24,13 +24,12 @@ RigidBody::RigidBody( )
 	this->frictionCoeff_Kinetic = 1.0f;
 	this->mass = 10;
 	this->momentOfInertiaTensor = MomentOfInertia();
-	this->rotation = Quaternion::identity;
 }
 
 RigidBody & RigidBody::operator = ( const RigidBody &body )
 { // by Dan Andersson
 	this->centerPos = body.centerPos;
-	this->axis = body.axis;
+	this->quaternion = body.quaternion;
 	this->boundingReach = body.boundingReach;
 	this->momentum_Linear = body.momentum_Linear;
 	this->momentum_Angular = body.momentum_Angular;
@@ -41,7 +40,6 @@ RigidBody & RigidBody::operator = ( const RigidBody &body )
 	this->frictionCoeff_Kinetic = body.frictionCoeff_Kinetic;
 	this->mass = body.mass;
 	this->momentOfInertiaTensor = body.momentOfInertiaTensor;
-	this->rotation = body.rotation;
 	return *this;
 }
 
@@ -55,19 +53,14 @@ void RigidBody::Update_LeapFrog( Float updateFrameLength )
 	this->momentum_Angular = this->momentum_Angular*0.99f;
 
 	// ds = dt * Formula::LinearVelocity( m, avg_G ) = dt * avg_G / m = (dt / m) * avg_G
-	Float3 delta = AverageWithDelta( this->momentum_Linear, this->impulse_Linear );
+	Float3 delta = this->momentum_Linear;
-	Float3 newPos = ( updateFrameLength)*this->momentum_Linear;
+	Float3 newPos = (updateFrameLength)*this->momentum_Linear;
 	this->centerPos += newPos;
 
-	if(this->mass == 70)
-	{
-		const char *breakpoint = "STOP";
-	}
-
 	// updating the angular
 	// dO = dt * Formula::AngularVelocity( (RI)^-1, avg_H ) = dt * (RI)^-1 * avg_H	
-	this->axis += updateFrameLength * this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, AverageWithDelta(this->momentum_Angular, this->impulse_Angular) );
+	/*this->axis += updateFrameLength*this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, this->momentum_Angular );
-	this->rotation = Rotation( this->axis );
+	this->rotation = Rotation( this->axis );*/
 
 	// update momentums and clear impulse_Linear and impulse_Angular
 	this->momentum_Linear += this->impulse_Linear;
@@ -89,14 +82,14 @@ void RigidBody::Predict_LeapFrog( Float3 &outDeltaPos, Float3 &outDeltaAxis, con
 
 	// dO = dt * Formula::AngularVelocity( (RI)^-1, avg_H ) = dt * (RI)^-1 * avg_H
 	//outDeltaAxis = Formula::AngularVelocity( wMomentOfInertiaTensor.GetInverse(), AverageWithDelta(this->momentum_Angular, actingAngularImpulse) );
-	outDeltaAxis = this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, AverageWithDelta(this->momentum_Angular, this->impulse_Angular) );
+	//utDeltaAxis = this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, AverageWithDelta(this->momentum_Angular, this->impulse_Angular) );
 }
 
 void RigidBody::Move( const Float3 &deltaPos, const Float3 &deltaAxis )
 {
-	this->centerPos += deltaPos;
+	//this->centerPos += deltaPos;
-	this->axis += deltaAxis;
+	//this->axis += deltaAxis;
-	this->rotation = Rotation( this->axis );
+	//this->rotation = Rotation( this->axis );
 }
 
 void RigidBody::ApplyImpulse( const Float3 &worldJ, const Float3 &atWorldPos )
@@ -125,22 +118,22 @@ Float RigidBody::GetMass() const
 
 const Quaternion & RigidBody::GetRotationQuaternion() const
 { // by Dan Andersson
-	return this->rotation;
+	return this->quaternion;
 }
 
 Float4x4 RigidBody::GetRotationMatrix() const
 { // by Dan Andersson
-	return RotationMatrix( this->rotation );
+	return RotationMatrix( quaternion );
 }
 
 Float4x4 RigidBody::GetOrientation() const
 { // by Dan Andersson
-	return ::Oyster::Math3D::OrientationMatrix( this->rotation, this->centerPos );
+	return ::Oyster::Math3D::OrientationMatrix( this->quaternion, this->centerPos );
 }
 
 Float4x4 RigidBody::GetView() const
 { // by Dan Andersson
-	return ViewMatrix( this->rotation, this->centerPos );
+	return ViewMatrix( this->quaternion, this->centerPos );
 }
 
 Float3 RigidBody::GetVelocity_Linear() const
@@ -150,7 +143,7 @@ Float3 RigidBody::GetVelocity_Linear() const
 
 Float3 RigidBody::GetVelocity_Angular() const
 { // by Dan Andersson
-	return this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, this->momentum_Angular );
+	return Float3(0, 0, 0);
 }
 
 Float3 RigidBody::GetLinearMomentum( const Float3 &atWorldPos ) const
@@ -165,9 +158,7 @@ Float3 RigidBody::GetLinearMomentum( const Float3 &atWorldPos ) const
 
 void RigidBody::SetMomentOfInertia_KeepVelocity( const MomentOfInertia &localTensorI )
 { // by Dan Andersson
-	Float3 w = this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, this->momentum_Angular );
+	
-	this->momentOfInertiaTensor = localTensorI;
-	this->momentum_Angular = this->momentOfInertiaTensor.CalculateAngularVelocity( this->rotation, w );
 }
 
 void RigidBody::SetMomentOfInertia_KeepMomentum( const MomentOfInertia &localTensorI )
@@ -193,10 +184,9 @@ void RigidBody::SetMass_KeepMomentum( const Float &m )
 	}
 }
 
-void RigidBody::SetRotation( const Float3 &axis )
+void RigidBody::SetRotation( const ::Oyster::Math::Quaternion &quaternion )
 { // by Dan Andersson
-	this->axis = axis;
+	this->quaternion = quaternion;
-	this->rotation = Rotation( this->axis );
 }
 
 void RigidBody::SetMomentum_Linear( const Float3 &worldG, const Float3 &atWorldPos )
@@ -215,12 +205,12 @@ void RigidBody::SetVelocity_Linear( const Float3 &worldV, const Float3 &atWorldP
 { // by Dan Andersson
 	Float3 worldOffset = atWorldPos - this->centerPos;
 	this->momentum_Linear  = Formula::LinearMomentum( this->mass, VectorProjection(worldV, worldOffset) );
-	this->momentum_Angular = this->momentOfInertiaTensor.CalculateAngularMomentum( this->rotation, Formula::AngularVelocity(worldV, worldOffset) );
+	this->momentum_Angular = this->momentOfInertiaTensor.CalculateAngularMomentum( this->quaternion, Formula::AngularVelocity(worldV, worldOffset) );
 }
 
 void RigidBody::SetVelocity_Angular( const Float3 &worldW )
 { // by Dan Andersson
-	this->momentum_Angular = this->momentOfInertiaTensor.CalculateAngularMomentum( this->rotation, worldW );
+	this->momentum_Angular = this->momentOfInertiaTensor.CalculateAngularMomentum( this->quaternion, worldW );
 }
 
 void RigidBody::SetImpulse_Linear( const Float3 &worldJ, const Float3 &atWorldPos )

Code/OysterPhysics3D/RigidBody.h

@@ -15,8 +15,8 @@ namespace Oyster { namespace Physics3D
 	struct RigidBody
 	{ //! A struct of a simple rigid body.
 	public:
+		::Oyster::Math::Quaternion  quaternion;
 		::Oyster::Math::Float3		centerPos,				//!< Location of the body's center in the world.
-									axis,					//!< Euler rotationAxis of the body.
 									boundingReach,			//!< 
 									momentum_Linear,		//!< The linear momentum G (kg*m/s).
 									momentum_Angular,		//!< The angular momentum H (Nm*s) around an parallell axis.
@@ -64,7 +64,7 @@ namespace Oyster { namespace Physics3D
 		void SetMass_KeepMomentum( const ::Oyster::Math::Float &m );
 
 		//void SetOrientation( const ::Oyster::Math::Float4x4 &o );
-		void SetRotation( const ::Oyster::Math::Float3 &axis );
+		void SetRotation( const ::Oyster::Math::Quaternion &quaternion );
 		void SetSize( const ::Oyster::Math::Float3 &widthHeight );
 
 		void SetMomentum_Linear( const ::Oyster::Math::Float3 &worldG, const ::Oyster::Math::Float3 &atWorldPos );
@@ -81,7 +81,7 @@ namespace Oyster { namespace Physics3D
 		::Oyster::Math::Float mass;						//!< m (kg)
 		//::Oyster::Math::Float4x4 momentOfInertiaTensor;	//!< I (Nm*s) Tensor matrix ( only need to be 3x3 matrix, but is 4x4 for future hardware acceleration )	(localValue)
 		::Oyster::Physics3D::MomentOfInertia momentOfInertiaTensor;
-		::Oyster::Math::Quaternion rotation;			//!< RotationAxis of the body.
+		//::Oyster::Math::Quaternion rotation;			//!< RotationAxis of the body.
 	};
 } }
 

Code/Physics/Bullet Source/Bullet-C-Api.h

@@ -0,0 +1,176 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+	Draft high-level generic physics C-API. For low-level access, use the physics SDK native API's.
+	Work in progress, functionality will be added on demand.
+
+	If possible, use the richer Bullet C++ API, by including "btBulletDynamicsCommon.h"
+*/
+
+#ifndef BULLET_C_API_H
+#define BULLET_C_API_H
+
+#define PL_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
+
+#ifdef BT_USE_DOUBLE_PRECISION
+typedef double	plReal;
+#else
+typedef float	plReal;
+#endif
+
+typedef plReal	plVector3[3];
+typedef plReal	plQuaternion[4];
+
+#ifdef __cplusplus
+extern "C" { 
+#endif
+
+/**	Particular physics SDK (C-API) */
+	PL_DECLARE_HANDLE(plPhysicsSdkHandle);
+
+/** 	Dynamics world, belonging to some physics SDK (C-API)*/
+	PL_DECLARE_HANDLE(plDynamicsWorldHandle);
+
+/** Rigid Body that can be part of a Dynamics World (C-API)*/	
+	PL_DECLARE_HANDLE(plRigidBodyHandle);
+
+/** 	Collision Shape/Geometry, property of a Rigid Body (C-API)*/
+	PL_DECLARE_HANDLE(plCollisionShapeHandle);
+
+/** Constraint for Rigid Bodies (C-API)*/
+	PL_DECLARE_HANDLE(plConstraintHandle);
+
+/** Triangle Mesh interface (C-API)*/
+	PL_DECLARE_HANDLE(plMeshInterfaceHandle);
+
+/** Broadphase Scene/Proxy Handles (C-API)*/
+	PL_DECLARE_HANDLE(plCollisionBroadphaseHandle);
+	PL_DECLARE_HANDLE(plBroadphaseProxyHandle);
+	PL_DECLARE_HANDLE(plCollisionWorldHandle);
+
+/**
+	Create and Delete a Physics SDK	
+*/
+
+	extern	plPhysicsSdkHandle	plNewBulletSdk(void); //this could be also another sdk, like ODE, PhysX etc.
+	extern	void		plDeletePhysicsSdk(plPhysicsSdkHandle	physicsSdk);
+
+/** Collision World, not strictly necessary, you can also just create a Dynamics World with Rigid Bodies which internally manages the Collision World with Collision Objects */
+
+	typedef void(*btBroadphaseCallback)(void* clientData, void* object1,void* object2);
+
+	extern plCollisionBroadphaseHandle	plCreateSapBroadphase(btBroadphaseCallback beginCallback,btBroadphaseCallback endCallback);
+
+	extern void	plDestroyBroadphase(plCollisionBroadphaseHandle bp);
+
+	extern 	plBroadphaseProxyHandle plCreateProxy(plCollisionBroadphaseHandle bp, void* clientData, plReal minX,plReal minY,plReal minZ, plReal maxX,plReal maxY, plReal maxZ);
+
+	extern void plDestroyProxy(plCollisionBroadphaseHandle bp, plBroadphaseProxyHandle proxyHandle);
+
+	extern void plSetBoundingBox(plBroadphaseProxyHandle proxyHandle, plReal minX,plReal minY,plReal minZ, plReal maxX,plReal maxY, plReal maxZ);
+
+/* todo: add pair cache support with queries like add/remove/find pair */
+	
+	extern plCollisionWorldHandle plCreateCollisionWorld(plPhysicsSdkHandle physicsSdk);
+
+/* todo: add/remove objects */
+	
+
+/* Dynamics World */
+
+	extern  plDynamicsWorldHandle plCreateDynamicsWorld(plPhysicsSdkHandle physicsSdk);
+
+	extern  void           plDeleteDynamicsWorld(plDynamicsWorldHandle world);
+
+	extern	void	plStepSimulation(plDynamicsWorldHandle,	plReal	timeStep);
+
+	extern  void plAddRigidBody(plDynamicsWorldHandle world, plRigidBodyHandle object);
+
+	extern  void plRemoveRigidBody(plDynamicsWorldHandle world, plRigidBodyHandle object);
+
+
+/* Rigid Body  */
+
+	extern  plRigidBodyHandle plCreateRigidBody(	void* user_data,  float mass, plCollisionShapeHandle cshape );
+
+	extern  void plDeleteRigidBody(plRigidBodyHandle body);
+
+
+/* Collision Shape definition */
+
+	extern  plCollisionShapeHandle plNewSphereShape(plReal radius);
+	extern  plCollisionShapeHandle plNewBoxShape(plReal x, plReal y, plReal z);
+	extern  plCollisionShapeHandle plNewCapsuleShape(plReal radius, plReal height);	
+	extern  plCollisionShapeHandle plNewConeShape(plReal radius, plReal height);
+	extern  plCollisionShapeHandle plNewCylinderShape(plReal radius, plReal height);
+	extern	plCollisionShapeHandle plNewCompoundShape(void);
+	extern	void	plAddChildShape(plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
+
+	extern  void plDeleteShape(plCollisionShapeHandle shape);
+
+	/* Convex Meshes */
+	extern  plCollisionShapeHandle plNewConvexHullShape(void);
+	extern  void		plAddVertex(plCollisionShapeHandle convexHull, plReal x,plReal y,plReal z);
+/* Concave static triangle meshes */
+	extern  plMeshInterfaceHandle		   plNewMeshInterface(void);
+	extern  void		plAddTriangle(plMeshInterfaceHandle meshHandle, plVector3 v0,plVector3 v1,plVector3 v2);
+	extern  plCollisionShapeHandle plNewStaticTriangleMeshShape(plMeshInterfaceHandle);
+
+	extern  void plSetScaling(plCollisionShapeHandle shape, plVector3 scaling);
+
+/* SOLID has Response Callback/Table/Management */
+/* PhysX has Triggers, User Callbacks and filtering */
+/* ODE has the typedef void dNearCallback (void *data, dGeomID o1, dGeomID o2); */
+
+/*	typedef void plUpdatedPositionCallback(void* userData, plRigidBodyHandle	rbHandle, plVector3 pos); */
+/*	typedef void plUpdatedOrientationCallback(void* userData, plRigidBodyHandle	rbHandle, plQuaternion orientation); */
+
+	/* get world transform */
+	extern void	plGetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix);
+	extern void	plGetPosition(plRigidBodyHandle object,plVector3 position);
+	extern void plGetOrientation(plRigidBodyHandle object,plQuaternion orientation);
+
+	/* set world transform (position/orientation) */
+	extern  void plSetPosition(plRigidBodyHandle object, const plVector3 position);
+	extern  void plSetOrientation(plRigidBodyHandle object, const plQuaternion orientation);
+	extern	void plSetEuler(plReal yaw,plReal pitch,plReal roll, plQuaternion orient);
+	extern	void plSetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix);
+
+	typedef struct plRayCastResult {
+		plRigidBodyHandle		m_body;  
+		plCollisionShapeHandle	m_shape; 		
+		plVector3				m_positionWorld; 		
+		plVector3				m_normalWorld;
+	} plRayCastResult;
+
+	extern  int plRayCast(plDynamicsWorldHandle world, const plVector3 rayStart, const plVector3 rayEnd, plRayCastResult res);
+
+	/* Sweep API */
+
+	/* extern  plRigidBodyHandle plObjectCast(plDynamicsWorldHandle world, const plVector3 rayStart, const plVector3 rayEnd, plVector3 hitpoint, plVector3 normal); */
+
+	/* Continuous Collision Detection API */
+	
+	// needed for source/blender/blenkernel/intern/collision.c
+	double plNearestPoints(float p1[3], float p2[3], float p3[3], float q1[3], float q2[3], float q3[3], float *pa, float *pb, float normal[3]);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif //BULLET_C_API_H
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp

@@ -0,0 +1,37 @@
+
+//Bullet Continuous Collision Detection and Physics Library
+//Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+
+//
+// btAxisSweep3
+//
+// Copyright (c) 2006 Simon Hobbs
+//
+// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+#include "btAxisSweep3.h"
+
+
+btAxisSweep3::btAxisSweep3(const btVector3& worldAabbMin,const btVector3& worldAabbMax, unsigned short int maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator)
+:btAxisSweep3Internal<unsigned short int>(worldAabbMin,worldAabbMax,0xfffe,0xffff,maxHandles,pairCache,disableRaycastAccelerator)
+{
+	// 1 handle is reserved as sentinel
+	btAssert(maxHandles > 1 && maxHandles < 32767);
+
+}
+
+
+bt32BitAxisSweep3::bt32BitAxisSweep3(const btVector3& worldAabbMin,const btVector3& worldAabbMax, unsigned int maxHandles , btOverlappingPairCache* pairCache , bool disableRaycastAccelerator)
+:btAxisSweep3Internal<unsigned int>(worldAabbMin,worldAabbMax,0xfffffffe,0x7fffffff,maxHandles,pairCache,disableRaycastAccelerator)
+{
+	// 1 handle is reserved as sentinel
+	btAssert(maxHandles > 1 && maxHandles < 2147483647);
+}

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h

@@ -0,0 +1,82 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef		BT_BROADPHASE_INTERFACE_H
+#define 	BT_BROADPHASE_INTERFACE_H
+
+
+
+struct btDispatcherInfo;
+class btDispatcher;
+#include "btBroadphaseProxy.h"
+
+class btOverlappingPairCache;
+
+
+
+struct	btBroadphaseAabbCallback
+{
+	virtual ~btBroadphaseAabbCallback() {}
+	virtual bool	process(const btBroadphaseProxy* proxy) = 0;
+};
+
+
+struct	btBroadphaseRayCallback : public btBroadphaseAabbCallback
+{
+	///added some cached data to accelerate ray-AABB tests
+	btVector3		m_rayDirectionInverse;
+	unsigned int	m_signs[3];
+	btScalar		m_lambda_max;
+
+	virtual ~btBroadphaseRayCallback() {}
+};
+
+#include "LinearMath/btVector3.h"
+
+///The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
+///Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase.
+///The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class.
+class btBroadphaseInterface
+{
+public:
+	virtual ~btBroadphaseInterface() {}
+
+	virtual btBroadphaseProxy*	createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy) =0;
+	virtual void	destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)=0;
+	virtual void	setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher)=0;
+	virtual void	getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const =0;
+
+	virtual void	rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVector3(0,0,0), const btVector3& aabbMax = btVector3(0,0,0)) = 0;
+
+	virtual void	aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback) = 0;
+
+	///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
+	virtual void	calculateOverlappingPairs(btDispatcher* dispatcher)=0;
+
+	virtual	btOverlappingPairCache*	getOverlappingPairCache()=0;
+	virtual	const btOverlappingPairCache*	getOverlappingPairCache() const =0;
+
+	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
+	///will add some transform later
+	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const =0;
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(btDispatcher* dispatcher) { (void) dispatcher; };
+
+	virtual void	printStats() = 0;
+
+};
+
+#endif //BT_BROADPHASE_INTERFACE_H

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp

@@ -0,0 +1,17 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btBroadphaseProxy.h"
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h

@@ -0,0 +1,270 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BROADPHASE_PROXY_H
+#define BT_BROADPHASE_PROXY_H
+
+#include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedAllocator.h"
+
+
+/// btDispatcher uses these types
+/// IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave
+/// to facilitate type checking
+/// CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code
+enum BroadphaseNativeTypes
+{
+	// polyhedral convex shapes
+	BOX_SHAPE_PROXYTYPE,
+	TRIANGLE_SHAPE_PROXYTYPE,
+	TETRAHEDRAL_SHAPE_PROXYTYPE,
+	CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
+	CONVEX_HULL_SHAPE_PROXYTYPE,
+	CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
+	CUSTOM_POLYHEDRAL_SHAPE_TYPE,
+//implicit convex shapes
+IMPLICIT_CONVEX_SHAPES_START_HERE,
+	SPHERE_SHAPE_PROXYTYPE,
+	MULTI_SPHERE_SHAPE_PROXYTYPE,
+	CAPSULE_SHAPE_PROXYTYPE,
+	CONE_SHAPE_PROXYTYPE,
+	CONVEX_SHAPE_PROXYTYPE,
+	CYLINDER_SHAPE_PROXYTYPE,
+	UNIFORM_SCALING_SHAPE_PROXYTYPE,
+	MINKOWSKI_SUM_SHAPE_PROXYTYPE,
+	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
+	BOX_2D_SHAPE_PROXYTYPE,
+	CONVEX_2D_SHAPE_PROXYTYPE,
+	CUSTOM_CONVEX_SHAPE_TYPE,
+//concave shapes
+CONCAVE_SHAPES_START_HERE,
+	//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
+	TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	///used for demo integration FAST/Swift collision library and Bullet
+	FAST_CONCAVE_MESH_PROXYTYPE,
+	//terrain
+	TERRAIN_SHAPE_PROXYTYPE,
+///Used for GIMPACT Trimesh integration
+	GIMPACT_SHAPE_PROXYTYPE,
+///Multimaterial mesh
+    MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
+	
+	EMPTY_SHAPE_PROXYTYPE,
+	STATIC_PLANE_PROXYTYPE,
+	CUSTOM_CONCAVE_SHAPE_TYPE,
+CONCAVE_SHAPES_END_HERE,
+
+	COMPOUND_SHAPE_PROXYTYPE,
+
+	SOFTBODY_SHAPE_PROXYTYPE,
+	HFFLUID_SHAPE_PROXYTYPE,
+	HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
+	INVALID_SHAPE_PROXYTYPE,
+
+	MAX_BROADPHASE_COLLISION_TYPES
+	
+};
+
+
+///The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. 
+///It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody.
+ATTRIBUTE_ALIGNED16(struct) btBroadphaseProxy
+{
+
+BT_DECLARE_ALIGNED_ALLOCATOR();
+	
+	///optional filtering to cull potential collisions
+	enum CollisionFilterGroups
+	{
+	        DefaultFilter = 1,
+	        StaticFilter = 2,
+	        KinematicFilter = 4,
+	        DebrisFilter = 8,
+			SensorTrigger = 16,
+			CharacterFilter = 32,
+	        AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
+	};
+
+	//Usually the client btCollisionObject or Rigidbody class
+	void*	m_clientObject;
+	short int m_collisionFilterGroup;
+	short int m_collisionFilterMask;
+	void*	m_multiSapParentProxy;		
+	int			m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
+
+	btVector3	m_aabbMin;
+	btVector3	m_aabbMax;
+
+	SIMD_FORCE_INLINE int getUid() const
+	{
+		return m_uniqueId;
+	}
+
+	//used for memory pools
+	btBroadphaseProxy() :m_clientObject(0),m_multiSapParentProxy(0)
+	{
+	}
+
+	btBroadphaseProxy(const btVector3& aabbMin,const btVector3& aabbMax,void* userPtr,short int collisionFilterGroup, short int collisionFilterMask,void* multiSapParentProxy=0)
+		:m_clientObject(userPtr),
+		m_collisionFilterGroup(collisionFilterGroup),
+		m_collisionFilterMask(collisionFilterMask),
+		m_aabbMin(aabbMin),
+		m_aabbMax(aabbMax)
+	{
+		m_multiSapParentProxy = multiSapParentProxy;
+	}
+
+	
+
+	static SIMD_FORCE_INLINE bool isPolyhedral(int proxyType)
+	{
+		return (proxyType  < IMPLICIT_CONVEX_SHAPES_START_HERE);
+	}
+
+	static SIMD_FORCE_INLINE bool	isConvex(int proxyType)
+	{
+		return (proxyType < CONCAVE_SHAPES_START_HERE);
+	}
+
+	static SIMD_FORCE_INLINE bool	isNonMoving(int proxyType)
+	{
+		return (isConcave(proxyType) && !(proxyType==GIMPACT_SHAPE_PROXYTYPE));
+	}
+
+	static SIMD_FORCE_INLINE bool	isConcave(int proxyType)
+	{
+		return ((proxyType > CONCAVE_SHAPES_START_HERE) &&
+			(proxyType < CONCAVE_SHAPES_END_HERE));
+	}
+	static SIMD_FORCE_INLINE bool	isCompound(int proxyType)
+	{
+		return (proxyType == COMPOUND_SHAPE_PROXYTYPE);
+	}
+
+	static SIMD_FORCE_INLINE bool	isSoftBody(int proxyType)
+	{
+		return (proxyType == SOFTBODY_SHAPE_PROXYTYPE);
+	}
+
+	static SIMD_FORCE_INLINE bool isInfinite(int proxyType)
+	{
+		return (proxyType == STATIC_PLANE_PROXYTYPE);
+	}
+
+	static SIMD_FORCE_INLINE bool isConvex2d(int proxyType)
+	{
+		return (proxyType == BOX_2D_SHAPE_PROXYTYPE) ||	(proxyType == CONVEX_2D_SHAPE_PROXYTYPE);
+	}
+
+	
+}
+;
+
+class btCollisionAlgorithm;
+
+struct btBroadphaseProxy;
+
+
+
+///The btBroadphasePair class contains a pair of aabb-overlapping objects.
+///A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes.
+ATTRIBUTE_ALIGNED16(struct) btBroadphasePair
+{
+	btBroadphasePair ()
+		:
+	m_pProxy0(0),
+		m_pProxy1(0),
+		m_algorithm(0),
+		m_internalInfo1(0)
+	{
+	}
+
+BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btBroadphasePair(const btBroadphasePair& other)
+		:		m_pProxy0(other.m_pProxy0),
+				m_pProxy1(other.m_pProxy1),
+				m_algorithm(other.m_algorithm),
+				m_internalInfo1(other.m_internalInfo1)
+	{
+	}
+	btBroadphasePair(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
+	{
+
+		//keep them sorted, so the std::set operations work
+		if (proxy0.m_uniqueId < proxy1.m_uniqueId)
+        { 
+            m_pProxy0 = &proxy0; 
+            m_pProxy1 = &proxy1; 
+        }
+        else 
+        { 
+			m_pProxy0 = &proxy1; 
+            m_pProxy1 = &proxy0; 
+        }
+
+		m_algorithm = 0;
+		m_internalInfo1 = 0;
+
+	}
+	
+	btBroadphaseProxy* m_pProxy0;
+	btBroadphaseProxy* m_pProxy1;
+	
+	mutable btCollisionAlgorithm* m_algorithm;
+	union { void* m_internalInfo1; int m_internalTmpValue;};//don't use this data, it will be removed in future version.
+
+};
+
+/*
+//comparison for set operation, see Solid DT_Encounter
+SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) 
+{ 
+    return a.m_pProxy0 < b.m_pProxy0 || 
+        (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); 
+}
+*/
+
+
+
+class btBroadphasePairSortPredicate
+{
+	public:
+
+		bool operator() ( const btBroadphasePair& a, const btBroadphasePair& b ) const
+		{
+			const int uidA0 = a.m_pProxy0 ? a.m_pProxy0->m_uniqueId : -1;
+			const int uidB0 = b.m_pProxy0 ? b.m_pProxy0->m_uniqueId : -1;
+			const int uidA1 = a.m_pProxy1 ? a.m_pProxy1->m_uniqueId : -1;
+			const int uidB1 = b.m_pProxy1 ? b.m_pProxy1->m_uniqueId : -1;
+
+			 return uidA0 > uidB0 || 
+				(a.m_pProxy0 == b.m_pProxy0 && uidA1 > uidB1) ||
+				(a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm); 
+		}
+};
+
+
+SIMD_FORCE_INLINE bool operator==(const btBroadphasePair& a, const btBroadphasePair& b) 
+{
+	 return (a.m_pProxy0 == b.m_pProxy0) && (a.m_pProxy1 == b.m_pProxy1);
+}
+
+
+#endif //BT_BROADPHASE_PROXY_H
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp

@@ -0,0 +1,23 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btCollisionAlgorithm.h"
+#include "btDispatcher.h"
+
+btCollisionAlgorithm::btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+{
+	m_dispatcher = ci.m_dispatcher1;
+}
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h

@@ -0,0 +1,81 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_ALGORITHM_H
+#define BT_COLLISION_ALGORITHM_H
+
+#include "LinearMath/btScalar.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct btBroadphaseProxy;
+class btDispatcher;
+class btManifoldResult;
+class btCollisionObject;
+struct btCollisionObjectWrapper;
+struct btDispatcherInfo;
+class	btPersistentManifold;
+
+typedef btAlignedObjectArray<btPersistentManifold*>	btManifoldArray;
+
+struct btCollisionAlgorithmConstructionInfo
+{
+	btCollisionAlgorithmConstructionInfo()
+		:m_dispatcher1(0),
+		m_manifold(0)
+	{
+	}
+	btCollisionAlgorithmConstructionInfo(btDispatcher* dispatcher,int temp)
+		:m_dispatcher1(dispatcher)
+	{
+		(void)temp;
+	}
+
+	btDispatcher*	m_dispatcher1;
+	btPersistentManifold*	m_manifold;
+
+//	int	getDispatcherId();
+
+};
+
+
+///btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher.
+///It is persistent over frames
+class btCollisionAlgorithm
+{
+
+protected:
+
+	btDispatcher*	m_dispatcher;
+
+protected:
+//	int	getDispatcherId();
+	
+public:
+
+	btCollisionAlgorithm() {};
+
+	btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);
+
+	virtual ~btCollisionAlgorithm() {};
+
+	virtual void processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
+
+	virtual	void	getAllContactManifolds(btManifoldArray&	manifoldArray) = 0;
+};
+
+
+#endif //BT_COLLISION_ALGORITHM_H

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp

@@ -0,0 +1,796 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///btDbvtBroadphase implementation by Nathanael Presson
+
+#include "btDbvtBroadphase.h"
+
+//
+// Profiling
+//
+
+#if DBVT_BP_PROFILE||DBVT_BP_ENABLE_BENCHMARK
+#include <stdio.h>
+#endif
+
+#if DBVT_BP_PROFILE
+struct	ProfileScope
+{
+	__forceinline ProfileScope(btClock& clock,unsigned long& value) :
+	m_clock(&clock),m_value(&value),m_base(clock.getTimeMicroseconds())
+	{
+	}
+	__forceinline ~ProfileScope()
+	{
+		(*m_value)+=m_clock->getTimeMicroseconds()-m_base;
+	}
+	btClock*		m_clock;
+	unsigned long*	m_value;
+	unsigned long	m_base;
+};
+#define	SPC(_value_)	ProfileScope	spc_scope(m_clock,_value_)
+#else
+#define	SPC(_value_)
+#endif
+
+//
+// Helpers
+//
+
+//
+template <typename T>
+static inline void	listappend(T* item,T*& list)
+{
+	item->links[0]=0;
+	item->links[1]=list;
+	if(list) list->links[0]=item;
+	list=item;
+}
+
+//
+template <typename T>
+static inline void	listremove(T* item,T*& list)
+{
+	if(item->links[0]) item->links[0]->links[1]=item->links[1]; else list=item->links[1];
+	if(item->links[1]) item->links[1]->links[0]=item->links[0];
+}
+
+//
+template <typename T>
+static inline int	listcount(T* root)
+{
+	int	n=0;
+	while(root) { ++n;root=root->links[1]; }
+	return(n);
+}
+
+//
+template <typename T>
+static inline void	clear(T& value)
+{
+	static const struct ZeroDummy : T {} zerodummy;
+	value=zerodummy;
+}
+
+//
+// Colliders
+//
+
+/* Tree collider	*/ 
+struct	btDbvtTreeCollider : btDbvt::ICollide
+{
+	btDbvtBroadphase*	pbp;
+	btDbvtProxy*		proxy;
+	btDbvtTreeCollider(btDbvtBroadphase* p) : pbp(p) {}
+	void	Process(const btDbvtNode* na,const btDbvtNode* nb)
+	{
+		if(na!=nb)
+		{
+			btDbvtProxy*	pa=(btDbvtProxy*)na->data;
+			btDbvtProxy*	pb=(btDbvtProxy*)nb->data;
+#if DBVT_BP_SORTPAIRS
+			if(pa->m_uniqueId>pb->m_uniqueId) 
+				btSwap(pa,pb);
+#endif
+			pbp->m_paircache->addOverlappingPair(pa,pb);
+			++pbp->m_newpairs;
+		}
+	}
+	void	Process(const btDbvtNode* n)
+	{
+		Process(n,proxy->leaf);
+	}
+};
+
+//
+// btDbvtBroadphase
+//
+
+//
+btDbvtBroadphase::btDbvtBroadphase(btOverlappingPairCache* paircache)
+{
+	m_deferedcollide	=	false;
+	m_needcleanup		=	true;
+	m_releasepaircache	=	(paircache!=0)?false:true;
+	m_prediction		=	0;
+	m_stageCurrent		=	0;
+	m_fixedleft			=	0;
+	m_fupdates			=	1;
+	m_dupdates			=	0;
+	m_cupdates			=	10;
+	m_newpairs			=	1;
+	m_updates_call		=	0;
+	m_updates_done		=	0;
+	m_updates_ratio		=	0;
+	m_paircache			=	paircache? paircache	: new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
+	m_gid				=	0;
+	m_pid				=	0;
+	m_cid				=	0;
+	for(int i=0;i<=STAGECOUNT;++i)
+	{
+		m_stageRoots[i]=0;
+	}
+#if DBVT_BP_PROFILE
+	clear(m_profiling);
+#endif
+}
+
+//
+btDbvtBroadphase::~btDbvtBroadphase()
+{
+	if(m_releasepaircache) 
+	{
+		m_paircache->~btOverlappingPairCache();
+		btAlignedFree(m_paircache);
+	}
+}
+
+//
+btBroadphaseProxy*				btDbvtBroadphase::createProxy(	const btVector3& aabbMin,
+															  const btVector3& aabbMax,
+															  int /*shapeType*/,
+															  void* userPtr,
+															  short int collisionFilterGroup,
+															  short int collisionFilterMask,
+															  btDispatcher* /*dispatcher*/,
+															  void* /*multiSapProxy*/)
+{
+	btDbvtProxy*		proxy=new(btAlignedAlloc(sizeof(btDbvtProxy),16)) btDbvtProxy(	aabbMin,aabbMax,userPtr,
+		collisionFilterGroup,
+		collisionFilterMask);
+
+	btDbvtAabbMm aabb = btDbvtVolume::FromMM(aabbMin,aabbMax);
+
+	//bproxy->aabb			=	btDbvtVolume::FromMM(aabbMin,aabbMax);
+	proxy->stage		=	m_stageCurrent;
+	proxy->m_uniqueId	=	++m_gid;
+	proxy->leaf			=	m_sets[0].insert(aabb,proxy);
+	listappend(proxy,m_stageRoots[m_stageCurrent]);
+	if(!m_deferedcollide)
+	{
+		btDbvtTreeCollider	collider(this);
+		collider.proxy=proxy;
+		m_sets[0].collideTV(m_sets[0].m_root,aabb,collider);
+		m_sets[1].collideTV(m_sets[1].m_root,aabb,collider);
+	}
+	return(proxy);
+}
+
+//
+void							btDbvtBroadphase::destroyProxy(	btBroadphaseProxy* absproxy,
+															   btDispatcher* dispatcher)
+{
+	btDbvtProxy*	proxy=(btDbvtProxy*)absproxy;
+	if(proxy->stage==STAGECOUNT)
+		m_sets[1].remove(proxy->leaf);
+	else
+		m_sets[0].remove(proxy->leaf);
+	listremove(proxy,m_stageRoots[proxy->stage]);
+	m_paircache->removeOverlappingPairsContainingProxy(proxy,dispatcher);
+	btAlignedFree(proxy);
+	m_needcleanup=true;
+}
+
+void	btDbvtBroadphase::getAabb(btBroadphaseProxy* absproxy,btVector3& aabbMin, btVector3& aabbMax ) const
+{
+	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
+	aabbMin = proxy->m_aabbMin;
+	aabbMax = proxy->m_aabbMax;
+}
+
+struct	BroadphaseRayTester : btDbvt::ICollide
+{
+	btBroadphaseRayCallback& m_rayCallback;
+	BroadphaseRayTester(btBroadphaseRayCallback& orgCallback)
+		:m_rayCallback(orgCallback)
+	{
+	}
+	void					Process(const btDbvtNode* leaf)
+	{
+		btDbvtProxy*	proxy=(btDbvtProxy*)leaf->data;
+		m_rayCallback.process(proxy);
+	}
+};	
+
+void	btDbvtBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback,const btVector3& aabbMin,const btVector3& aabbMax)
+{
+	BroadphaseRayTester callback(rayCallback);
+
+	m_sets[0].rayTestInternal(	m_sets[0].m_root,
+		rayFrom,
+		rayTo,
+		rayCallback.m_rayDirectionInverse,
+		rayCallback.m_signs,
+		rayCallback.m_lambda_max,
+		aabbMin,
+		aabbMax,
+		callback);
+
+	m_sets[1].rayTestInternal(	m_sets[1].m_root,
+		rayFrom,
+		rayTo,
+		rayCallback.m_rayDirectionInverse,
+		rayCallback.m_signs,
+		rayCallback.m_lambda_max,
+		aabbMin,
+		aabbMax,
+		callback);
+
+}
+
+
+struct	BroadphaseAabbTester : btDbvt::ICollide
+{
+	btBroadphaseAabbCallback& m_aabbCallback;
+	BroadphaseAabbTester(btBroadphaseAabbCallback& orgCallback)
+		:m_aabbCallback(orgCallback)
+	{
+	}
+	void					Process(const btDbvtNode* leaf)
+	{
+		btDbvtProxy*	proxy=(btDbvtProxy*)leaf->data;
+		m_aabbCallback.process(proxy);
+	}
+};	
+
+void	btDbvtBroadphase::aabbTest(const btVector3& aabbMin,const btVector3& aabbMax,btBroadphaseAabbCallback& aabbCallback)
+{
+	BroadphaseAabbTester callback(aabbCallback);
+
+	const ATTRIBUTE_ALIGNED16(btDbvtVolume)	bounds=btDbvtVolume::FromMM(aabbMin,aabbMax);
+		//process all children, that overlap with  the given AABB bounds
+	m_sets[0].collideTV(m_sets[0].m_root,bounds,callback);
+	m_sets[1].collideTV(m_sets[1].m_root,bounds,callback);
+
+}
+
+
+
+//
+void							btDbvtBroadphase::setAabb(		btBroadphaseProxy* absproxy,
+														  const btVector3& aabbMin,
+														  const btVector3& aabbMax,
+														  btDispatcher* /*dispatcher*/)
+{
+	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
+	ATTRIBUTE_ALIGNED16(btDbvtVolume)	aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
+#if DBVT_BP_PREVENTFALSEUPDATE
+	if(NotEqual(aabb,proxy->leaf->volume))
+#endif
+	{
+		bool	docollide=false;
+		if(proxy->stage==STAGECOUNT)
+		{/* fixed -> dynamic set	*/ 
+			m_sets[1].remove(proxy->leaf);
+			proxy->leaf=m_sets[0].insert(aabb,proxy);
+			docollide=true;
+		}
+		else
+		{/* dynamic set				*/ 
+			++m_updates_call;
+			if(Intersect(proxy->leaf->volume,aabb))
+			{/* Moving				*/ 
+
+				const btVector3	delta=aabbMin-proxy->m_aabbMin;
+				btVector3		velocity(((proxy->m_aabbMax-proxy->m_aabbMin)/2)*m_prediction);
+				if(delta[0]<0) velocity[0]=-velocity[0];
+				if(delta[1]<0) velocity[1]=-velocity[1];
+				if(delta[2]<0) velocity[2]=-velocity[2];
+				if	(
+#ifdef DBVT_BP_MARGIN				
+					m_sets[0].update(proxy->leaf,aabb,velocity,DBVT_BP_MARGIN)
+#else
+					m_sets[0].update(proxy->leaf,aabb,velocity)
+#endif
+					)
+				{
+					++m_updates_done;
+					docollide=true;
+				}
+			}
+			else
+			{/* Teleporting			*/ 
+				m_sets[0].update(proxy->leaf,aabb);
+				++m_updates_done;
+				docollide=true;
+			}	
+		}
+		listremove(proxy,m_stageRoots[proxy->stage]);
+		proxy->m_aabbMin = aabbMin;
+		proxy->m_aabbMax = aabbMax;
+		proxy->stage	=	m_stageCurrent;
+		listappend(proxy,m_stageRoots[m_stageCurrent]);
+		if(docollide)
+		{
+			m_needcleanup=true;
+			if(!m_deferedcollide)
+			{
+				btDbvtTreeCollider	collider(this);
+				m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider);
+				m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider);
+			}
+		}	
+	}
+}
+
+
+//
+void							btDbvtBroadphase::setAabbForceUpdate(		btBroadphaseProxy* absproxy,
+														  const btVector3& aabbMin,
+														  const btVector3& aabbMax,
+														  btDispatcher* /*dispatcher*/)
+{
+	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
+	ATTRIBUTE_ALIGNED16(btDbvtVolume)	aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
+	bool	docollide=false;
+	if(proxy->stage==STAGECOUNT)
+	{/* fixed -> dynamic set	*/ 
+		m_sets[1].remove(proxy->leaf);
+		proxy->leaf=m_sets[0].insert(aabb,proxy);
+		docollide=true;
+	}
+	else
+	{/* dynamic set				*/ 
+		++m_updates_call;
+		/* Teleporting			*/ 
+		m_sets[0].update(proxy->leaf,aabb);
+		++m_updates_done;
+		docollide=true;
+	}
+	listremove(proxy,m_stageRoots[proxy->stage]);
+	proxy->m_aabbMin = aabbMin;
+	proxy->m_aabbMax = aabbMax;
+	proxy->stage	=	m_stageCurrent;
+	listappend(proxy,m_stageRoots[m_stageCurrent]);
+	if(docollide)
+	{
+		m_needcleanup=true;
+		if(!m_deferedcollide)
+		{
+			btDbvtTreeCollider	collider(this);
+			m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider);
+			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider);
+		}
+	}	
+}
+
+//
+void							btDbvtBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
+{
+	collide(dispatcher);
+#if DBVT_BP_PROFILE
+	if(0==(m_pid%DBVT_BP_PROFILING_RATE))
+	{	
+		printf("fixed(%u) dynamics(%u) pairs(%u)\r\n",m_sets[1].m_leaves,m_sets[0].m_leaves,m_paircache->getNumOverlappingPairs());
+		unsigned int	total=m_profiling.m_total;
+		if(total<=0) total=1;
+		printf("ddcollide: %u%% (%uus)\r\n",(50+m_profiling.m_ddcollide*100)/total,m_profiling.m_ddcollide/DBVT_BP_PROFILING_RATE);
+		printf("fdcollide: %u%% (%uus)\r\n",(50+m_profiling.m_fdcollide*100)/total,m_profiling.m_fdcollide/DBVT_BP_PROFILING_RATE);
+		printf("cleanup:   %u%% (%uus)\r\n",(50+m_profiling.m_cleanup*100)/total,m_profiling.m_cleanup/DBVT_BP_PROFILING_RATE);
+		printf("total:     %uus\r\n",total/DBVT_BP_PROFILING_RATE);
+		const unsigned long	sum=m_profiling.m_ddcollide+
+			m_profiling.m_fdcollide+
+			m_profiling.m_cleanup;
+		printf("leaked: %u%% (%uus)\r\n",100-((50+sum*100)/total),(total-sum)/DBVT_BP_PROFILING_RATE);
+		printf("job counts: %u%%\r\n",(m_profiling.m_jobcount*100)/((m_sets[0].m_leaves+m_sets[1].m_leaves)*DBVT_BP_PROFILING_RATE));
+		clear(m_profiling);
+		m_clock.reset();
+	}
+#endif
+
+	performDeferredRemoval(dispatcher);
+
+}
+
+void btDbvtBroadphase::performDeferredRemoval(btDispatcher* dispatcher)
+{
+
+	if (m_paircache->hasDeferredRemoval())
+	{
+
+		btBroadphasePairArray&	overlappingPairArray = m_paircache->getOverlappingPairArray();
+
+		//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
+		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
+
+		int invalidPair = 0;
+
+		
+		int i;
+
+		btBroadphasePair previousPair;
+		previousPair.m_pProxy0 = 0;
+		previousPair.m_pProxy1 = 0;
+		previousPair.m_algorithm = 0;
+		
+		
+		for (i=0;i<overlappingPairArray.size();i++)
+		{
+		
+			btBroadphasePair& pair = overlappingPairArray[i];
+
+			bool isDuplicate = (pair == previousPair);
+
+			previousPair = pair;
+
+			bool needsRemoval = false;
+
+			if (!isDuplicate)
+			{
+				//important to perform AABB check that is consistent with the broadphase
+				btDbvtProxy*		pa=(btDbvtProxy*)pair.m_pProxy0;
+				btDbvtProxy*		pb=(btDbvtProxy*)pair.m_pProxy1;
+				bool hasOverlap = Intersect(pa->leaf->volume,pb->leaf->volume);
+
+				if (hasOverlap)
+				{
+					needsRemoval = false;
+				} else
+				{
+					needsRemoval = true;
+				}
+			} else
+			{
+				//remove duplicate
+				needsRemoval = true;
+				//should have no algorithm
+				btAssert(!pair.m_algorithm);
+			}
+			
+			if (needsRemoval)
+			{
+				m_paircache->cleanOverlappingPair(pair,dispatcher);
+
+				pair.m_pProxy0 = 0;
+				pair.m_pProxy1 = 0;
+				invalidPair++;
+			} 
+			
+		}
+
+		//perform a sort, to sort 'invalid' pairs to the end
+		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
+		overlappingPairArray.resize(overlappingPairArray.size() - invalidPair);
+	}
+}
+
+//
+void							btDbvtBroadphase::collide(btDispatcher* dispatcher)
+{
+	/*printf("---------------------------------------------------------\n");
+	printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves);
+	printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves);
+	printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs());
+	{
+		int i;
+		for (i=0;i<getOverlappingPairCache()->getNumOverlappingPairs();i++)
+		{
+			printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(),
+				getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid());
+		}
+		printf("\n");
+	}
+*/
+
+
+
+	SPC(m_profiling.m_total);
+	/* optimize				*/ 
+	m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100);
+	if(m_fixedleft)
+	{
+		const int count=1+(m_sets[1].m_leaves*m_fupdates)/100;
+		m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/100);
+		m_fixedleft=btMax<int>(0,m_fixedleft-count);
+	}
+	/* dynamic -> fixed set	*/ 
+	m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT;
+	btDbvtProxy*	current=m_stageRoots[m_stageCurrent];
+	if(current)
+	{
+		btDbvtTreeCollider	collider(this);
+		do	{
+			btDbvtProxy*	next=current->links[1];
+			listremove(current,m_stageRoots[current->stage]);
+			listappend(current,m_stageRoots[STAGECOUNT]);
+#if DBVT_BP_ACCURATESLEEPING
+			m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher);
+			collider.proxy=current;
+			btDbvt::collideTV(m_sets[0].m_root,current->aabb,collider);
+			btDbvt::collideTV(m_sets[1].m_root,current->aabb,collider);
+#endif
+			m_sets[0].remove(current->leaf);
+			ATTRIBUTE_ALIGNED16(btDbvtVolume)	curAabb=btDbvtVolume::FromMM(current->m_aabbMin,current->m_aabbMax);
+			current->leaf	=	m_sets[1].insert(curAabb,current);
+			current->stage	=	STAGECOUNT;	
+			current			=	next;
+		} while(current);
+		m_fixedleft=m_sets[1].m_leaves;
+		m_needcleanup=true;
+	}
+	/* collide dynamics		*/ 
+	{
+		btDbvtTreeCollider	collider(this);
+		if(m_deferedcollide)
+		{
+			SPC(m_profiling.m_fdcollide);
+			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[1].m_root,collider);
+		}
+		if(m_deferedcollide)
+		{
+			SPC(m_profiling.m_ddcollide);
+			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[0].m_root,collider);
+		}
+	}
+	/* clean up				*/ 
+	if(m_needcleanup)
+	{
+		SPC(m_profiling.m_cleanup);
+		btBroadphasePairArray&	pairs=m_paircache->getOverlappingPairArray();
+		if(pairs.size()>0)
+		{
+
+			int			ni=btMin(pairs.size(),btMax<int>(m_newpairs,(pairs.size()*m_cupdates)/100));
+			for(int i=0;i<ni;++i)
+			{
+				btBroadphasePair&	p=pairs[(m_cid+i)%pairs.size()];
+				btDbvtProxy*		pa=(btDbvtProxy*)p.m_pProxy0;
+				btDbvtProxy*		pb=(btDbvtProxy*)p.m_pProxy1;
+				if(!Intersect(pa->leaf->volume,pb->leaf->volume))
+				{
+#if DBVT_BP_SORTPAIRS
+					if(pa->m_uniqueId>pb->m_uniqueId) 
+						btSwap(pa,pb);
+#endif
+					m_paircache->removeOverlappingPair(pa,pb,dispatcher);
+					--ni;--i;
+				}
+			}
+			if(pairs.size()>0) m_cid=(m_cid+ni)%pairs.size(); else m_cid=0;
+		}
+	}
+	++m_pid;
+	m_newpairs=1;
+	m_needcleanup=false;
+	if(m_updates_call>0)
+	{ m_updates_ratio=m_updates_done/(btScalar)m_updates_call; }
+	else
+	{ m_updates_ratio=0; }
+	m_updates_done/=2;
+	m_updates_call/=2;
+}
+
+//
+void							btDbvtBroadphase::optimize()
+{
+	m_sets[0].optimizeTopDown();
+	m_sets[1].optimizeTopDown();
+}
+
+//
+btOverlappingPairCache*			btDbvtBroadphase::getOverlappingPairCache()
+{
+	return(m_paircache);
+}
+
+//
+const btOverlappingPairCache*	btDbvtBroadphase::getOverlappingPairCache() const
+{
+	return(m_paircache);
+}
+
+//
+void							btDbvtBroadphase::getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const
+{
+
+	ATTRIBUTE_ALIGNED16(btDbvtVolume)	bounds;
+
+	if(!m_sets[0].empty())
+		if(!m_sets[1].empty())	Merge(	m_sets[0].m_root->volume,
+			m_sets[1].m_root->volume,bounds);
+		else
+			bounds=m_sets[0].m_root->volume;
+	else if(!m_sets[1].empty())	bounds=m_sets[1].m_root->volume;
+	else
+		bounds=btDbvtVolume::FromCR(btVector3(0,0,0),0);
+	aabbMin=bounds.Mins();
+	aabbMax=bounds.Maxs();
+}
+
+void btDbvtBroadphase::resetPool(btDispatcher* dispatcher)
+{
+	
+	int totalObjects = m_sets[0].m_leaves + m_sets[1].m_leaves;
+	if (!totalObjects)
+	{
+		//reset internal dynamic tree data structures
+		m_sets[0].clear();
+		m_sets[1].clear();
+		
+		m_deferedcollide	=	false;
+		m_needcleanup		=	true;
+		m_stageCurrent		=	0;
+		m_fixedleft			=	0;
+		m_fupdates			=	1;
+		m_dupdates			=	0;
+		m_cupdates			=	10;
+		m_newpairs			=	1;
+		m_updates_call		=	0;
+		m_updates_done		=	0;
+		m_updates_ratio		=	0;
+		
+		m_gid				=	0;
+		m_pid				=	0;
+		m_cid				=	0;
+		for(int i=0;i<=STAGECOUNT;++i)
+		{
+			m_stageRoots[i]=0;
+		}
+	}
+}
+
+//
+void							btDbvtBroadphase::printStats()
+{}
+
+//
+#if DBVT_BP_ENABLE_BENCHMARK
+
+struct	btBroadphaseBenchmark
+{
+	struct	Experiment
+	{
+		const char*			name;
+		int					object_count;
+		int					update_count;
+		int					spawn_count;
+		int					iterations;
+		btScalar			speed;
+		btScalar			amplitude;
+	};
+	struct	Object
+	{
+		btVector3			center;
+		btVector3			extents;
+		btBroadphaseProxy*	proxy;
+		btScalar			time;
+		void				update(btScalar speed,btScalar amplitude,btBroadphaseInterface* pbi)
+		{
+			time		+=	speed;
+			center[0]	=	btCos(time*(btScalar)2.17)*amplitude+
+				btSin(time)*amplitude/2;
+			center[1]	=	btCos(time*(btScalar)1.38)*amplitude+
+				btSin(time)*amplitude;
+			center[2]	=	btSin(time*(btScalar)0.777)*amplitude;
+			pbi->setAabb(proxy,center-extents,center+extents,0);
+		}
+	};
+	static int		UnsignedRand(int range=RAND_MAX-1)	{ return(rand()%(range+1)); }
+	static btScalar	UnitRand()							{ return(UnsignedRand(16384)/(btScalar)16384); }
+	static void		OutputTime(const char* name,btClock& c,unsigned count=0)
+	{
+		const unsigned long	us=c.getTimeMicroseconds();
+		const unsigned long	ms=(us+500)/1000;
+		const btScalar		sec=us/(btScalar)(1000*1000);
+		if(count>0)
+			printf("%s : %u us (%u ms), %.2f/s\r\n",name,us,ms,count/sec);
+		else
+			printf("%s : %u us (%u ms)\r\n",name,us,ms);
+	}
+};
+
+void							btDbvtBroadphase::benchmark(btBroadphaseInterface* pbi)
+{
+	static const btBroadphaseBenchmark::Experiment		experiments[]=
+	{
+		{"1024o.10%",1024,10,0,8192,(btScalar)0.005,(btScalar)100},
+		/*{"4096o.10%",4096,10,0,8192,(btScalar)0.005,(btScalar)100},
+		{"8192o.10%",8192,10,0,8192,(btScalar)0.005,(btScalar)100},*/
+	};
+	static const int										nexperiments=sizeof(experiments)/sizeof(experiments[0]);
+	btAlignedObjectArray<btBroadphaseBenchmark::Object*>	objects;
+	btClock													wallclock;
+	/* Begin			*/ 
+	for(int iexp=0;iexp<nexperiments;++iexp)
+	{
+		const btBroadphaseBenchmark::Experiment&	experiment=experiments[iexp];
+		const int									object_count=experiment.object_count;
+		const int									update_count=(object_count*experiment.update_count)/100;
+		const int									spawn_count=(object_count*experiment.spawn_count)/100;
+		const btScalar								speed=experiment.speed;	
+		const btScalar								amplitude=experiment.amplitude;
+		printf("Experiment #%u '%s':\r\n",iexp,experiment.name);
+		printf("\tObjects: %u\r\n",object_count);
+		printf("\tUpdate: %u\r\n",update_count);
+		printf("\tSpawn: %u\r\n",spawn_count);
+		printf("\tSpeed: %f\r\n",speed);
+		printf("\tAmplitude: %f\r\n",amplitude);
+		srand(180673);
+		/* Create objects	*/ 
+		wallclock.reset();
+		objects.reserve(object_count);
+		for(int i=0;i<object_count;++i)
+		{
+			btBroadphaseBenchmark::Object*	po=new btBroadphaseBenchmark::Object();
+			po->center[0]=btBroadphaseBenchmark::UnitRand()*50;
+			po->center[1]=btBroadphaseBenchmark::UnitRand()*50;
+			po->center[2]=btBroadphaseBenchmark::UnitRand()*50;
+			po->extents[0]=btBroadphaseBenchmark::UnitRand()*2+2;
+			po->extents[1]=btBroadphaseBenchmark::UnitRand()*2+2;
+			po->extents[2]=btBroadphaseBenchmark::UnitRand()*2+2;
+			po->time=btBroadphaseBenchmark::UnitRand()*2000;
+			po->proxy=pbi->createProxy(po->center-po->extents,po->center+po->extents,0,po,1,1,0,0);
+			objects.push_back(po);
+		}
+		btBroadphaseBenchmark::OutputTime("\tInitialization",wallclock);
+		/* First update		*/ 
+		wallclock.reset();
+		for(int i=0;i<objects.size();++i)
+		{
+			objects[i]->update(speed,amplitude,pbi);
+		}
+		btBroadphaseBenchmark::OutputTime("\tFirst update",wallclock);
+		/* Updates			*/ 
+		wallclock.reset();
+		for(int i=0;i<experiment.iterations;++i)
+		{
+			for(int j=0;j<update_count;++j)
+			{				
+				objects[j]->update(speed,amplitude,pbi);
+			}
+			pbi->calculateOverlappingPairs(0);
+		}
+		btBroadphaseBenchmark::OutputTime("\tUpdate",wallclock,experiment.iterations);
+		/* Clean up			*/ 
+		wallclock.reset();
+		for(int i=0;i<objects.size();++i)
+		{
+			pbi->destroyProxy(objects[i]->proxy,0);
+			delete objects[i];
+		}
+		objects.resize(0);
+		btBroadphaseBenchmark::OutputTime("\tRelease",wallclock);
+	}
+
+}
+#else
+void							btDbvtBroadphase::benchmark(btBroadphaseInterface*)
+{}
+#endif
+
+#if DBVT_BP_PROFILE
+#undef	SPC
+#endif
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h

@@ -0,0 +1,146 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///btDbvtBroadphase implementation by Nathanael Presson
+#ifndef BT_DBVT_BROADPHASE_H
+#define BT_DBVT_BROADPHASE_H
+
+#include "BulletCollision/BroadphaseCollision/btDbvt.h"
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
+
+//
+// Compile time config
+//
+
+#define	DBVT_BP_PROFILE					0
+//#define DBVT_BP_SORTPAIRS				1
+#define DBVT_BP_PREVENTFALSEUPDATE		0
+#define DBVT_BP_ACCURATESLEEPING		0
+#define DBVT_BP_ENABLE_BENCHMARK		0
+#define DBVT_BP_MARGIN					(btScalar)0.05
+
+#if DBVT_BP_PROFILE
+#define	DBVT_BP_PROFILING_RATE	256
+#include "LinearMath/btQuickprof.h"
+#endif
+
+//
+// btDbvtProxy
+//
+struct btDbvtProxy : btBroadphaseProxy
+{
+	/* Fields		*/ 
+	//btDbvtAabbMm	aabb;
+	btDbvtNode*		leaf;
+	btDbvtProxy*	links[2];
+	int				stage;
+	/* ctor			*/ 
+	btDbvtProxy(const btVector3& aabbMin,const btVector3& aabbMax,void* userPtr,short int collisionFilterGroup, short int collisionFilterMask) :
+	btBroadphaseProxy(aabbMin,aabbMax,userPtr,collisionFilterGroup,collisionFilterMask)
+	{
+		links[0]=links[1]=0;
+	}
+};
+
+typedef btAlignedObjectArray<btDbvtProxy*>	btDbvtProxyArray;
+
+///The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt).
+///One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other.
+///This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3.
+struct	btDbvtBroadphase : btBroadphaseInterface
+{
+	/* Config		*/ 
+	enum	{
+		DYNAMIC_SET			=	0,	/* Dynamic set index	*/ 
+		FIXED_SET			=	1,	/* Fixed set index		*/ 
+		STAGECOUNT			=	2	/* Number of stages		*/ 
+	};
+	/* Fields		*/ 
+	btDbvt					m_sets[2];					// Dbvt sets
+	btDbvtProxy*			m_stageRoots[STAGECOUNT+1];	// Stages list
+	btOverlappingPairCache*	m_paircache;				// Pair cache
+	btScalar				m_prediction;				// Velocity prediction
+	int						m_stageCurrent;				// Current stage
+	int						m_fupdates;					// % of fixed updates per frame
+	int						m_dupdates;					// % of dynamic updates per frame
+	int						m_cupdates;					// % of cleanup updates per frame
+	int						m_newpairs;					// Number of pairs created
+	int						m_fixedleft;				// Fixed optimization left
+	unsigned				m_updates_call;				// Number of updates call
+	unsigned				m_updates_done;				// Number of updates done
+	btScalar				m_updates_ratio;			// m_updates_done/m_updates_call
+	int						m_pid;						// Parse id
+	int						m_cid;						// Cleanup index
+	int						m_gid;						// Gen id
+	bool					m_releasepaircache;			// Release pair cache on delete
+	bool					m_deferedcollide;			// Defere dynamic/static collision to collide call
+	bool					m_needcleanup;				// Need to run cleanup?
+#if DBVT_BP_PROFILE
+	btClock					m_clock;
+	struct	{
+		unsigned long		m_total;
+		unsigned long		m_ddcollide;
+		unsigned long		m_fdcollide;
+		unsigned long		m_cleanup;
+		unsigned long		m_jobcount;
+	}				m_profiling;
+#endif
+	/* Methods		*/ 
+	btDbvtBroadphase(btOverlappingPairCache* paircache=0);
+	~btDbvtBroadphase();
+	void							collide(btDispatcher* dispatcher);
+	void							optimize();
+	
+	/* btBroadphaseInterface Implementation	*/
+	btBroadphaseProxy*				createProxy(const btVector3& aabbMin,const btVector3& aabbMax,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask,btDispatcher* dispatcher,void* multiSapProxy);
+	virtual void					destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
+	virtual void					setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax,btDispatcher* dispatcher);
+	virtual void					rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVector3(0,0,0), const btVector3& aabbMax = btVector3(0,0,0));
+	virtual void					aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);
+
+	virtual void					getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;
+	virtual	void					calculateOverlappingPairs(btDispatcher* dispatcher);
+	virtual	btOverlappingPairCache*	getOverlappingPairCache();
+	virtual	const btOverlappingPairCache*	getOverlappingPairCache() const;
+	virtual	void					getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const;
+	virtual	void					printStats();
+
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(btDispatcher* dispatcher);
+
+	void	performDeferredRemoval(btDispatcher* dispatcher);
+	
+	void	setVelocityPrediction(btScalar prediction)
+	{
+		m_prediction = prediction;
+	}
+	btScalar getVelocityPrediction() const
+	{
+		return m_prediction;
+	}
+
+	///this setAabbForceUpdate is similar to setAabb but always forces the aabb update. 
+	///it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase.
+	///it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see
+	///http://code.google.com/p/bullet/issues/detail?id=223
+	void							setAabbForceUpdate(		btBroadphaseProxy* absproxy,const btVector3& aabbMin,const btVector3& aabbMax,btDispatcher* /*dispatcher*/);
+
+	static void						benchmark(btBroadphaseInterface*);
+
+
+};
+
+#endif

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btDispatcher.cpp

@@ -0,0 +1,22 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btDispatcher.h"
+
+btDispatcher::~btDispatcher()
+{
+
+}
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btDispatcher.h

@@ -0,0 +1,107 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DISPATCHER_H
+#define BT_DISPATCHER_H
+#include "LinearMath/btScalar.h"
+
+class btCollisionAlgorithm;
+struct btBroadphaseProxy;
+class btRigidBody;
+class	btCollisionObject;
+class btOverlappingPairCache;
+struct btCollisionObjectWrapper;
+
+class btPersistentManifold;
+class btPoolAllocator;
+
+struct btDispatcherInfo
+{
+	enum DispatchFunc
+	{
+		DISPATCH_DISCRETE = 1,
+		DISPATCH_CONTINUOUS
+	};
+	btDispatcherInfo()
+		:m_timeStep(btScalar(0.)),
+		m_stepCount(0),
+		m_dispatchFunc(DISPATCH_DISCRETE),
+		m_timeOfImpact(btScalar(1.)),
+		m_useContinuous(true),
+		m_debugDraw(0),
+		m_enableSatConvex(false),
+		m_enableSPU(true),
+		m_useEpa(true),
+		m_allowedCcdPenetration(btScalar(0.04)),
+		m_useConvexConservativeDistanceUtil(false),
+		m_convexConservativeDistanceThreshold(0.0f)
+	{
+
+	}
+	btScalar	m_timeStep;
+	int			m_stepCount;
+	int			m_dispatchFunc;
+	mutable btScalar	m_timeOfImpact;
+	bool		m_useContinuous;
+	class btIDebugDraw*	m_debugDraw;
+	bool		m_enableSatConvex;
+	bool		m_enableSPU;
+	bool		m_useEpa;
+	btScalar	m_allowedCcdPenetration;
+	bool		m_useConvexConservativeDistanceUtil;
+	btScalar	m_convexConservativeDistanceThreshold;
+};
+
+///The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs.
+///For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic).
+class btDispatcher
+{
+
+
+public:
+	virtual ~btDispatcher() ;
+
+	virtual btCollisionAlgorithm* findAlgorithm(const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,btPersistentManifold* sharedManifold=0) = 0;
+
+	virtual btPersistentManifold*	getNewManifold(const btCollisionObject* b0,const btCollisionObject* b1)=0;
+
+	virtual void releaseManifold(btPersistentManifold* manifold)=0;
+
+	virtual void clearManifold(btPersistentManifold* manifold)=0;
+
+	virtual bool	needsCollision(const btCollisionObject* body0,const btCollisionObject* body1) = 0;
+
+	virtual bool	needsResponse(const btCollisionObject* body0,const btCollisionObject* body1)=0;
+
+	virtual void	dispatchAllCollisionPairs(btOverlappingPairCache* pairCache,const btDispatcherInfo& dispatchInfo,btDispatcher* dispatcher)  =0;
+
+	virtual int getNumManifolds() const = 0;
+
+	virtual btPersistentManifold* getManifoldByIndexInternal(int index) = 0;
+
+	virtual	btPersistentManifold**	getInternalManifoldPointer() = 0;
+
+	virtual	btPoolAllocator*	getInternalManifoldPool() = 0;
+
+	virtual	const btPoolAllocator*	getInternalManifoldPool() const = 0;
+
+	virtual	void* allocateCollisionAlgorithm(int size)  = 0;
+
+	virtual	void freeCollisionAlgorithm(void* ptr) = 0;
+
+};
+
+
+#endif //BT_DISPATCHER_H

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp

@@ -0,0 +1,489 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btMultiSapBroadphase.h"
+
+#include "btSimpleBroadphase.h"
+#include "LinearMath/btAabbUtil2.h"
+#include "btQuantizedBvh.h"
+
+///	btSapBroadphaseArray	m_sapBroadphases;
+
+///	btOverlappingPairCache*	m_overlappingPairs;
+extern int gOverlappingPairs;
+
+/*
+class btMultiSapSortedOverlappingPairCache : public btSortedOverlappingPairCache
+{
+public:
+
+	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+	{
+		return btSortedOverlappingPairCache::addOverlappingPair((btBroadphaseProxy*)proxy0->m_multiSapParentProxy,(btBroadphaseProxy*)proxy1->m_multiSapParentProxy);
+	}
+};
+
+*/
+
+btMultiSapBroadphase::btMultiSapBroadphase(int /*maxProxies*/,btOverlappingPairCache* pairCache)
+:m_overlappingPairs(pairCache),
+m_optimizedAabbTree(0),
+m_ownsPairCache(false),
+m_invalidPair(0)
+{
+	if (!m_overlappingPairs)
+	{
+		m_ownsPairCache = true;
+		void* mem = btAlignedAlloc(sizeof(btSortedOverlappingPairCache),16);
+		m_overlappingPairs = new (mem)btSortedOverlappingPairCache();
+	}
+
+	struct btMultiSapOverlapFilterCallback : public btOverlapFilterCallback
+	{
+		virtual ~btMultiSapOverlapFilterCallback()
+		{}
+		// return true when pairs need collision
+		virtual bool	needBroadphaseCollision(btBroadphaseProxy* childProxy0,btBroadphaseProxy* childProxy1) const
+		{
+			btBroadphaseProxy* multiProxy0 = (btBroadphaseProxy*)childProxy0->m_multiSapParentProxy;
+			btBroadphaseProxy* multiProxy1 = (btBroadphaseProxy*)childProxy1->m_multiSapParentProxy;
+			
+			bool collides = (multiProxy0->m_collisionFilterGroup & multiProxy1->m_collisionFilterMask) != 0;
+			collides = collides && (multiProxy1->m_collisionFilterGroup & multiProxy0->m_collisionFilterMask);
+	
+			return collides;
+		}
+	};
+
+	void* mem = btAlignedAlloc(sizeof(btMultiSapOverlapFilterCallback),16);
+	m_filterCallback = new (mem)btMultiSapOverlapFilterCallback();
+
+	m_overlappingPairs->setOverlapFilterCallback(m_filterCallback);
+//	mem = btAlignedAlloc(sizeof(btSimpleBroadphase),16);
+//	m_simpleBroadphase = new (mem) btSimpleBroadphase(maxProxies,m_overlappingPairs);
+}
+
+btMultiSapBroadphase::~btMultiSapBroadphase()
+{
+	if (m_ownsPairCache)
+	{
+		m_overlappingPairs->~btOverlappingPairCache();
+		btAlignedFree(m_overlappingPairs);
+	}
+}
+
+
+void	btMultiSapBroadphase::buildTree(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax)
+{
+	m_optimizedAabbTree = new btQuantizedBvh();
+	m_optimizedAabbTree->setQuantizationValues(bvhAabbMin,bvhAabbMax);
+	QuantizedNodeArray&	nodes = m_optimizedAabbTree->getLeafNodeArray();
+	for (int i=0;i<m_sapBroadphases.size();i++)
+	{
+		btQuantizedBvhNode node;
+		btVector3 aabbMin,aabbMax;
+		m_sapBroadphases[i]->getBroadphaseAabb(aabbMin,aabbMax);
+		m_optimizedAabbTree->quantize(&node.m_quantizedAabbMin[0],aabbMin,0);
+		m_optimizedAabbTree->quantize(&node.m_quantizedAabbMax[0],aabbMax,1);
+		int partId = 0;
+		node.m_escapeIndexOrTriangleIndex = (partId<<(31-MAX_NUM_PARTS_IN_BITS)) | i;
+		nodes.push_back(node);
+	}
+	m_optimizedAabbTree->buildInternal();
+}
+
+btBroadphaseProxy*	btMultiSapBroadphase::createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* /*ignoreMe*/)
+{
+	//void* ignoreMe -> we could think of recursive multi-sap, if someone is interested
+
+	void* mem = btAlignedAlloc(sizeof(btMultiSapProxy),16);
+	btMultiSapProxy* proxy = new (mem)btMultiSapProxy(aabbMin,  aabbMax,shapeType,userPtr, collisionFilterGroup,collisionFilterMask);
+	m_multiSapProxies.push_back(proxy);
+
+	///this should deal with inserting/removal into child broadphases
+	setAabb(proxy,aabbMin,aabbMax,dispatcher);
+	return proxy;
+}
+
+void	btMultiSapBroadphase::destroyProxy(btBroadphaseProxy* /*proxy*/,btDispatcher* /*dispatcher*/)
+{
+	///not yet
+	btAssert(0);
+
+}
+
+
+void	btMultiSapBroadphase::addToChildBroadphase(btMultiSapProxy* parentMultiSapProxy, btBroadphaseProxy* childProxy, btBroadphaseInterface*	childBroadphase)
+{
+	void* mem = btAlignedAlloc(sizeof(btBridgeProxy),16);
+	btBridgeProxy* bridgeProxyRef = new(mem) btBridgeProxy;
+	bridgeProxyRef->m_childProxy = childProxy;
+	bridgeProxyRef->m_childBroadphase = childBroadphase;
+	parentMultiSapProxy->m_bridgeProxies.push_back(bridgeProxyRef);
+}
+
+
+bool boxIsContainedWithinBox(const btVector3& amin,const btVector3& amax,const btVector3& bmin,const btVector3& bmax);
+bool boxIsContainedWithinBox(const btVector3& amin,const btVector3& amax,const btVector3& bmin,const btVector3& bmax)
+{
+return
+amin.getX() >= bmin.getX() && amax.getX() <= bmax.getX() &&
+amin.getY() >= bmin.getY() && amax.getY() <= bmax.getY() &&
+amin.getZ() >= bmin.getZ() && amax.getZ() <= bmax.getZ();
+}
+
+
+
+
+
+
+void	btMultiSapBroadphase::getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const
+{
+	btMultiSapProxy* multiProxy = static_cast<btMultiSapProxy*>(proxy);
+	aabbMin = multiProxy->m_aabbMin;
+	aabbMax = multiProxy->m_aabbMax;
+}
+
+void	btMultiSapBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin,const btVector3& aabbMax)
+{
+	for (int i=0;i<m_multiSapProxies.size();i++)
+	{
+		rayCallback.process(m_multiSapProxies[i]);
+	}
+}
+
+
+//#include <stdio.h>
+
+void	btMultiSapBroadphase::setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher)
+{
+	btMultiSapProxy* multiProxy = static_cast<btMultiSapProxy*>(proxy);
+	multiProxy->m_aabbMin = aabbMin;
+	multiProxy->m_aabbMax = aabbMax;
+	
+	
+//	bool fullyContained = false;
+//	bool alreadyInSimple = false;
+	
+
+
+	
+	struct MyNodeOverlapCallback : public btNodeOverlapCallback
+	{
+		btMultiSapBroadphase*	m_multiSap;
+		btMultiSapProxy*		m_multiProxy;
+		btDispatcher*			m_dispatcher;
+
+		MyNodeOverlapCallback(btMultiSapBroadphase* multiSap,btMultiSapProxy* multiProxy,btDispatcher* dispatcher)
+			:m_multiSap(multiSap),
+			m_multiProxy(multiProxy),
+			m_dispatcher(dispatcher)
+		{
+
+		}
+
+		virtual void processNode(int /*nodeSubPart*/, int broadphaseIndex)
+		{
+			btBroadphaseInterface* childBroadphase = m_multiSap->getBroadphaseArray()[broadphaseIndex];
+
+			int containingBroadphaseIndex = -1;
+			//already found?
+			for (int i=0;i<m_multiProxy->m_bridgeProxies.size();i++)
+			{
+
+				if (m_multiProxy->m_bridgeProxies[i]->m_childBroadphase == childBroadphase)
+				{
+					containingBroadphaseIndex = i;
+					break;
+				}
+			}
+			if (containingBroadphaseIndex<0)
+			{
+				//add it
+				btBroadphaseProxy* childProxy = childBroadphase->createProxy(m_multiProxy->m_aabbMin,m_multiProxy->m_aabbMax,m_multiProxy->m_shapeType,m_multiProxy->m_clientObject,m_multiProxy->m_collisionFilterGroup,m_multiProxy->m_collisionFilterMask, m_dispatcher,m_multiProxy);
+				m_multiSap->addToChildBroadphase(m_multiProxy,childProxy,childBroadphase);
+
+			}
+		}
+	};
+
+	MyNodeOverlapCallback	myNodeCallback(this,multiProxy,dispatcher);
+
+
+
+	
+	if (m_optimizedAabbTree)
+		m_optimizedAabbTree->reportAabbOverlappingNodex(&myNodeCallback,aabbMin,aabbMax);
+
+	int i;
+
+	for ( i=0;i<multiProxy->m_bridgeProxies.size();i++)
+	{
+		btVector3 worldAabbMin,worldAabbMax;
+		multiProxy->m_bridgeProxies[i]->m_childBroadphase->getBroadphaseAabb(worldAabbMin,worldAabbMax);
+		bool overlapsBroadphase = TestAabbAgainstAabb2(worldAabbMin,worldAabbMax,multiProxy->m_aabbMin,multiProxy->m_aabbMax);
+		if (!overlapsBroadphase)
+		{
+			//remove it now
+			btBridgeProxy* bridgeProxy = multiProxy->m_bridgeProxies[i];
+
+			btBroadphaseProxy* childProxy = bridgeProxy->m_childProxy;
+			bridgeProxy->m_childBroadphase->destroyProxy(childProxy,dispatcher);
+			
+			multiProxy->m_bridgeProxies.swap( i,multiProxy->m_bridgeProxies.size()-1);
+			multiProxy->m_bridgeProxies.pop_back();
+
+		}
+	}
+
+
+	/*
+
+	if (1)
+	{
+
+		//find broadphase that contain this multiProxy
+		int numChildBroadphases = getBroadphaseArray().size();
+		for (int i=0;i<numChildBroadphases;i++)
+		{
+			btBroadphaseInterface* childBroadphase = getBroadphaseArray()[i];
+			btVector3 worldAabbMin,worldAabbMax;
+			childBroadphase->getBroadphaseAabb(worldAabbMin,worldAabbMax);
+			bool overlapsBroadphase = TestAabbAgainstAabb2(worldAabbMin,worldAabbMax,multiProxy->m_aabbMin,multiProxy->m_aabbMax);
+			
+		//	fullyContained = fullyContained || boxIsContainedWithinBox(worldAabbMin,worldAabbMax,multiProxy->m_aabbMin,multiProxy->m_aabbMax);
+			int containingBroadphaseIndex = -1;
+			
+			//if already contains this
+			
+			for (int i=0;i<multiProxy->m_bridgeProxies.size();i++)
+			{
+				if (multiProxy->m_bridgeProxies[i]->m_childBroadphase == childBroadphase)
+				{
+					containingBroadphaseIndex = i;
+				}
+				alreadyInSimple = alreadyInSimple || (multiProxy->m_bridgeProxies[i]->m_childBroadphase == m_simpleBroadphase);
+			}
+
+			if (overlapsBroadphase)
+			{
+				if (containingBroadphaseIndex<0)
+				{
+					btBroadphaseProxy* childProxy = childBroadphase->createProxy(aabbMin,aabbMax,multiProxy->m_shapeType,multiProxy->m_clientObject,multiProxy->m_collisionFilterGroup,multiProxy->m_collisionFilterMask, dispatcher);
+					childProxy->m_multiSapParentProxy = multiProxy;
+					addToChildBroadphase(multiProxy,childProxy,childBroadphase);
+				}
+			} else
+			{
+				if (containingBroadphaseIndex>=0)
+				{
+					//remove
+					btBridgeProxy* bridgeProxy = multiProxy->m_bridgeProxies[containingBroadphaseIndex];
+
+					btBroadphaseProxy* childProxy = bridgeProxy->m_childProxy;
+					bridgeProxy->m_childBroadphase->destroyProxy(childProxy,dispatcher);
+					
+					multiProxy->m_bridgeProxies.swap( containingBroadphaseIndex,multiProxy->m_bridgeProxies.size()-1);
+					multiProxy->m_bridgeProxies.pop_back();
+				}
+			}
+		}
+
+
+		///If we are in no other child broadphase, stick the proxy in the global 'simple' broadphase (brute force)
+		///hopefully we don't end up with many entries here (can assert/provide feedback on stats)
+		if (0)//!multiProxy->m_bridgeProxies.size())
+		{
+			///we don't pass the userPtr but our multisap proxy. We need to patch this, before processing an actual collision
+			///this is needed to be able to calculate the aabb overlap
+			btBroadphaseProxy* childProxy = m_simpleBroadphase->createProxy(aabbMin,aabbMax,multiProxy->m_shapeType,multiProxy->m_clientObject,multiProxy->m_collisionFilterGroup,multiProxy->m_collisionFilterMask, dispatcher);
+			childProxy->m_multiSapParentProxy = multiProxy;
+			addToChildBroadphase(multiProxy,childProxy,m_simpleBroadphase);
+		}
+	}
+
+	if (!multiProxy->m_bridgeProxies.size())
+	{
+		///we don't pass the userPtr but our multisap proxy. We need to patch this, before processing an actual collision
+		///this is needed to be able to calculate the aabb overlap
+		btBroadphaseProxy* childProxy = m_simpleBroadphase->createProxy(aabbMin,aabbMax,multiProxy->m_shapeType,multiProxy->m_clientObject,multiProxy->m_collisionFilterGroup,multiProxy->m_collisionFilterMask, dispatcher);
+		childProxy->m_multiSapParentProxy = multiProxy;
+		addToChildBroadphase(multiProxy,childProxy,m_simpleBroadphase);
+	}
+*/
+
+
+	//update
+	for ( i=0;i<multiProxy->m_bridgeProxies.size();i++)
+	{
+		btBridgeProxy* bridgeProxyRef = multiProxy->m_bridgeProxies[i];
+		bridgeProxyRef->m_childBroadphase->setAabb(bridgeProxyRef->m_childProxy,aabbMin,aabbMax,dispatcher);
+	}
+
+}
+bool stopUpdating=false;
+
+
+
+class btMultiSapBroadphasePairSortPredicate
+{
+	public:
+
+		bool operator() ( const btBroadphasePair& a1, const btBroadphasePair& b1 ) const
+		{
+				btMultiSapBroadphase::btMultiSapProxy* aProxy0 = a1.m_pProxy0 ? (btMultiSapBroadphase::btMultiSapProxy*)a1.m_pProxy0->m_multiSapParentProxy : 0;
+				btMultiSapBroadphase::btMultiSapProxy* aProxy1 = a1.m_pProxy1 ? (btMultiSapBroadphase::btMultiSapProxy*)a1.m_pProxy1->m_multiSapParentProxy : 0;
+				btMultiSapBroadphase::btMultiSapProxy* bProxy0 = b1.m_pProxy0 ? (btMultiSapBroadphase::btMultiSapProxy*)b1.m_pProxy0->m_multiSapParentProxy : 0;
+				btMultiSapBroadphase::btMultiSapProxy* bProxy1 = b1.m_pProxy1 ? (btMultiSapBroadphase::btMultiSapProxy*)b1.m_pProxy1->m_multiSapParentProxy : 0;
+
+				 return aProxy0 > bProxy0 || 
+					(aProxy0 == bProxy0 && aProxy1 > bProxy1) ||
+					(aProxy0 == bProxy0 && aProxy1 == bProxy1 && a1.m_algorithm > b1.m_algorithm); 
+		}
+};
+
+
+        ///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
+void    btMultiSapBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
+{
+
+//	m_simpleBroadphase->calculateOverlappingPairs(dispatcher);
+
+	if (!stopUpdating && getOverlappingPairCache()->hasDeferredRemoval())
+	{
+	
+		btBroadphasePairArray&	overlappingPairArray = getOverlappingPairCache()->getOverlappingPairArray();
+
+	//	quicksort(overlappingPairArray,0,overlappingPairArray.size());
+
+		overlappingPairArray.quickSort(btMultiSapBroadphasePairSortPredicate());
+
+		//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
+	//	overlappingPairArray.heapSort(btMultiSapBroadphasePairSortPredicate());
+
+		overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
+		m_invalidPair = 0;
+
+		
+		int i;
+
+		btBroadphasePair previousPair;
+		previousPair.m_pProxy0 = 0;
+		previousPair.m_pProxy1 = 0;
+		previousPair.m_algorithm = 0;
+		
+		
+		for (i=0;i<overlappingPairArray.size();i++)
+		{
+		
+			btBroadphasePair& pair = overlappingPairArray[i];
+
+			btMultiSapProxy* aProxy0 = pair.m_pProxy0 ? (btMultiSapProxy*)pair.m_pProxy0->m_multiSapParentProxy : 0;
+			btMultiSapProxy* aProxy1 = pair.m_pProxy1 ? (btMultiSapProxy*)pair.m_pProxy1->m_multiSapParentProxy : 0;
+			btMultiSapProxy* bProxy0 = previousPair.m_pProxy0 ? (btMultiSapProxy*)previousPair.m_pProxy0->m_multiSapParentProxy : 0;
+			btMultiSapProxy* bProxy1 = previousPair.m_pProxy1 ? (btMultiSapProxy*)previousPair.m_pProxy1->m_multiSapParentProxy : 0;
+
+			bool isDuplicate = (aProxy0 == bProxy0) && (aProxy1 == bProxy1);
+			
+			previousPair = pair;
+
+			bool needsRemoval = false;
+
+			if (!isDuplicate)
+			{
+				bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);
+
+				if (hasOverlap)
+				{
+					needsRemoval = false;//callback->processOverlap(pair);
+				} else
+				{
+					needsRemoval = true;
+				}
+			} else
+			{
+				//remove duplicate
+				needsRemoval = true;
+				//should have no algorithm
+				btAssert(!pair.m_algorithm);
+			}
+			
+			if (needsRemoval)
+			{
+				getOverlappingPairCache()->cleanOverlappingPair(pair,dispatcher);
+
+		//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+		//		m_overlappingPairArray.pop_back();
+				pair.m_pProxy0 = 0;
+				pair.m_pProxy1 = 0;
+				m_invalidPair++;
+				gOverlappingPairs--;
+			} 
+			
+		}
+
+	///if you don't like to skip the invalid pairs in the array, execute following code:
+	#define CLEAN_INVALID_PAIRS 1
+	#ifdef CLEAN_INVALID_PAIRS
+
+		//perform a sort, to sort 'invalid' pairs to the end
+		//overlappingPairArray.heapSort(btMultiSapBroadphasePairSortPredicate());
+		overlappingPairArray.quickSort(btMultiSapBroadphasePairSortPredicate());
+
+		overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
+		m_invalidPair = 0;
+	#endif//CLEAN_INVALID_PAIRS
+		
+		//printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size());
+	}
+
+
+}
+
+
+bool	btMultiSapBroadphase::testAabbOverlap(btBroadphaseProxy* childProxy0,btBroadphaseProxy* childProxy1)
+{
+	btMultiSapProxy* multiSapProxy0 = (btMultiSapProxy*)childProxy0->m_multiSapParentProxy;
+		btMultiSapProxy* multiSapProxy1 = (btMultiSapProxy*)childProxy1->m_multiSapParentProxy;
+
+		return	TestAabbAgainstAabb2(multiSapProxy0->m_aabbMin,multiSapProxy0->m_aabbMax,
+			multiSapProxy1->m_aabbMin,multiSapProxy1->m_aabbMax);
+		
+}
+
+
+void	btMultiSapBroadphase::printStats()
+{
+/*	printf("---------------------------------\n");
+	
+		printf("btMultiSapBroadphase.h\n");
+		printf("numHandles = %d\n",m_multiSapProxies.size());
+			//find broadphase that contain this multiProxy
+		int numChildBroadphases = getBroadphaseArray().size();
+		for (int i=0;i<numChildBroadphases;i++)
+		{
+
+			btBroadphaseInterface* childBroadphase = getBroadphaseArray()[i];
+			childBroadphase->printStats();
+
+		}
+		*/
+
+}
+
+void btMultiSapBroadphase::resetPool(btDispatcher* dispatcher)
+{
+	// not yet
+}

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.h

@@ -0,0 +1,151 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BT_MULTI_SAP_BROADPHASE
+#define BT_MULTI_SAP_BROADPHASE
+
+#include "btBroadphaseInterface.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btOverlappingPairCache.h"
+
+
+class btBroadphaseInterface;
+class btSimpleBroadphase;
+
+
+typedef btAlignedObjectArray<btBroadphaseInterface*> btSapBroadphaseArray;
+
+///The btMultiSapBroadphase is a research project, not recommended to use in production. Use btAxisSweep3 or btDbvtBroadphase instead.
+///The btMultiSapBroadphase is a broadphase that contains multiple SAP broadphases.
+///The user can add SAP broadphases that cover the world. A btBroadphaseProxy can be in multiple child broadphases at the same time.
+///A btQuantizedBvh acceleration structures finds overlapping SAPs for each btBroadphaseProxy.
+///See http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=328
+///and http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1329
+class btMultiSapBroadphase :public btBroadphaseInterface
+{
+	btSapBroadphaseArray	m_sapBroadphases;
+	
+	btSimpleBroadphase*		m_simpleBroadphase;
+
+	btOverlappingPairCache*	m_overlappingPairs;
+
+	class btQuantizedBvh*			m_optimizedAabbTree;
+
+
+	bool					m_ownsPairCache;
+	
+	btOverlapFilterCallback*	m_filterCallback;
+
+	int			m_invalidPair;
+
+	struct	btBridgeProxy
+	{
+		btBroadphaseProxy*		m_childProxy;
+		btBroadphaseInterface*	m_childBroadphase;
+	};
+
+
+public:
+
+	struct	btMultiSapProxy	: public btBroadphaseProxy
+	{
+
+		///array with all the entries that this proxy belongs to
+		btAlignedObjectArray<btBridgeProxy*> m_bridgeProxies;
+		btVector3	m_aabbMin;
+		btVector3	m_aabbMax;
+
+		int	m_shapeType;
+
+/*		void*	m_userPtr;
+		short int	m_collisionFilterGroup;
+		short int	m_collisionFilterMask;
+*/
+		btMultiSapProxy(const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask)
+			:btBroadphaseProxy(aabbMin,aabbMax,userPtr,collisionFilterGroup,collisionFilterMask),
+			m_aabbMin(aabbMin),
+			m_aabbMax(aabbMax),
+			m_shapeType(shapeType)
+		{
+			m_multiSapParentProxy =this;
+		}
+
+		
+	};
+
+protected:
+
+
+	btAlignedObjectArray<btMultiSapProxy*> m_multiSapProxies;
+
+public:
+
+	btMultiSapBroadphase(int maxProxies = 16384,btOverlappingPairCache* pairCache=0);
+
+
+	btSapBroadphaseArray&	getBroadphaseArray()
+	{
+		return m_sapBroadphases;
+	}
+
+	const btSapBroadphaseArray&	getBroadphaseArray() const
+	{
+		return m_sapBroadphases;
+	}
+
+	virtual ~btMultiSapBroadphase();
+
+	virtual btBroadphaseProxy*	createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy);
+	virtual void	destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
+	virtual void	setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher);
+	virtual void	getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;
+
+	virtual void	rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback,const btVector3& aabbMin=btVector3(0,0,0),const btVector3& aabbMax=btVector3(0,0,0));
+
+	void	addToChildBroadphase(btMultiSapProxy* parentMultiSapProxy, btBroadphaseProxy* childProxy, btBroadphaseInterface*	childBroadphase);
+
+	///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
+	virtual void	calculateOverlappingPairs(btDispatcher* dispatcher);
+
+	bool	testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
+
+	virtual	btOverlappingPairCache*	getOverlappingPairCache()
+	{
+		return m_overlappingPairs;
+	}
+	virtual	const btOverlappingPairCache*	getOverlappingPairCache() const
+	{
+		return m_overlappingPairs;
+	}
+
+	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
+	///will add some transform later
+	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const
+	{
+		aabbMin.setValue(-BT_LARGE_FLOAT,-BT_LARGE_FLOAT,-BT_LARGE_FLOAT);
+		aabbMax.setValue(BT_LARGE_FLOAT,BT_LARGE_FLOAT,BT_LARGE_FLOAT);
+	}
+
+	void	buildTree(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax);
+
+	virtual void	printStats();
+
+	void quicksort (btBroadphasePairArray& a, int lo, int hi);
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(btDispatcher* dispatcher);
+
+};
+
+#endif //BT_MULTI_SAP_BROADPHASE

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp

@@ -0,0 +1,633 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+
+#include "btOverlappingPairCache.h"
+
+#include "btDispatcher.h"
+#include "btCollisionAlgorithm.h"
+#include "LinearMath/btAabbUtil2.h"
+
+#include <stdio.h>
+
+int	gOverlappingPairs = 0;
+
+int gRemovePairs =0;
+int gAddedPairs =0;
+int gFindPairs =0;
+
+
+
+
+btHashedOverlappingPairCache::btHashedOverlappingPairCache():
+	m_overlapFilterCallback(0),
+	m_blockedForChanges(false),
+	m_ghostPairCallback(0)
+{
+	int initialAllocatedSize= 2;
+	m_overlappingPairArray.reserve(initialAllocatedSize);
+	growTables();
+}
+
+
+
+
+btHashedOverlappingPairCache::~btHashedOverlappingPairCache()
+{
+}
+
+
+
+void	btHashedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
+{
+	if (pair.m_algorithm && dispatcher)
+	{
+		{
+			pair.m_algorithm->~btCollisionAlgorithm();
+			dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
+			pair.m_algorithm=0;
+		}
+	}
+}
+
+
+
+
+void	btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+{
+
+	class	CleanPairCallback : public btOverlapCallback
+	{
+		btBroadphaseProxy* m_cleanProxy;
+		btOverlappingPairCache*	m_pairCache;
+		btDispatcher* m_dispatcher;
+
+	public:
+		CleanPairCallback(btBroadphaseProxy* cleanProxy,btOverlappingPairCache* pairCache,btDispatcher* dispatcher)
+			:m_cleanProxy(cleanProxy),
+			m_pairCache(pairCache),
+			m_dispatcher(dispatcher)
+		{
+		}
+		virtual	bool	processOverlap(btBroadphasePair& pair)
+		{
+			if ((pair.m_pProxy0 == m_cleanProxy) ||
+				(pair.m_pProxy1 == m_cleanProxy))
+			{
+				m_pairCache->cleanOverlappingPair(pair,m_dispatcher);
+			}
+			return false;
+		}
+		
+	};
+
+	CleanPairCallback cleanPairs(proxy,this,dispatcher);
+
+	processAllOverlappingPairs(&cleanPairs,dispatcher);
+
+}
+
+
+
+
+void	btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+{
+
+	class	RemovePairCallback : public btOverlapCallback
+	{
+		btBroadphaseProxy* m_obsoleteProxy;
+
+	public:
+		RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
+			:m_obsoleteProxy(obsoleteProxy)
+		{
+		}
+		virtual	bool	processOverlap(btBroadphasePair& pair)
+		{
+			return ((pair.m_pProxy0 == m_obsoleteProxy) ||
+				(pair.m_pProxy1 == m_obsoleteProxy));
+		}
+		
+	};
+
+
+	RemovePairCallback removeCallback(proxy);
+
+	processAllOverlappingPairs(&removeCallback,dispatcher);
+}
+
+
+
+
+
+btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+{
+	gFindPairs++;
+	if(proxy0->m_uniqueId>proxy1->m_uniqueId) 
+		btSwap(proxy0,proxy1);
+	int proxyId1 = proxy0->getUid();
+	int proxyId2 = proxy1->getUid();
+
+	/*if (proxyId1 > proxyId2) 
+		btSwap(proxyId1, proxyId2);*/
+
+	int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));
+
+	if (hash >= m_hashTable.size())
+	{
+		return NULL;
+	}
+
+	int index = m_hashTable[hash];
+	while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
+	{
+		index = m_next[index];
+	}
+
+	if (index == BT_NULL_PAIR)
+	{
+		return NULL;
+	}
+
+	btAssert(index < m_overlappingPairArray.size());
+
+	return &m_overlappingPairArray[index];
+}
+
+//#include <stdio.h>
+
+void	btHashedOverlappingPairCache::growTables()
+{
+
+	int newCapacity = m_overlappingPairArray.capacity();
+
+	if (m_hashTable.size() < newCapacity)
+	{
+		//grow hashtable and next table
+		int curHashtableSize = m_hashTable.size();
+
+		m_hashTable.resize(newCapacity);
+		m_next.resize(newCapacity);
+
+
+		int i;
+
+		for (i= 0; i < newCapacity; ++i)
+		{
+			m_hashTable[i] = BT_NULL_PAIR;
+		}
+		for (i = 0; i < newCapacity; ++i)
+		{
+			m_next[i] = BT_NULL_PAIR;
+		}
+
+		for(i=0;i<curHashtableSize;i++)
+		{
+	
+			const btBroadphasePair& pair = m_overlappingPairArray[i];
+			int proxyId1 = pair.m_pProxy0->getUid();
+			int proxyId2 = pair.m_pProxy1->getUid();
+			/*if (proxyId1 > proxyId2) 
+				btSwap(proxyId1, proxyId2);*/
+			int	hashValue = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));	// New hash value with new mask
+			m_next[i] = m_hashTable[hashValue];
+			m_hashTable[hashValue] = i;
+		}
+
+
+	}
+}
+
+btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+{
+	if(proxy0->m_uniqueId>proxy1->m_uniqueId) 
+		btSwap(proxy0,proxy1);
+	int proxyId1 = proxy0->getUid();
+	int proxyId2 = proxy1->getUid();
+
+	/*if (proxyId1 > proxyId2) 
+		btSwap(proxyId1, proxyId2);*/
+
+	int	hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));	// New hash value with new mask
+
+
+	btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash);
+	if (pair != NULL)
+	{
+		return pair;
+	}
+	/*for(int i=0;i<m_overlappingPairArray.size();++i)
+		{
+		if(	(m_overlappingPairArray[i].m_pProxy0==proxy0)&&
+			(m_overlappingPairArray[i].m_pProxy1==proxy1))
+			{
+			printf("Adding duplicated %u<>%u\r\n",proxyId1,proxyId2);
+			internalFindPair(proxy0, proxy1, hash);
+			}
+		}*/
+	int count = m_overlappingPairArray.size();
+	int oldCapacity = m_overlappingPairArray.capacity();
+	void* mem = &m_overlappingPairArray.expandNonInitializing();
+
+	//this is where we add an actual pair, so also call the 'ghost'
+	if (m_ghostPairCallback)
+		m_ghostPairCallback->addOverlappingPair(proxy0,proxy1);
+
+	int newCapacity = m_overlappingPairArray.capacity();
+
+	if (oldCapacity < newCapacity)
+	{
+		growTables();
+		//hash with new capacity
+		hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));
+	}
+	
+	pair = new (mem) btBroadphasePair(*proxy0,*proxy1);
+//	pair->m_pProxy0 = proxy0;
+//	pair->m_pProxy1 = proxy1;
+	pair->m_algorithm = 0;
+	pair->m_internalTmpValue = 0;
+	
+
+	m_next[count] = m_hashTable[hash];
+	m_hashTable[hash] = count;
+
+	return pair;
+}
+
+
+
+void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
+{
+	gRemovePairs++;
+	if(proxy0->m_uniqueId>proxy1->m_uniqueId) 
+		btSwap(proxy0,proxy1);
+	int proxyId1 = proxy0->getUid();
+	int proxyId2 = proxy1->getUid();
+
+	/*if (proxyId1 > proxyId2) 
+		btSwap(proxyId1, proxyId2);*/
+
+	int	hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));
+
+	btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash);
+	if (pair == NULL)
+	{
+		return 0;
+	}
+
+	cleanOverlappingPair(*pair,dispatcher);
+
+	void* userData = pair->m_internalInfo1;
+
+	btAssert(pair->m_pProxy0->getUid() == proxyId1);
+	btAssert(pair->m_pProxy1->getUid() == proxyId2);
+
+	int pairIndex = int(pair - &m_overlappingPairArray[0]);
+	btAssert(pairIndex < m_overlappingPairArray.size());
+
+	// Remove the pair from the hash table.
+	int index = m_hashTable[hash];
+	btAssert(index != BT_NULL_PAIR);
+
+	int previous = BT_NULL_PAIR;
+	while (index != pairIndex)
+	{
+		previous = index;
+		index = m_next[index];
+	}
+
+	if (previous != BT_NULL_PAIR)
+	{
+		btAssert(m_next[previous] == pairIndex);
+		m_next[previous] = m_next[pairIndex];
+	}
+	else
+	{
+		m_hashTable[hash] = m_next[pairIndex];
+	}
+
+	// We now move the last pair into spot of the
+	// pair being removed. We need to fix the hash
+	// table indices to support the move.
+
+	int lastPairIndex = m_overlappingPairArray.size() - 1;
+
+	if (m_ghostPairCallback)
+		m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1,dispatcher);
+
+	// If the removed pair is the last pair, we are done.
+	if (lastPairIndex == pairIndex)
+	{
+		m_overlappingPairArray.pop_back();
+		return userData;
+	}
+
+	// Remove the last pair from the hash table.
+	const btBroadphasePair* last = &m_overlappingPairArray[lastPairIndex];
+		/* missing swap here too, Nat. */ 
+	int lastHash = static_cast<int>(getHash(static_cast<unsigned int>(last->m_pProxy0->getUid()), static_cast<unsigned int>(last->m_pProxy1->getUid())) & (m_overlappingPairArray.capacity()-1));
+
+	index = m_hashTable[lastHash];
+	btAssert(index != BT_NULL_PAIR);
+
+	previous = BT_NULL_PAIR;
+	while (index != lastPairIndex)
+	{
+		previous = index;
+		index = m_next[index];
+	}
+
+	if (previous != BT_NULL_PAIR)
+	{
+		btAssert(m_next[previous] == lastPairIndex);
+		m_next[previous] = m_next[lastPairIndex];
+	}
+	else
+	{
+		m_hashTable[lastHash] = m_next[lastPairIndex];
+	}
+
+	// Copy the last pair into the remove pair's spot.
+	m_overlappingPairArray[pairIndex] = m_overlappingPairArray[lastPairIndex];
+
+	// Insert the last pair into the hash table
+	m_next[pairIndex] = m_hashTable[lastHash];
+	m_hashTable[lastHash] = pairIndex;
+
+	m_overlappingPairArray.pop_back();
+
+	return userData;
+}
+//#include <stdio.h>
+
+void	btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
+{
+
+	int i;
+
+//	printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size());
+	for (i=0;i<m_overlappingPairArray.size();)
+	{
+	
+		btBroadphasePair* pair = &m_overlappingPairArray[i];
+		if (callback->processOverlap(*pair))
+		{
+			removeOverlappingPair(pair->m_pProxy0,pair->m_pProxy1,dispatcher);
+
+			gOverlappingPairs--;
+		} else
+		{
+			i++;
+		}
+	}
+}
+
+void	btHashedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
+{
+	///need to keep hashmap in sync with pair address, so rebuild all
+	btBroadphasePairArray tmpPairs;
+	int i;
+	for (i=0;i<m_overlappingPairArray.size();i++)
+	{
+		tmpPairs.push_back(m_overlappingPairArray[i]);
+	}
+
+	for (i=0;i<tmpPairs.size();i++)
+	{
+		removeOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1,dispatcher);
+	}
+	
+	for (i = 0; i < m_next.size(); i++)
+	{
+		m_next[i] = BT_NULL_PAIR;
+	}
+
+	tmpPairs.quickSort(btBroadphasePairSortPredicate());
+
+	for (i=0;i<tmpPairs.size();i++)
+	{
+		addOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1);
+	}
+
+	
+}
+
+
+void*	btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher )
+{
+	if (!hasDeferredRemoval())
+	{
+		btBroadphasePair findPair(*proxy0,*proxy1);
+
+		int findIndex = m_overlappingPairArray.findLinearSearch(findPair);
+		if (findIndex < m_overlappingPairArray.size())
+		{
+			gOverlappingPairs--;
+			btBroadphasePair& pair = m_overlappingPairArray[findIndex];
+			void* userData = pair.m_internalInfo1;
+			cleanOverlappingPair(pair,dispatcher);
+			if (m_ghostPairCallback)
+				m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1,dispatcher);
+			
+			m_overlappingPairArray.swap(findIndex,m_overlappingPairArray.capacity()-1);
+			m_overlappingPairArray.pop_back();
+			return userData;
+		}
+	}
+
+	return 0;
+}
+
+
+
+
+
+
+
+
+btBroadphasePair*	btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+{
+	//don't add overlap with own
+	btAssert(proxy0 != proxy1);
+
+	if (!needsBroadphaseCollision(proxy0,proxy1))
+		return 0;
+	
+	void* mem = &m_overlappingPairArray.expandNonInitializing();
+	btBroadphasePair* pair = new (mem) btBroadphasePair(*proxy0,*proxy1);
+	
+	gOverlappingPairs++;
+	gAddedPairs++;
+	
+	if (m_ghostPairCallback)
+		m_ghostPairCallback->addOverlappingPair(proxy0, proxy1);
+	return pair;
+	
+}
+
+///this findPair becomes really slow. Either sort the list to speedup the query, or
+///use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed.
+///we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address)
+///Also we can use a 2D bitmap, which can be useful for a future GPU implementation
+ btBroadphasePair*	btSortedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+{
+	if (!needsBroadphaseCollision(proxy0,proxy1))
+		return 0;
+
+	btBroadphasePair tmpPair(*proxy0,*proxy1);
+	int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair);
+
+	if (findIndex < m_overlappingPairArray.size())
+	{
+		//btAssert(it != m_overlappingPairSet.end());
+		 btBroadphasePair* pair = &m_overlappingPairArray[findIndex];
+		return pair;
+	}
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+//#include <stdio.h>
+
+void	btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
+{
+
+	int i;
+
+	for (i=0;i<m_overlappingPairArray.size();)
+	{
+	
+		btBroadphasePair* pair = &m_overlappingPairArray[i];
+		if (callback->processOverlap(*pair))
+		{
+			cleanOverlappingPair(*pair,dispatcher);
+			pair->m_pProxy0 = 0;
+			pair->m_pProxy1 = 0;
+			m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+			m_overlappingPairArray.pop_back();
+			gOverlappingPairs--;
+		} else
+		{
+			i++;
+		}
+	}
+}
+
+
+
+
+btSortedOverlappingPairCache::btSortedOverlappingPairCache():
+	m_blockedForChanges(false),
+	m_hasDeferredRemoval(true),
+	m_overlapFilterCallback(0),
+	m_ghostPairCallback(0)
+{
+	int initialAllocatedSize= 2;
+	m_overlappingPairArray.reserve(initialAllocatedSize);
+}
+
+btSortedOverlappingPairCache::~btSortedOverlappingPairCache()
+{
+}
+
+void	btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
+{
+	if (pair.m_algorithm)
+	{
+		{
+			pair.m_algorithm->~btCollisionAlgorithm();
+			dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
+			pair.m_algorithm=0;
+			gRemovePairs--;
+		}
+	}
+}
+
+
+void	btSortedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+{
+
+	class	CleanPairCallback : public btOverlapCallback
+	{
+		btBroadphaseProxy* m_cleanProxy;
+		btOverlappingPairCache*	m_pairCache;
+		btDispatcher* m_dispatcher;
+
+	public:
+		CleanPairCallback(btBroadphaseProxy* cleanProxy,btOverlappingPairCache* pairCache,btDispatcher* dispatcher)
+			:m_cleanProxy(cleanProxy),
+			m_pairCache(pairCache),
+			m_dispatcher(dispatcher)
+		{
+		}
+		virtual	bool	processOverlap(btBroadphasePair& pair)
+		{
+			if ((pair.m_pProxy0 == m_cleanProxy) ||
+				(pair.m_pProxy1 == m_cleanProxy))
+			{
+				m_pairCache->cleanOverlappingPair(pair,m_dispatcher);
+			}
+			return false;
+		}
+		
+	};
+
+	CleanPairCallback cleanPairs(proxy,this,dispatcher);
+
+	processAllOverlappingPairs(&cleanPairs,dispatcher);
+
+}
+
+
+void	btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+{
+
+	class	RemovePairCallback : public btOverlapCallback
+	{
+		btBroadphaseProxy* m_obsoleteProxy;
+
+	public:
+		RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
+			:m_obsoleteProxy(obsoleteProxy)
+		{
+		}
+		virtual	bool	processOverlap(btBroadphasePair& pair)
+		{
+			return ((pair.m_pProxy0 == m_obsoleteProxy) ||
+				(pair.m_pProxy1 == m_obsoleteProxy));
+		}
+		
+	};
+
+	RemovePairCallback removeCallback(proxy);
+
+	processAllOverlappingPairs(&removeCallback,dispatcher);
+}
+
+void	btSortedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
+{
+	//should already be sorted
+}
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

@@ -0,0 +1,470 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_OVERLAPPING_PAIR_CACHE_H
+#define BT_OVERLAPPING_PAIR_CACHE_H
+
+
+#include "btBroadphaseInterface.h"
+#include "btBroadphaseProxy.h"
+#include "btOverlappingPairCallback.h"
+
+#include "LinearMath/btAlignedObjectArray.h"
+class btDispatcher;
+
+typedef btAlignedObjectArray<btBroadphasePair>	btBroadphasePairArray;
+
+struct	btOverlapCallback
+{
+	virtual ~btOverlapCallback()
+	{}
+	//return true for deletion of the pair
+	virtual bool	processOverlap(btBroadphasePair& pair) = 0;
+
+};
+
+struct btOverlapFilterCallback
+{
+	virtual ~btOverlapFilterCallback()
+	{}
+	// return true when pairs need collision
+	virtual bool	needBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const = 0;
+};
+
+
+
+
+
+
+
+extern int gRemovePairs;
+extern int gAddedPairs;
+extern int gFindPairs;
+
+const int BT_NULL_PAIR=0xffffffff;
+
+///The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
+///The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations.
+class btOverlappingPairCache : public btOverlappingPairCallback
+{
+public:
+	virtual ~btOverlappingPairCache() {} // this is needed so we can get to the derived class destructor
+
+	virtual btBroadphasePair*	getOverlappingPairArrayPtr() = 0;
+	
+	virtual const btBroadphasePair*	getOverlappingPairArrayPtr() const = 0;
+
+	virtual btBroadphasePairArray&	getOverlappingPairArray() = 0;
+
+	virtual	void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher) = 0;
+
+	virtual int getNumOverlappingPairs() const = 0;
+
+	virtual void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher) = 0;
+
+	virtual	void setOverlapFilterCallback(btOverlapFilterCallback* callback) = 0;
+
+	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher) = 0;
+
+	virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0;
+
+	virtual bool	hasDeferredRemoval() = 0;
+
+	virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)=0;
+
+	virtual void	sortOverlappingPairs(btDispatcher* dispatcher) = 0;
+
+
+};
+
+/// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
+class btHashedOverlappingPairCache : public btOverlappingPairCache
+{
+	btBroadphasePairArray	m_overlappingPairArray;
+	btOverlapFilterCallback* m_overlapFilterCallback;
+	bool		m_blockedForChanges;
+
+protected:
+	
+	btAlignedObjectArray<int>	m_hashTable;
+	btAlignedObjectArray<int>	m_next;
+	btOverlappingPairCallback*	m_ghostPairCallback;
+
+
+public:
+	btHashedOverlappingPairCache();
+	virtual ~btHashedOverlappingPairCache();
+
+	
+	void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
+
+	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
+	
+	SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
+	{
+		if (m_overlapFilterCallback)
+			return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);
+
+		bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+		collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+		
+		return collides;
+	}
+
+	// Add a pair and return the new pair. If the pair already exists,
+	// no new pair is created and the old one is returned.
+	virtual btBroadphasePair* 	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+	{
+		gAddedPairs++;
+
+		if (!needsBroadphaseCollision(proxy0,proxy1))
+			return 0;
+
+		return internalAddPair(proxy0,proxy1);
+	}
+
+	
+
+	void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
+
+	
+	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
+
+	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	const btBroadphasePair*	getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	btBroadphasePairArray&	getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	const btBroadphasePairArray&	getOverlappingPairArray() const
+	{
+		return m_overlappingPairArray;
+	}
+
+	void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher);
+
+
+
+	btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
+
+	int GetCount() const { return m_overlappingPairArray.size(); }
+//	btBroadphasePair* GetPairs() { return m_pairs; }
+
+	btOverlapFilterCallback* getOverlapFilterCallback()
+	{
+		return m_overlapFilterCallback;
+	}
+
+	void setOverlapFilterCallback(btOverlapFilterCallback* callback)
+	{
+		m_overlapFilterCallback = callback;
+	}
+
+	int	getNumOverlappingPairs() const
+	{
+		return m_overlappingPairArray.size();
+	}
+private:
+	
+	btBroadphasePair* 	internalAddPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
+
+	void	growTables();
+
+	SIMD_FORCE_INLINE bool equalsPair(const btBroadphasePair& pair, int proxyId1, int proxyId2)
+	{	
+		return pair.m_pProxy0->getUid() == proxyId1 && pair.m_pProxy1->getUid() == proxyId2;
+	}
+
+	/*
+	// Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm
+	// This assumes proxyId1 and proxyId2 are 16-bit.
+	SIMD_FORCE_INLINE int getHash(int proxyId1, int proxyId2)
+	{
+		int key = (proxyId2 << 16) | proxyId1;
+		key = ~key + (key << 15);
+		key = key ^ (key >> 12);
+		key = key + (key << 2);
+		key = key ^ (key >> 4);
+		key = key * 2057;
+		key = key ^ (key >> 16);
+		return key;
+	}
+	*/
+
+
+	
+	SIMD_FORCE_INLINE	unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
+	{
+		int key = static_cast<int>(((unsigned int)proxyId1) | (((unsigned int)proxyId2) <<16));
+		// Thomas Wang's hash
+
+		key += ~(key << 15);
+		key ^=  (key >> 10);
+		key +=  (key << 3);
+		key ^=  (key >> 6);
+		key += ~(key << 11);
+		key ^=  (key >> 16);
+		return static_cast<unsigned int>(key);
+	}
+	
+
+
+
+
+	SIMD_FORCE_INLINE btBroadphasePair* internalFindPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, int hash)
+	{
+		int proxyId1 = proxy0->getUid();
+		int proxyId2 = proxy1->getUid();
+		#if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat.
+		if (proxyId1 > proxyId2) 
+			btSwap(proxyId1, proxyId2);
+		#endif
+
+		int index = m_hashTable[hash];
+		
+		while( index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
+		{
+			index = m_next[index];
+		}
+
+		if ( index == BT_NULL_PAIR )
+		{
+			return NULL;
+		}
+
+		btAssert(index < m_overlappingPairArray.size());
+
+		return &m_overlappingPairArray[index];
+	}
+
+	virtual bool	hasDeferredRemoval()
+	{
+		return false;
+	}
+
+	virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)
+	{
+		m_ghostPairCallback = ghostPairCallback;
+	}
+
+	virtual void	sortOverlappingPairs(btDispatcher* dispatcher);
+	
+
+	
+};
+
+
+
+
+///btSortedOverlappingPairCache maintains the objects with overlapping AABB
+///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
+class	btSortedOverlappingPairCache : public btOverlappingPairCache
+{
+	protected:
+		//avoid brute-force finding all the time
+		btBroadphasePairArray	m_overlappingPairArray;
+
+		//during the dispatch, check that user doesn't destroy/create proxy
+		bool		m_blockedForChanges;
+
+		///by default, do the removal during the pair traversal
+		bool		m_hasDeferredRemoval;
+		
+		//if set, use the callback instead of the built in filter in needBroadphaseCollision
+		btOverlapFilterCallback* m_overlapFilterCallback;
+
+		btOverlappingPairCallback*	m_ghostPairCallback;
+
+	public:
+			
+		btSortedOverlappingPairCache();	
+		virtual ~btSortedOverlappingPairCache();
+
+		virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
+
+		void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
+
+		void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher);
+		
+		btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
+
+		btBroadphasePair*	findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
+			
+		
+		void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
+
+		void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
+
+
+		inline bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
+		{
+			if (m_overlapFilterCallback)
+				return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);
+
+			bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+			collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			
+			return collides;
+		}
+		
+		btBroadphasePairArray&	getOverlappingPairArray()
+		{
+			return m_overlappingPairArray;
+		}
+
+		const btBroadphasePairArray&	getOverlappingPairArray() const
+		{
+			return m_overlappingPairArray;
+		}
+
+		
+
+
+		btBroadphasePair*	getOverlappingPairArrayPtr()
+		{
+			return &m_overlappingPairArray[0];
+		}
+
+		const btBroadphasePair*	getOverlappingPairArrayPtr() const
+		{
+			return &m_overlappingPairArray[0];
+		}
+
+		int	getNumOverlappingPairs() const
+		{
+			return m_overlappingPairArray.size();
+		}
+		
+		btOverlapFilterCallback* getOverlapFilterCallback()
+		{
+			return m_overlapFilterCallback;
+		}
+
+		void setOverlapFilterCallback(btOverlapFilterCallback* callback)
+		{
+			m_overlapFilterCallback = callback;
+		}
+
+		virtual bool	hasDeferredRemoval()
+		{
+			return m_hasDeferredRemoval;
+		}
+
+		virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)
+		{
+			m_ghostPairCallback = ghostPairCallback;
+		}
+
+		virtual void	sortOverlappingPairs(btDispatcher* dispatcher);
+		
+
+};
+
+
+
+///btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.
+class btNullPairCache : public btOverlappingPairCache
+{
+
+	btBroadphasePairArray	m_overlappingPairArray;
+
+public:
+
+	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+	const btBroadphasePair*	getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+	btBroadphasePairArray&	getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+	
+	virtual	void	cleanOverlappingPair(btBroadphasePair& /*pair*/,btDispatcher* /*dispatcher*/)
+	{
+
+	}
+
+	virtual int getNumOverlappingPairs() const
+	{
+		return 0;
+	}
+
+	virtual void	cleanProxyFromPairs(btBroadphaseProxy* /*proxy*/,btDispatcher* /*dispatcher*/)
+	{
+
+	}
+
+	virtual	void setOverlapFilterCallback(btOverlapFilterCallback* /*callback*/)
+	{
+	}
+
+	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual btBroadphasePair* findPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/)
+	{
+		return 0;
+	}
+
+	virtual bool	hasDeferredRemoval()
+	{
+		return true;
+	}
+
+	virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* /* ghostPairCallback */)
+	{
+
+	}
+
+	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* /*proxy0*/,btBroadphaseProxy* /*proxy1*/)
+	{
+		return 0;
+	}
+
+	virtual void*	removeOverlappingPair(btBroadphaseProxy* /*proxy0*/,btBroadphaseProxy* /*proxy1*/,btDispatcher* /*dispatcher*/)
+	{
+		return 0;
+	}
+
+	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/,btDispatcher* /*dispatcher*/)
+	{
+	}
+	
+	virtual void	sortOverlappingPairs(btDispatcher* dispatcher)
+	{
+        (void) dispatcher;
+	}
+
+
+};
+
+
+#endif //BT_OVERLAPPING_PAIR_CACHE_H
+
+

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h

@@ -0,0 +1,40 @@
+
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef OVERLAPPING_PAIR_CALLBACK_H
+#define OVERLAPPING_PAIR_CALLBACK_H
+
+class btDispatcher;
+struct  btBroadphasePair;
+
+///The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache.
+class btOverlappingPairCallback
+{
+public:
+	virtual ~btOverlappingPairCallback()
+	{
+
+	}
+	
+	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
+
+	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher) = 0;
+
+	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0,btDispatcher* dispatcher) = 0;
+
+};
+
+#endif //OVERLAPPING_PAIR_CALLBACK_H

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btQuantizedBvh.h

@@ -0,0 +1,581 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_QUANTIZED_BVH_H
+#define BT_QUANTIZED_BVH_H
+
+class btSerializer;
+
+//#define DEBUG_CHECK_DEQUANTIZATION 1
+#ifdef DEBUG_CHECK_DEQUANTIZATION
+#ifdef __SPU__
+#define printf spu_printf
+#endif //__SPU__
+
+#include <stdio.h>
+#include <stdlib.h>
+#endif //DEBUG_CHECK_DEQUANTIZATION
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedAllocator.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btQuantizedBvhData btQuantizedBvhDoubleData
+#define btOptimizedBvhNodeData btOptimizedBvhNodeDoubleData
+#define btQuantizedBvhDataName "btQuantizedBvhDoubleData"
+#else
+#define btQuantizedBvhData btQuantizedBvhFloatData
+#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData
+#define btQuantizedBvhDataName "btQuantizedBvhFloatData"
+#endif
+
+
+
+//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp
+
+
+//Note: currently we have 16 bytes per quantized node
+#define MAX_SUBTREE_SIZE_IN_BYTES  2048
+
+// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one
+// actually) triangles each (since the sign bit is reserved
+#define MAX_NUM_PARTS_IN_BITS 10
+
+///btQuantizedBvhNode is a compressed aabb node, 16 bytes.
+///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
+ATTRIBUTE_ALIGNED16	(struct) btQuantizedBvhNode
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//12 bytes
+	unsigned short int	m_quantizedAabbMin[3];
+	unsigned short int	m_quantizedAabbMax[3];
+	//4 bytes
+	int	m_escapeIndexOrTriangleIndex;
+
+	bool isLeafNode() const
+	{
+		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+		return (m_escapeIndexOrTriangleIndex >= 0);
+	}
+	int getEscapeIndex() const
+	{
+		btAssert(!isLeafNode());
+		return -m_escapeIndexOrTriangleIndex;
+	}
+	int	getTriangleIndex() const
+	{
+		btAssert(isLeafNode());
+		unsigned int x=0;
+		unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);
+		// Get only the lower bits where the triangle index is stored
+		return (m_escapeIndexOrTriangleIndex&~(y));
+	}
+	int	getPartId() const
+	{
+		btAssert(isLeafNode());
+		// Get only the highest bits where the part index is stored
+		return (m_escapeIndexOrTriangleIndex>>(31-MAX_NUM_PARTS_IN_BITS));
+	}
+}
+;
+
+/// btOptimizedBvhNode contains both internal and leaf node information.
+/// Total node size is 44 bytes / node. You can use the compressed version of 16 bytes.
+ATTRIBUTE_ALIGNED16 (struct) btOptimizedBvhNode
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//32 bytes
+	btVector3	m_aabbMinOrg;
+	btVector3	m_aabbMaxOrg;
+
+	//4
+	int	m_escapeIndex;
+
+	//8
+	//for child nodes
+	int	m_subPart;
+	int	m_triangleIndex;
+
+//pad the size to 64 bytes
+	char	m_padding[20];
+};
+
+
+///btBvhSubtreeInfo provides info to gather a subtree of limited size
+ATTRIBUTE_ALIGNED16(class) btBvhSubtreeInfo
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//12 bytes
+	unsigned short int	m_quantizedAabbMin[3];
+	unsigned short int	m_quantizedAabbMax[3];
+	//4 bytes, points to the root of the subtree
+	int			m_rootNodeIndex;
+	//4 bytes
+	int			m_subtreeSize;
+	int			m_padding[3];
+
+	btBvhSubtreeInfo()
+	{
+		//memset(&m_padding[0], 0, sizeof(m_padding));
+	}
+
+
+	void	setAabbFromQuantizeNode(const btQuantizedBvhNode& quantizedNode)
+	{
+		m_quantizedAabbMin[0] = quantizedNode.m_quantizedAabbMin[0];
+		m_quantizedAabbMin[1] = quantizedNode.m_quantizedAabbMin[1];
+		m_quantizedAabbMin[2] = quantizedNode.m_quantizedAabbMin[2];
+		m_quantizedAabbMax[0] = quantizedNode.m_quantizedAabbMax[0];
+		m_quantizedAabbMax[1] = quantizedNode.m_quantizedAabbMax[1];
+		m_quantizedAabbMax[2] = quantizedNode.m_quantizedAabbMax[2];
+	}
+}
+;
+
+
+class btNodeOverlapCallback
+{
+public:
+	virtual ~btNodeOverlapCallback() {};
+
+	virtual void processNode(int subPart, int triangleIndex) = 0;
+};
+
+#include "LinearMath/btAlignedAllocator.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+
+
+///for code readability:
+typedef btAlignedObjectArray<btOptimizedBvhNode>	NodeArray;
+typedef btAlignedObjectArray<btQuantizedBvhNode>	QuantizedNodeArray;
+typedef btAlignedObjectArray<btBvhSubtreeInfo>		BvhSubtreeInfoArray;
+
+
+///The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU.
+///It is used by the btBvhTriangleMeshShape as midphase, and by the btMultiSapBroadphase.
+///It is recommended to use quantization for better performance and lower memory requirements.
+ATTRIBUTE_ALIGNED16(class) btQuantizedBvh
+{
+public:
+	enum btTraversalMode
+	{
+		TRAVERSAL_STACKLESS = 0,
+		TRAVERSAL_STACKLESS_CACHE_FRIENDLY,
+		TRAVERSAL_RECURSIVE
+	};
+
+protected:
+
+
+	btVector3			m_bvhAabbMin;
+	btVector3			m_bvhAabbMax;
+	btVector3			m_bvhQuantization;
+
+	int					m_bulletVersion;	//for serialization versioning. It could also be used to detect endianess.
+
+	int					m_curNodeIndex;
+	//quantization data
+	bool				m_useQuantization;
+
+
+
+	NodeArray			m_leafNodes;
+	NodeArray			m_contiguousNodes;
+	QuantizedNodeArray	m_quantizedLeafNodes;
+	QuantizedNodeArray	m_quantizedContiguousNodes;
+	
+	btTraversalMode	m_traversalMode;
+	BvhSubtreeInfoArray		m_SubtreeHeaders;
+
+	//This is only used for serialization so we don't have to add serialization directly to btAlignedObjectArray
+	mutable int m_subtreeHeaderCount;
+
+	
+
+
+
+	///two versions, one for quantized and normal nodes. This allows code-reuse while maintaining readability (no template/macro!)
+	///this might be refactored into a virtual, it is usually not calculated at run-time
+	void	setInternalNodeAabbMin(int nodeIndex, const btVector3& aabbMin)
+	{
+		if (m_useQuantization)
+		{
+			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0] ,aabbMin,0);
+		} else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin;
+
+		}
+	}
+	void	setInternalNodeAabbMax(int nodeIndex,const btVector3& aabbMax)
+	{
+		if (m_useQuantization)
+		{
+			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0],aabbMax,1);
+		} else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax;
+		}
+	}
+
+	btVector3 getAabbMin(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]);
+		}
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMinOrg;
+
+	}
+	btVector3 getAabbMax(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]);
+		} 
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMaxOrg;
+		
+	}
+
+	
+	void	setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex)
+	{
+		if (m_useQuantization)
+		{
+			m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex;
+		} 
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex;
+		}
+
+	}
+
+	void mergeInternalNodeAabb(int nodeIndex,const btVector3& newAabbMin,const btVector3& newAabbMax) 
+	{
+		if (m_useQuantization)
+		{
+			unsigned short int quantizedAabbMin[3];
+			unsigned short int quantizedAabbMax[3];
+			quantize(quantizedAabbMin,newAabbMin,0);
+			quantize(quantizedAabbMax,newAabbMax,1);
+			for (int i=0;i<3;i++)
+			{
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i];
+
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i];
+
+			}
+		} else
+		{
+			//non-quantized
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin);
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax);		
+		}
+	}
+
+	void	swapLeafNodes(int firstIndex,int secondIndex);
+
+	void	assignInternalNodeFromLeafNode(int internalNode,int leafNodeIndex);
+
+protected:
+
+	
+
+	void	buildTree	(int startIndex,int endIndex);
+
+	int	calcSplittingAxis(int startIndex,int endIndex);
+
+	int	sortAndCalcSplittingIndex(int startIndex,int endIndex,int splitAxis);
+	
+	void	walkStacklessTree(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
+
+	void	walkStacklessQuantizedTreeAgainstRay(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex,int endNodeIndex) const;
+	void	walkStacklessQuantizedTree(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax,int startNodeIndex,int endNodeIndex) const;
+	void	walkStacklessTreeAgainstRay(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex,int endNodeIndex) const;
+
+	///tree traversal designed for small-memory processors like PS3 SPU
+	void	walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void	walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode,btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void	walkRecursiveQuantizedTreeAgainstQuantizedTree(const btQuantizedBvhNode* treeNodeA,const btQuantizedBvhNode* treeNodeB,btNodeOverlapCallback* nodeCallback) const;
+	
+
+
+
+	void	updateSubtreeHeaders(int leftChildNodexIndex,int rightChildNodexIndex);
+
+public:
+	
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btQuantizedBvh();
+
+	virtual ~btQuantizedBvh();
+
+	
+	///***************************************** expert/internal use only *************************
+	void	setQuantizationValues(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax,btScalar quantizationMargin=btScalar(1.0));
+	QuantizedNodeArray&	getLeafNodeArray() {			return	m_quantizedLeafNodes;	}
+	///buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized
+	void	buildInternal();
+	///***************************************** expert/internal use only *************************
+
+	void	reportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
+	void	reportRayOverlappingNodex (btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget) const;
+	void	reportBoxCastOverlappingNodex(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin,const btVector3& aabbMax) const;
+
+		SIMD_FORCE_INLINE void quantize(unsigned short* out, const btVector3& point,int isMax) const
+	{
+
+		btAssert(m_useQuantization);
+
+		btAssert(point.getX() <= m_bvhAabbMax.getX());
+		btAssert(point.getY() <= m_bvhAabbMax.getY());
+		btAssert(point.getZ() <= m_bvhAabbMax.getZ());
+
+		btAssert(point.getX() >= m_bvhAabbMin.getX());
+		btAssert(point.getY() >= m_bvhAabbMin.getY());
+		btAssert(point.getZ() >= m_bvhAabbMin.getZ());
+
+		btVector3 v = (point - m_bvhAabbMin) * m_bvhQuantization;
+		///Make sure rounding is done in a way that unQuantize(quantizeWithClamp(...)) is conservative
+		///end-points always set the first bit, so that they are sorted properly (so that neighbouring AABBs overlap properly)
+		///@todo: double-check this
+		if (isMax)
+		{
+			out[0] = (unsigned short) (((unsigned short)(v.getX()+btScalar(1.)) | 1));
+			out[1] = (unsigned short) (((unsigned short)(v.getY()+btScalar(1.)) | 1));
+			out[2] = (unsigned short) (((unsigned short)(v.getZ()+btScalar(1.)) | 1));
+		} else
+		{
+			out[0] = (unsigned short) (((unsigned short)(v.getX()) & 0xfffe));
+			out[1] = (unsigned short) (((unsigned short)(v.getY()) & 0xfffe));
+			out[2] = (unsigned short) (((unsigned short)(v.getZ()) & 0xfffe));
+		}
+
+
+#ifdef DEBUG_CHECK_DEQUANTIZATION
+		btVector3 newPoint = unQuantize(out);
+		if (isMax)
+		{
+			if (newPoint.getX() < point.getX())
+			{
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n",newPoint.getX()-point.getX(), newPoint.getX(),point.getX());
+			}
+			if (newPoint.getY() < point.getY())
+			{
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n",newPoint.getY()-point.getY(), newPoint.getY(),point.getY());
+			}
+			if (newPoint.getZ() < point.getZ())
+			{
+
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n",newPoint.getZ()-point.getZ(), newPoint.getZ(),point.getZ());
+			}
+		} else
+		{
+			if (newPoint.getX() > point.getX())
+			{
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n",newPoint.getX()-point.getX(), newPoint.getX(),point.getX());
+			}
+			if (newPoint.getY() > point.getY())
+			{
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n",newPoint.getY()-point.getY(), newPoint.getY(),point.getY());
+			}
+			if (newPoint.getZ() > point.getZ())
+			{
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n",newPoint.getZ()-point.getZ(), newPoint.getZ(),point.getZ());
+			}
+		}
+#endif //DEBUG_CHECK_DEQUANTIZATION
+
+	}
+
+
+	SIMD_FORCE_INLINE void quantizeWithClamp(unsigned short* out, const btVector3& point2,int isMax) const
+	{
+
+		btAssert(m_useQuantization);
+
+		btVector3 clampedPoint(point2);
+		clampedPoint.setMax(m_bvhAabbMin);
+		clampedPoint.setMin(m_bvhAabbMax);
+
+		quantize(out,clampedPoint,isMax);
+
+	}
+	
+	SIMD_FORCE_INLINE btVector3	unQuantize(const unsigned short* vecIn) const
+	{
+			btVector3	vecOut;
+			vecOut.setValue(
+			(btScalar)(vecIn[0]) / (m_bvhQuantization.getX()),
+			(btScalar)(vecIn[1]) / (m_bvhQuantization.getY()),
+			(btScalar)(vecIn[2]) / (m_bvhQuantization.getZ()));
+			vecOut += m_bvhAabbMin;
+			return vecOut;
+	}
+
+	///setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees.
+	void	setTraversalMode(btTraversalMode	traversalMode)
+	{
+		m_traversalMode = traversalMode;
+	}
+
+
+	SIMD_FORCE_INLINE QuantizedNodeArray&	getQuantizedNodeArray()
+	{	
+		return	m_quantizedContiguousNodes;
+	}
+
+
+	SIMD_FORCE_INLINE BvhSubtreeInfoArray&	getSubtreeInfoArray()
+	{
+		return m_SubtreeHeaders;
+	}
+
+////////////////////////////////////////////////////////////////////
+
+	/////Calculate space needed to store BVH for serialization
+	unsigned calculateSerializeBufferSize() const;
+
+	/// Data buffer MUST be 16 byte aligned
+	virtual bool serialize(void *o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const;
+
+	///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place'
+	static btQuantizedBvh *deSerializeInPlace(void *i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian);
+
+	static unsigned int getAlignmentSerializationPadding();
+//////////////////////////////////////////////////////////////////////
+
+	
+	virtual	int	calculateSerializeBufferSizeNew() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual	const char*	serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	virtual	void deSerializeFloat(struct btQuantizedBvhFloatData& quantizedBvhFloatData);
+
+	virtual	void deSerializeDouble(struct btQuantizedBvhDoubleData& quantizedBvhDoubleData);
+
+
+////////////////////////////////////////////////////////////////////
+
+	SIMD_FORCE_INLINE bool isQuantized()
+	{
+		return m_useQuantization;
+	}
+
+private:
+	// Special "copy" constructor that allows for in-place deserialization
+	// Prevents btVector3's default constructor from being called, but doesn't inialize much else
+	// ownsMemory should most likely be false if deserializing, and if you are not, don't call this (it also changes the function signature, which we need)
+	btQuantizedBvh(btQuantizedBvh &other, bool ownsMemory);
+
+}
+;
+
+
+struct	btBvhSubtreeInfoData
+{
+	int			m_rootNodeIndex;
+	int			m_subtreeSize;
+	unsigned short m_quantizedAabbMin[3];
+	unsigned short m_quantizedAabbMax[3];
+};
+
+struct btOptimizedBvhNodeFloatData
+{
+	btVector3FloatData	m_aabbMinOrg;
+	btVector3FloatData	m_aabbMaxOrg;
+	int	m_escapeIndex;
+	int	m_subPart;
+	int	m_triangleIndex;
+	char m_pad[4];
+};
+
+struct btOptimizedBvhNodeDoubleData
+{
+	btVector3DoubleData	m_aabbMinOrg;
+	btVector3DoubleData	m_aabbMaxOrg;
+	int	m_escapeIndex;
+	int	m_subPart;
+	int	m_triangleIndex;
+	char	m_pad[4];
+};
+
+
+struct btQuantizedBvhNodeData
+{
+	unsigned short m_quantizedAabbMin[3];
+	unsigned short m_quantizedAabbMax[3];
+	int	m_escapeIndexOrTriangleIndex;
+};
+
+struct	btQuantizedBvhFloatData
+{
+	btVector3FloatData			m_bvhAabbMin;
+	btVector3FloatData			m_bvhAabbMax;
+	btVector3FloatData			m_bvhQuantization;
+	int					m_curNodeIndex;
+	int					m_useQuantization;
+	int					m_numContiguousLeafNodes;
+	int					m_numQuantizedContiguousNodes;
+	btOptimizedBvhNodeFloatData	*m_contiguousNodesPtr;
+	btQuantizedBvhNodeData		*m_quantizedContiguousNodesPtr;
+	btBvhSubtreeInfoData	*m_subTreeInfoPtr;
+	int					m_traversalMode;
+	int					m_numSubtreeHeaders;
+	
+};
+
+struct	btQuantizedBvhDoubleData
+{
+	btVector3DoubleData			m_bvhAabbMin;
+	btVector3DoubleData			m_bvhAabbMax;
+	btVector3DoubleData			m_bvhQuantization;
+	int							m_curNodeIndex;
+	int							m_useQuantization;
+	int							m_numContiguousLeafNodes;
+	int							m_numQuantizedContiguousNodes;
+	btOptimizedBvhNodeDoubleData	*m_contiguousNodesPtr;
+	btQuantizedBvhNodeData			*m_quantizedContiguousNodesPtr;
+
+	int							m_traversalMode;
+	int							m_numSubtreeHeaders;
+	btBvhSubtreeInfoData		*m_subTreeInfoPtr;
+};
+
+
+SIMD_FORCE_INLINE	int	btQuantizedBvh::calculateSerializeBufferSizeNew() const
+{
+	return sizeof(btQuantizedBvhData);
+}
+
+
+
+#endif //BT_QUANTIZED_BVH_H

Code/Physics/Bullet Source/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp

@@ -0,0 +1,349 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btSimpleBroadphase.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "LinearMath/btAabbUtil2.h"
+
+#include <new>
+
+extern int gOverlappingPairs;
+
+void	btSimpleBroadphase::validate()
+{
+	for (int i=0;i<m_numHandles;i++)
+	{
+		for (int j=i+1;j<m_numHandles;j++)
+		{
+			btAssert(&m_pHandles[i] != &m_pHandles[j]);
+		}
+	}
+	
+}
+
+btSimpleBroadphase::btSimpleBroadphase(int maxProxies, btOverlappingPairCache* overlappingPairCache)
+	:m_pairCache(overlappingPairCache),
+	m_ownsPairCache(false),
+	m_invalidPair(0)
+{
+
+	if (!overlappingPairCache)
+	{
+		void* mem = btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16);
+		m_pairCache = new (mem)btHashedOverlappingPairCache();
+		m_ownsPairCache = true;
+	}
+
+	// allocate handles buffer and put all handles on free list
+	m_pHandlesRawPtr = btAlignedAlloc(sizeof(btSimpleBroadphaseProxy)*maxProxies,16);
+	m_pHandles = new(m_pHandlesRawPtr) btSimpleBroadphaseProxy[maxProxies];
+	m_maxHandles = maxProxies;
+	m_numHandles = 0;
+	m_firstFreeHandle = 0;
+	m_LastHandleIndex = -1;
+	
+
+	{
+		for (int i = m_firstFreeHandle; i < maxProxies; i++)
+		{
+			m_pHandles[i].SetNextFree(i + 1);
+			m_pHandles[i].m_uniqueId = i+2;//any UID will do, we just avoid too trivial values (0,1) for debugging purposes
+		}
+		m_pHandles[maxProxies - 1].SetNextFree(0);
+	
+	}
+
+}
+
+btSimpleBroadphase::~btSimpleBroadphase()
+{
+	btAlignedFree(m_pHandlesRawPtr);
+
+	if (m_ownsPairCache)
+	{
+		m_pairCache->~btOverlappingPairCache();
+		btAlignedFree(m_pairCache);
+	}
+}
+
+
+btBroadphaseProxy*	btSimpleBroadphase::createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* /*dispatcher*/,void* multiSapProxy)
+{
+	if (m_numHandles >= m_maxHandles)
+	{
+		btAssert(0);
+		return 0; //should never happen, but don't let the game crash ;-)
+	}
+	btAssert(aabbMin[0]<= aabbMax[0] && aabbMin[1]<= aabbMax[1] && aabbMin[2]<= aabbMax[2]);
+
+	int newHandleIndex = allocHandle();
+	btSimpleBroadphaseProxy* proxy = new (&m_pHandles[newHandleIndex])btSimpleBroadphaseProxy(aabbMin,aabbMax,shapeType,userPtr,collisionFilterGroup,collisionFilterMask,multiSapProxy);
+
+	return proxy;
+}
+
+class	RemovingOverlapCallback : public btOverlapCallback
+{
+protected:
+	virtual bool	processOverlap(btBroadphasePair& pair)
+	{
+		(void)pair;
+		btAssert(0);
+		return false;
+	}
+};
+
+class RemovePairContainingProxy
+{
+
+	btBroadphaseProxy*	m_targetProxy;
+	public:
+	virtual ~RemovePairContainingProxy()
+	{
+	}
+protected:
+	virtual bool processOverlap(btBroadphasePair& pair)
+	{
+		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy0);
+		btSimpleBroadphaseProxy* proxy1 = static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy1);
+
+		return ((m_targetProxy == proxy0 || m_targetProxy == proxy1));
+	};
+};
+
+void	btSimpleBroadphase::destroyProxy(btBroadphaseProxy* proxyOrg,btDispatcher* dispatcher)
+{
+		
+		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxyOrg);
+		freeHandle(proxy0);
+
+		m_pairCache->removeOverlappingPairsContainingProxy(proxyOrg,dispatcher);
+
+		//validate();
+		
+}
+
+void	btSimpleBroadphase::getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const
+{
+	const btSimpleBroadphaseProxy* sbp = getSimpleProxyFromProxy(proxy);
+	aabbMin = sbp->m_aabbMin;
+	aabbMax = sbp->m_aabbMax;
+}
+
+void	btSimpleBroadphase::setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* /*dispatcher*/)
+{
+	btSimpleBroadphaseProxy* sbp = getSimpleProxyFromProxy(proxy);
+	sbp->m_aabbMin = aabbMin;
+	sbp->m_aabbMax = aabbMax;
+}
+
+void	btSimpleBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin,const btVector3& aabbMax)
+{
+	for (int i=0; i <= m_LastHandleIndex; i++)
+	{
+		btSimpleBroadphaseProxy* proxy = &m_pHandles[i];
+		if(!proxy->m_clientObject)
+		{
+			continue;
+		}
+		rayCallback.process(proxy);
+	}
+}
+
+
+void	btSimpleBroadphase::aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback)
+{
+	for (int i=0; i <= m_LastHandleIndex; i++)
+	{
+		btSimpleBroadphaseProxy* proxy = &m_pHandles[i];
+		if(!proxy->m_clientObject)
+		{
+			continue;
+		}
+		if (TestAabbAgainstAabb2(aabbMin,aabbMax,proxy->m_aabbMin,proxy->m_aabbMax))
+		{
+			callback.process(proxy);
+		}
+	}
+}
+
+
+
+	
+
+
+
+bool	btSimpleBroadphase::aabbOverlap(btSimpleBroadphaseProxy* proxy0,btSimpleBroadphaseProxy* proxy1)
+{
+	return proxy0->m_aabbMin[0] <= proxy1->m_aabbMax[0] && proxy1->m_aabbMin[0] <= proxy0->m_aabbMax[0] && 
+		   proxy0->m_aabbMin[1] <= proxy1->m_aabbMax[1] && proxy1->m_aabbMin[1] <= proxy0->m_aabbMax[1] &&
+		   proxy0->m_aabbMin[2] <= proxy1->m_aabbMax[2] && proxy1->m_aabbMin[2] <= proxy0->m_aabbMax[2];
+
+}
+
+
+
+//then remove non-overlapping ones
+class CheckOverlapCallback : public btOverlapCallback
+{
+public:
+	virtual bool processOverlap(btBroadphasePair& pair)
+	{
+		return (!btSimpleBroadphase::aabbOverlap(static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy0),static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy1)));
+	}
+};
+
+void	btSimpleBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
+{
+	//first check for new overlapping pairs
+	int i,j;
+	if (m_numHandles >= 0)
+	{
+		int new_largest_index = -1;
+		for (i=0; i <= m_LastHandleIndex; i++)
+		{
+			btSimpleBroadphaseProxy* proxy0 = &m_pHandles[i];
+			if(!proxy0->m_clientObject)
+			{
+				continue;
+			}
+			new_largest_index = i;
+			for (j=i+1; j <= m_LastHandleIndex; j++)
+			{
+				btSimpleBroadphaseProxy* proxy1 = &m_pHandles[j];
+				btAssert(proxy0 != proxy1);
+				if(!proxy1->m_clientObject)
+				{
+					continue;
+				}
+
+				btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0);
+				btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1);
+
+				if (aabbOverlap(p0,p1))
+				{
+					if ( !m_pairCache->findPair(proxy0,proxy1))
+					{
+						m_pairCache->addOverlappingPair(proxy0,proxy1);
+					}
+				} else
+				{
+					if (!m_pairCache->hasDeferredRemoval())
+					{
+						if ( m_pairCache->findPair(proxy0,proxy1))
+						{
+							m_pairCache->removeOverlappingPair(proxy0,proxy1,dispatcher);
+						}
+					}
+				}
+			}
+		}
+
+		m_LastHandleIndex = new_largest_index;
+
+		if (m_ownsPairCache && m_pairCache->hasDeferredRemoval())
+		{
+
+			btBroadphasePairArray&	overlappingPairArray = m_pairCache->getOverlappingPairArray();
+
+			//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
+			overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
+
+			overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
+			m_invalidPair = 0;
+
+
+			btBroadphasePair previousPair;
+			previousPair.m_pProxy0 = 0;
+			previousPair.m_pProxy1 = 0;
+			previousPair.m_algorithm = 0;
+
+
+			for (i=0;i<overlappingPairArray.size();i++)
+			{
+
+				btBroadphasePair& pair = overlappingPairArray[i];
+
+				bool isDuplicate = (pair == previousPair);
+
+				previousPair = pair;
+
+				bool needsRemoval = false;
+
+				if (!isDuplicate)
+				{
+					bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);
+
+					if (hasOverlap)
+					{
+						needsRemoval = false;//callback->processOverlap(pair);
+					} else
+					{
+						needsRemoval = true;
+					}
+				} else
+				{
+					//remove duplicate
+					needsRemoval = true;
+					//should have no algorithm
+					btAssert(!pair.m_algorithm);
+				}
+
+				if (needsRemoval)
+				{
+					m_pairCache->cleanOverlappingPair(pair,dispatcher);
+
+					//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+					//		m_overlappingPairArray.pop_back();
+					pair.m_pProxy0 = 0;
+					pair.m_pProxy1 = 0;
+					m_invalidPair++;
+					gOverlappingPairs--;
+				} 
+
+			}
+
+			///if you don't like to skip the invalid pairs in the array, execute following code:
+#define CLEAN_INVALID_PAIRS 1
+#ifdef CLEAN_INVALID_PAIRS
+
+			//perform a sort, to sort 'invalid' pairs to the end
+			overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
+
+			overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
+			m_invalidPair = 0;
+#endif//CLEAN_INVALID_PAIRS
+
+		}
+	}
+}
+
+
+bool btSimpleBroadphase::testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+{
+	btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0);
+	btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1);
+	return aabbOverlap(p0,p1);
+}
+
+void	btSimpleBroadphase::resetPool(btDispatcher* dispatcher)
+{
+	//not yet
+}