+init

1 files changed, 651 insertions, 0 deletions

diff --git a/Client/ThirdParty/Box2D/testbed/main.cpp b/Client/ThirdParty/Box2D/testbed/main.cpp
new file mode 100644
index 0000000..c5969e3
--- /dev/null
+++ b/Client/ThirdParty/Box2D/testbed/main.cpp
@@ -0,0 +1,651 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#define _CRT_SECURE_NO_WARNINGS
+#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS 1
+
+#include "imgui/imgui.h"
+#include "imgui_impl_glfw.h"
+#include "imgui_impl_opengl3.h"
+#include "draw.h"
+#include "settings.h"
+#include "test.h"
+
+#include <algorithm>
+#include <stdio.h>
+#include <thread>
+#include <chrono>
+
+#if defined(_WIN32)
+#include <crtdbg.h>
+#endif
+
+GLFWwindow* g_mainWindow = nullptr;
+static int32 s_testSelection = 0;
+static Test* s_test = nullptr;
+static Settings s_settings;
+static bool s_rightMouseDown = false;
+static b2Vec2 s_clickPointWS = b2Vec2_zero;
+
+void glfwErrorCallback(int error, const char* description)
+{
+	fprintf(stderr, "GLFW error occured. Code: %d. Description: %s\n", error, description);
+}
+
+static inline bool CompareTests(const TestEntry& a, const TestEntry& b)
+{
+	int result = strcmp(a.category, b.category);
+	if (result == 0)
+	{
+		result = strcmp(a.name, b.name);
+	}
+
+	return result < 0;
+}
+
+static void SortTests()
+{
+	std::sort(g_testEntries, g_testEntries + g_testCount, CompareTests);
+}
+
+static void CreateUI(GLFWwindow* window, const char* glslVersion = NULL)
+{
+	IMGUI_CHECKVERSION();
+	ImGui::CreateContext();
+
+	bool success;
+	success = ImGui_ImplGlfw_InitForOpenGL(window, false);
+	if (success == false)
+	{
+		printf("ImGui_ImplGlfw_InitForOpenGL failed\n");
+		assert(false);
+	}
+
+	success = ImGui_ImplOpenGL3_Init(glslVersion);
+	if (success == false)
+	{
+		printf("ImGui_ImplOpenGL3_Init failed\n");
+		assert(false);
+	}
+
+	// Search for font file
+	const char* fontPath1 = "data/droid_sans.ttf";
+	const char* fontPath2 = "../data/droid_sans.ttf";
+	const char* fontPath = nullptr;
+	FILE* file1 = fopen(fontPath1, "rb");
+	FILE* file2 = fopen(fontPath2, "rb");
+	if (file1)
+	{
+		fontPath = fontPath1;
+		fclose(file1);
+	}
+	
+	if (file2)
+	{
+		fontPath = fontPath2;
+		fclose(file2);
+	}
+
+	if (fontPath)
+	{
+		ImGui::GetIO().Fonts->AddFontFromFileTTF(fontPath, 13.0f);
+	}
+}
+
+static void ResizeWindowCallback(GLFWwindow*, int width, int height)
+{
+	g_camera.m_width = width;
+	g_camera.m_height = height;
+	s_settings.m_windowWidth = width;
+	s_settings.m_windowHeight = height;
+}
+
+static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+	ImGui_ImplGlfw_KeyCallback(window, key, scancode, action, mods);
+	if (ImGui::GetIO().WantCaptureKeyboard)
+	{
+		return;
+	}
+
+	if (action == GLFW_PRESS)
+	{
+		switch (key)
+		{
+		case GLFW_KEY_ESCAPE:
+			// Quit
+			glfwSetWindowShouldClose(g_mainWindow, GL_TRUE);
+			break;
+
+		case GLFW_KEY_LEFT:
+			// Pan left
+			if (mods == GLFW_MOD_CONTROL)
+			{
+				b2Vec2 newOrigin(2.0f, 0.0f);
+				s_test->ShiftOrigin(newOrigin);
+			}
+			else
+			{
+				g_camera.m_center.x -= 0.5f;
+			}
+			break;
+
+		case GLFW_KEY_RIGHT:
+			// Pan right
+			if (mods == GLFW_MOD_CONTROL)
+			{
+				b2Vec2 newOrigin(-2.0f, 0.0f);
+				s_test->ShiftOrigin(newOrigin);
+			}
+			else
+			{
+				g_camera.m_center.x += 0.5f;
+			}
+			break;
+
+		case GLFW_KEY_DOWN:
+			// Pan down
+			if (mods == GLFW_MOD_CONTROL)
+			{
+				b2Vec2 newOrigin(0.0f, 2.0f);
+				s_test->ShiftOrigin(newOrigin);
+			}
+			else
+			{
+				g_camera.m_center.y -= 0.5f;
+			}
+			break;
+
+		case GLFW_KEY_UP:
+			// Pan up
+			if (mods == GLFW_MOD_CONTROL)
+			{
+				b2Vec2 newOrigin(0.0f, -2.0f);
+				s_test->ShiftOrigin(newOrigin);
+			}
+			else
+			{
+				g_camera.m_center.y += 0.5f;
+			}
+			break;
+
+		case GLFW_KEY_HOME:
+			// Reset view
+			g_camera.m_zoom = 1.0f;
+			g_camera.m_center.Set(0.0f, 20.0f);
+			break;
+
+		case GLFW_KEY_Z:
+			// Zoom out
+			g_camera.m_zoom = b2Min(1.1f * g_camera.m_zoom, 20.0f);
+			break;
+
+		case GLFW_KEY_X:
+			// Zoom in
+			g_camera.m_zoom = b2Max(0.9f * g_camera.m_zoom, 0.02f);
+			break;
+
+		case GLFW_KEY_R:
+			// Reset test
+			delete s_test;
+			s_test = g_testEntries[s_settings.m_testIndex].createFcn();
+			break;
+
+		case GLFW_KEY_SPACE:
+			// Launch a bomb.
+			if (s_test)
+			{
+				s_test->LaunchBomb();
+			}
+			break;
+
+		case GLFW_KEY_O:
+			s_settings.m_singleStep = true;
+			break;
+
+		case GLFW_KEY_P:
+			s_settings.m_pause = !s_settings.m_pause;
+			break;
+
+		case GLFW_KEY_LEFT_BRACKET:
+			// Switch to previous test
+			--s_testSelection;
+			if (s_testSelection < 0)
+			{
+				s_testSelection = g_testCount - 1;
+			}
+			break;
+
+		case GLFW_KEY_RIGHT_BRACKET:
+			// Switch to next test
+			++s_testSelection;
+			if (s_testSelection == g_testCount)
+			{
+				s_testSelection = 0;
+			}
+			break;
+
+		case GLFW_KEY_TAB:
+			g_debugDraw.m_showUI = !g_debugDraw.m_showUI;
+
+		default:
+			if (s_test)
+			{
+				s_test->Keyboard(key);
+			}
+		}
+	}
+	else if (action == GLFW_RELEASE)
+	{
+		s_test->KeyboardUp(key);
+	}
+	// else GLFW_REPEAT
+}
+
+static void CharCallback(GLFWwindow* window, unsigned int c)
+{
+	ImGui_ImplGlfw_CharCallback(window, c);
+}
+
+static void MouseButtonCallback(GLFWwindow* window, int32 button, int32 action, int32 mods)
+{
+	ImGui_ImplGlfw_MouseButtonCallback(window, button, action, mods);
+
+	double xd, yd;
+	glfwGetCursorPos(g_mainWindow, &xd, &yd);
+	b2Vec2 ps((float)xd, (float)yd);
+
+	// Use the mouse to move things around.
+	if (button == GLFW_MOUSE_BUTTON_1)
+	{
+        //<##>
+        //ps.Set(0, 0);
+		b2Vec2 pw = g_camera.ConvertScreenToWorld(ps);
+		if (action == GLFW_PRESS)
+		{
+			if (mods == GLFW_MOD_SHIFT)
+			{
+				s_test->ShiftMouseDown(pw);
+			}
+			else
+			{
+				s_test->MouseDown(pw);
+			}
+		}
+		
+		if (action == GLFW_RELEASE)
+		{
+			s_test->MouseUp(pw);
+		}
+	}
+	else if (button == GLFW_MOUSE_BUTTON_2)
+	{
+		if (action == GLFW_PRESS)
+		{	
+			s_clickPointWS = g_camera.ConvertScreenToWorld(ps);
+			s_rightMouseDown = true;
+		}
+
+		if (action == GLFW_RELEASE)
+		{
+			s_rightMouseDown = false;
+		}
+	}
+}
+
+static void MouseMotionCallback(GLFWwindow*, double xd, double yd)
+{
+	b2Vec2 ps((float)xd, (float)yd);
+
+	b2Vec2 pw = g_camera.ConvertScreenToWorld(ps);
+	s_test->MouseMove(pw);
+	
+	if (s_rightMouseDown)
+	{
+		b2Vec2 diff = pw - s_clickPointWS;
+		g_camera.m_center.x -= diff.x;
+		g_camera.m_center.y -= diff.y;
+		s_clickPointWS = g_camera.ConvertScreenToWorld(ps);
+	}
+}
+
+static void ScrollCallback(GLFWwindow* window, double dx, double dy)
+{
+	ImGui_ImplGlfw_ScrollCallback(window, dx, dy);
+	if (ImGui::GetIO().WantCaptureMouse)
+	{
+		return;
+	}
+
+	if (dy > 0)
+	{
+		g_camera.m_zoom /= 1.1f;
+	}
+	else
+	{
+		g_camera.m_zoom *= 1.1f;
+	}
+}
+
+static void RestartTest()
+{
+	delete s_test;
+	s_test = g_testEntries[s_settings.m_testIndex].createFcn();
+}
+
+static void UpdateUI()
+{
+	int menuWidth = 180;
+	if (g_debugDraw.m_showUI)
+	{
+		ImGui::SetNextWindowPos(ImVec2((float)g_camera.m_width - menuWidth - 10, 10));
+		ImGui::SetNextWindowSize(ImVec2((float)menuWidth, (float)g_camera.m_height - 20));
+
+		ImGui::Begin("Tools", &g_debugDraw.m_showUI, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
+
+		if (ImGui::BeginTabBar("ControlTabs", ImGuiTabBarFlags_None))
+		{
+			if (ImGui::BeginTabItem("Controls"))
+			{
+				ImGui::SliderInt("Vel Iters", &s_settings.m_velocityIterations, 0, 50);
+				ImGui::SliderInt("Pos Iters", &s_settings.m_positionIterations, 0, 50);
+				ImGui::SliderFloat("Hertz", &s_settings.m_hertz, 5.0f, 120.0f, "%.0f hz");
+				
+				ImGui::Separator();
+
+				ImGui::Checkbox("Sleep", &s_settings.m_enableSleep);
+				ImGui::Checkbox("Warm Starting", &s_settings.m_enableWarmStarting);
+				ImGui::Checkbox("Time of Impact", &s_settings.m_enableContinuous);
+				ImGui::Checkbox("Sub-Stepping", &s_settings.m_enableSubStepping);
+
+				ImGui::Separator();
+
+				ImGui::Checkbox("Shapes", &s_settings.m_drawShapes);
+				ImGui::Checkbox("Joints", &s_settings.m_drawJoints);
+				ImGui::Checkbox("AABBs", &s_settings.m_drawAABBs);
+				ImGui::Checkbox("Contact Points", &s_settings.m_drawContactPoints);
+				ImGui::Checkbox("Contact Normals", &s_settings.m_drawContactNormals);
+				ImGui::Checkbox("Contact Impulses", &s_settings.m_drawContactImpulse);
+				ImGui::Checkbox("Friction Impulses", &s_settings.m_drawFrictionImpulse);
+				ImGui::Checkbox("Center of Masses", &s_settings.m_drawCOMs);
+				ImGui::Checkbox("Statistics", &s_settings.m_drawStats);
+				ImGui::Checkbox("Profile", &s_settings.m_drawProfile);
+
+				ImVec2 button_sz = ImVec2(-1, 0);
+				if (ImGui::Button("Pause (P)", button_sz))
+				{
+					s_settings.m_pause = !s_settings.m_pause;
+				}
+
+				if (ImGui::Button("Single Step (O)", button_sz))
+				{
+					s_settings.m_singleStep = !s_settings.m_singleStep;
+				}
+
+				if (ImGui::Button("Restart (R)", button_sz))
+				{
+					RestartTest();
+				}
+
+				if (ImGui::Button("Quit", button_sz))
+				{
+					glfwSetWindowShouldClose(g_mainWindow, GL_TRUE);
+				}
+
+				ImGui::EndTabItem();
+			}
+
+			ImGuiTreeNodeFlags leafNodeFlags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick;
+			leafNodeFlags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;
+
+			ImGuiTreeNodeFlags nodeFlags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick;
+
+			if (ImGui::BeginTabItem("Tests"))
+			{
+				int categoryIndex = 0;
+				const char* category = g_testEntries[categoryIndex].category;
+				int i = 0;
+				while (i < g_testCount)
+				{
+					bool categorySelected = strcmp(category, g_testEntries[s_settings.m_testIndex].category) == 0;
+					ImGuiTreeNodeFlags nodeSelectionFlags = categorySelected ? ImGuiTreeNodeFlags_Selected : 0;
+					bool nodeOpen = ImGui::TreeNodeEx(category, nodeFlags | nodeSelectionFlags);
+
+					if (nodeOpen)
+					{
+						while (i < g_testCount && strcmp(category, g_testEntries[i].category) == 0)
+						{
+							ImGuiTreeNodeFlags selectionFlags = 0;
+							if (s_settings.m_testIndex == i)
+							{
+								selectionFlags = ImGuiTreeNodeFlags_Selected;
+							}
+							ImGui::TreeNodeEx((void*)(intptr_t)i, leafNodeFlags | selectionFlags, "%s", g_testEntries[i].name);
+							if (ImGui::IsItemClicked())
+							{
+								delete s_test;
+								s_settings.m_testIndex = i;
+								s_test = g_testEntries[i].createFcn();
+								s_testSelection = i;
+							}
+							++i;
+						}
+						ImGui::TreePop();
+					}
+					else
+					{
+						while (i < g_testCount && strcmp(category, g_testEntries[i].category) == 0)
+						{
+							++i;
+						}
+					}
+
+					if (i < g_testCount)
+					{
+						category = g_testEntries[i].category;
+						categoryIndex = i;
+					}
+				}
+				ImGui::EndTabItem();
+			}
+			ImGui::EndTabBar();
+		}
+
+		ImGui::End();
+
+		s_test->UpdateUI();
+	}
+}
+
+//
+int main(int, char**)
+{
+#if defined(_WIN32)
+	// Enable memory-leak reports
+	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
+#endif
+
+	char buffer[128];
+
+	s_settings.Load();
+	SortTests();
+
+	glfwSetErrorCallback(glfwErrorCallback);
+
+	g_camera.m_width = s_settings.m_windowWidth;
+	g_camera.m_height = s_settings.m_windowHeight;
+
+	if (glfwInit() == 0)
+	{
+		fprintf(stderr, "Failed to initialize GLFW\n");
+		return -1;
+	}
+
+#if __APPLE__
+    const char* glslVersion = "#version 150";
+#else
+    const char* glslVersion = NULL;
+#endif
+
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+	sprintf(buffer, "Box2D Testbed Version %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision);
+
+	bool fullscreen = false;
+	if (fullscreen)
+	{
+		g_mainWindow = glfwCreateWindow(1920, 1080, buffer, glfwGetPrimaryMonitor(), NULL);
+	}
+	else
+	{
+		g_mainWindow = glfwCreateWindow(g_camera.m_width, g_camera.m_height, buffer, NULL, NULL);
+	}
+
+	if (g_mainWindow == NULL)
+	{
+		fprintf(stderr, "Failed to open GLFW g_mainWindow.\n");
+		glfwTerminate();
+		return -1;
+	}
+
+	glfwMakeContextCurrent(g_mainWindow);
+
+	// Load OpenGL functions using glad
+	int version = gladLoadGL(glfwGetProcAddress);
+	printf("GL %d.%d\n", GLAD_VERSION_MAJOR(version), GLAD_VERSION_MINOR(version));
+	printf("OpenGL %s, GLSL %s\n", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION));
+
+	glfwSetScrollCallback(g_mainWindow, ScrollCallback);
+	glfwSetWindowSizeCallback(g_mainWindow, ResizeWindowCallback);
+	glfwSetKeyCallback(g_mainWindow, KeyCallback);
+	glfwSetCharCallback(g_mainWindow, CharCallback);
+	glfwSetMouseButtonCallback(g_mainWindow, MouseButtonCallback);
+	glfwSetCursorPosCallback(g_mainWindow, MouseMotionCallback);
+	glfwSetScrollCallback(g_mainWindow, ScrollCallback);
+
+	g_debugDraw.Create();
+
+	CreateUI(g_mainWindow, glslVersion);
+
+	s_settings.m_testIndex = b2Clamp(s_settings.m_testIndex, 0, g_testCount - 1);
+	s_testSelection = s_settings.m_testIndex;
+	s_test = g_testEntries[s_settings.m_testIndex].createFcn();
+
+	// Control the frame rate. One draw per monitor refresh.
+	//glfwSwapInterval(1);
+
+	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+
+	std::chrono::duration<double> frameTime(0.0);
+	std::chrono::duration<double> sleepAdjust(0.0);
+
+	while (!glfwWindowShouldClose(g_mainWindow))
+	{
+		std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
+
+		glfwGetWindowSize(g_mainWindow, &g_camera.m_width, &g_camera.m_height);
+        
+        int bufferWidth, bufferHeight;
+        glfwGetFramebufferSize(g_mainWindow, &bufferWidth, &bufferHeight);
+        glViewport(0, 0, bufferWidth, bufferHeight);
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		ImGui_ImplOpenGL3_NewFrame();
+		ImGui_ImplGlfw_NewFrame();
+
+		ImGui::NewFrame();
+
+		if (g_debugDraw.m_showUI)
+		{
+			ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
+			ImGui::SetNextWindowSize(ImVec2(float(g_camera.m_width), float(g_camera.m_height)));
+			ImGui::SetNextWindowBgAlpha(0.0f);
+			ImGui::Begin("Overlay", nullptr, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoScrollbar);
+			ImGui::End();
+
+			const TestEntry& entry = g_testEntries[s_settings.m_testIndex];
+			sprintf(buffer, "%s : %s", entry.category, entry.name);
+			s_test->DrawTitle(buffer);
+		}
+
+		s_test->Step(s_settings);
+
+		UpdateUI();
+
+		// ImGui::ShowDemoWindow();
+			
+		if (g_debugDraw.m_showUI)
+		{
+			sprintf(buffer, "%.1f ms", 1000.0 * frameTime.count());
+			g_debugDraw.DrawString(5, g_camera.m_height - 20, buffer);
+		}
+
+		ImGui::Render();
+		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+		glfwSwapBuffers(g_mainWindow);
+
+		if (s_testSelection != s_settings.m_testIndex)
+		{
+			s_settings.m_testIndex = s_testSelection;
+			delete s_test;
+			s_test = g_testEntries[s_settings.m_testIndex].createFcn();
+			g_camera.m_zoom = 1.0f;
+			g_camera.m_center.Set(0.0f, 20.0f);
+		}
+
+		glfwPollEvents();
+
+		// Throttle to cap at 60Hz. This adaptive using a sleep adjustment. This could be improved by
+		// using mm_pause or equivalent for the last millisecond.
+		std::chrono::steady_clock::time_point t2 = std::chrono::steady_clock::now();
+		std::chrono::duration<double> target(1.0 / 60.0);
+		std::chrono::duration<double> timeUsed = t2 - t1;
+		std::chrono::duration<double> sleepTime = target - timeUsed + sleepAdjust;
+		if (sleepTime > std::chrono::duration<double>(0))
+		{
+			std::this_thread::sleep_for(sleepTime);
+		}
+
+		std::chrono::steady_clock::time_point t3 = std::chrono::steady_clock::now();
+		frameTime = t3 - t1;
+
+		// Compute the sleep adjustment using a low pass filter
+		sleepAdjust = 0.9 * sleepAdjust + 0.1 * (target - frameTime);
+	}
+
+	delete s_test;
+	s_test = nullptr;
+
+	g_debugDraw.Destroy();
+	ImGui_ImplOpenGL3_Shutdown();
+	ImGui_ImplGlfw_Shutdown();
+	glfwTerminate();
+
+	s_settings.Save();
+
+	return 0;
+}