Final project

.gitignore

@@ -43,3 +43,9 @@ Assignment1/CMakeSettings.json
 **/.vs/VSWorkspaceState.json
 .idea/
 cmake-build-debug/
+
+
+Final/SFML-2.4.2
+Final/.vs
+**/.vs/
+**/CMakeSettings.json

CMakeLists.txt

@@ -1,8 +1,6 @@
-cmake_minimum_required(VERSION 3.6)
-project(PhysicallyBasedSimulation LANGUAGES CXX)
-
+cmake_minimum_required(VERSION 3.5.1)
+project(FinalProject LANGUAGES CXX)
 
 add_subdirectory(
-        Final
-)
-
+		Final
+)

Final/CMakeLists.txt

@@ -1,30 +1,37 @@
 cmake_minimum_required(VERSION 3.5.1)
 project(FinalProject LANGUAGES CXX)
 
-set(CMAKE_BUILD_TYPE Debug)
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH})
 
 if(MSVC)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++latest /wd4141")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fp:strict /std:c++latest /wd4141")
 	set(CMAKE_CXX_FLAGS_RELEASE "/Ox /Ot /DNDEBUG")
 else()
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1z -Wall")
 	set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 endif()
 
-set(SOURCE_FILES 
-	${CMAKE_CURRENT_SOURCE_DIR}/Main.cpp
-		${CMAKE_CURRENT_SOURCE_DIR}/Polygon.cpp
+file(GLOB SOURCE_FILES
+    "*.h"
+    "*.cpp"
 )
 
-add_executable(FinalProject ${SOURCE_FILES})
+add_executable(FinalProject ${SOURCE_FILES}  ${HEADERS})
 
 target_include_directories(FinalProject PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH})
+set(SFML_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/SFML-2.4.2)
 
 find_package(SFML 2 REQUIRED network audio graphics window system)
-
-if(SFML_FOUND)
-	include_directories(${SFML_INCLUDE_DIR})
-	target_link_libraries(FinalProject ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
-endif()
+include_directories(${SFML_INCLUDE_DIR})
+target_link_libraries(FinalProject ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
+
+find_package(Eigen3 REQUIRED)
+include_directories(${EIGEN3_INCLUDE_DIR})
+target_link_libraries(FinalProject ${EIGEN3_LIBRARIES} ${EIGEN3_DEPENDENCIES})
+
+FIND_PACKAGE(OpenMP)
+IF(OPENMP_FOUND)
+    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+ENDIF()

Final/Console.hpp

@@ -0,0 +1,122 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+
+#include <iomanip>
+#include <mutex>
+#include <sstream>
+#include <unordered_map>
+
+class console
+{
+public:
+	static console& instance()
+	{
+		static console console;
+		return console;
+	}
+
+	void init()
+	{
+		if (!font.loadFromFile("arial.ttf"))
+		{
+			// error...
+		}
+
+		m_text.setFont(font);
+		m_text.setCharacterSize(12);
+		m_text.setFillColor(sf::Color::White);
+	}
+
+	template<typename T>
+	void set_param(const std::string& name, const T& value)
+	{
+		std::stringstream stm;
+		stm << std::fixed << std::setprecision(2) << value;
+
+		m_params[name] = stm.str();
+		update();
+	}
+
+	void print(sf::RenderWindow& window)
+	{
+		std::lock_guard <decltype(m_lock)> ga{ m_lock };
+
+		window.draw(m_text);
+	}
+
+private:
+    console()
+    {
+
+    }
+
+	void update()
+	{
+		std::stringstream stm;
+
+		for (auto itr : m_params)
+			stm << itr.first + ": " + itr.second << std::endl;
+
+		{
+			std::lock_guard <decltype(m_lock)> ga{ m_lock };
+			m_text.setString(stm.str());
+		}
+	}
+
+	std::mutex m_lock;
+	sf::Text m_text;
+	std::unordered_map<std::string, std::string> m_params;
+	sf::Font font;
+};
+
+template<class SmootherType, class FuncType>
+void measure(const std::string name, SmootherType& smoother, const FuncType& func)
+{
+    using namespace std::chrono;
+    using clock = high_resolution_clock;
+
+    const auto start_frame = clock::now();
+
+    func();
+
+    const auto elapsed = duration_cast<milliseconds>(clock::now() - start_frame);
+
+    smoother.add(static_cast<double>(elapsed.count()));
+
+    console::instance().set_param(name, smoother.get());
+};
+
+template<class FuncType, typename = 
+    std::enable_if_t<std::is_void_v<std::result_of_t<std::decay_t<FuncType>()>>>>
+void measure(const std::string name, const FuncType& func)
+{
+    using namespace std::chrono;
+    using clock = high_resolution_clock;
+
+    const auto start_frame = clock::now();
+
+    func();
+
+    const auto elapsed = duration_cast<milliseconds>(clock::now() - start_frame);
+
+    console::instance().set_param(name, elapsed.count());
+};
+
+template<class FuncType, typename = 
+    std::enable_if_t<!std::is_void_v<std::result_of_t<std::decay_t<FuncType>()>>>>
+auto measure(const std::string name, const FuncType& func)
+{
+    using namespace std::chrono;
+    using clock = high_resolution_clock;
+
+    const auto start_frame = clock::now();
+
+    auto result = func();
+
+    const auto elapsed = duration_cast<milliseconds>(clock::now() - start_frame);
+
+    console::instance().set_param(name, elapsed.count());
+
+    return result;
+};

Final/ContactInfo.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "physical_object.h"
+
+
+class contact_info
+{
+public:
+    contact_info(physical_object& point_owner,
+        const point_t& point,
+        physical_object& line_owner,
+        const line_t& line,
+        const double penetration_depth,
+        const Vector2d& point_of_intersection)
+        : point_owner_(point_owner),
+        point_(point),
+        line_owner_(line_owner),
+        line_(line),
+        penetration_depth_(penetration_depth),
+        point_of_intersection_(point_of_intersection)
+    {
+    }
+
+    physical_object& line_owner() const { return line_owner_; }
+    physical_object& point_owner() const { return point_owner_; }
+
+    const point_t& line_start_point() const { return line_owner_.points()[std::get<0>(line_)]; }
+    const point_t& line_end_point() const { return line_owner_.points()[std::get<1>(line_)]; }
+
+    Vector2d line_start_offset() const { return std::get<0>(line_start_point()); }
+    Vector2d line_end_offset() const { return std::get<0>(line_end_point()); }
+    Vector2d line_offset() const { return (line_start_offset() + line_end_offset()) / 2.0; }
+
+    const point_t& contact_point() const { return point_; }
+    const Vector2d& contact_point_offset() const { return std::get<0>(point_); }
+    const Vector2d& contact_point_velocity() const { return std::get<1>(point_); }
+
+    Vector2d relative_velocity() const
+    {
+        const Vector2d line_velocity =
+            (std::get<1>(line_start_point())
+           + std::get<1>(line_end_point())) / 2.0;
+
+        return contact_point_velocity() - line_velocity;
+    }
+
+    Vector2d normal() const
+    {
+        return ::normal(line_start_offset(), line_end_offset());
+    }
+
+    double penetration_depth() const { return penetration_depth_; }
+
+private:
+	physical_object& point_owner_;
+    point_t point_;
+
+    physical_object& line_owner_;
+    line_t line_;
+
+    double penetration_depth_;
+    Vector2d point_of_intersection_;
+};