6 files changed, 12 insertions, 498 deletions

diff --git a/src/core/AssetManager.cpp b/src/core/AssetManager.cpp
index 14ea677..d263c4a 100644
--- a/src/core/AssetManager.cpp
+++ b/src/core/AssetManager.cpp
@@ -1,4 +1,4 @@
-#include <core/AssetManager.hpp>
+#include <AssetManager.hpp>
 
 namespace fs = std::experimental::filesystem;
 
diff --git a/src/core/AssetManager.hpp b/src/core/AssetManager.hpp
deleted file mode 100644
index 26c7eca..0000000
--- a/src/core/AssetManager.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#pragma once
-
-#include <experimental/filesystem>
-#include <map>
-
-#include <GL/glew.h>
-#include <glm/vec4.hpp>
-#include <nlohmann/json.hpp>
-
-#include <world/Block.hpp>
-#include <graphics/Texture.hpp>
-
-struct TextureCoordinates {
-	TextureCoordinates(float x = -1, float y = -1, float w = -1, float h = -1) : x(x), y(y), w(w), h(h) {}
-
-	bool operator==(const TextureCoordinates &rhs) const {
-		return x == rhs.x &&
-		       y == rhs.y &&
-		       w == rhs.w &&
-		       h == rhs.h;
-	}
-
-	explicit operator bool() const {
-		return !(*this == TextureCoordinates(-1, -1, -1, -1));
-	}
-
-	float x, y, w, h;
-};
-
-struct BlockTextureId {
-	//Block sides: 0 - bottom, 1 - top, 2 - north, 3 - south, 4 - west, 5 - east 6 - every side
-	BlockTextureId(int id = 0, int state = 0, int side = 6) : id(id), state(state), side(side) {}
-
-	int id:9;
-	int state:4;
-	int side:3;
-
-
-	bool operator<(const BlockTextureId &rhs) const {
-		if (id < rhs.id)
-			return true;
-		if (rhs.id < id)
-			return false;
-		if (state < rhs.state)
-			return true;
-		if (rhs.state < state)
-			return false;
-		return side < rhs.side;
-	}
-};
-
-class AssetManager {
-	Texture *textureAtlas;
-	std::map<std::string, Block> assetIds;
-	std::map<std::string, TextureCoordinates> assetTextures;
-	std::map<BlockTextureId,glm::vec4> textureAtlasIndexes;
-public:
-	AssetManager();
-
-	~AssetManager();
-
-	void LoadTextureResources();
-
-	TextureCoordinates GetTextureByAssetName(std::string AssetName);
-
-	std::string GetTextureAssetNameByBlockId(BlockTextureId block);
-
-	GLuint GetTextureAtlas();
-
-	const std::map<BlockTextureId,glm::vec4> &GetTextureAtlasIndexes();
-
-	void LoadIds();
-
-	TextureCoordinates GetTextureByBlock(BlockTextureId block);
-};
diff --git a/src/core/Core.cpp b/src/core/Core.cpp
index e98d204..dcfa890 100644
--- a/src/core/Core.cpp
+++ b/src/core/Core.cpp
@@ -1,6 +1,5 @@
 #include "Core.hpp"
 
-//Core::Core():toRenderMutex("toRender"),availableChunksMutex("availableChunks") {
 Core::Core() {
 	LOG(INFO) << "Core initializing...";
 	InitSfml(900, 450, "AltCraft");
@@ -9,8 +8,8 @@ Core::Core() {
 	glCheckError();
 	client = new NetworkClient("127.0.0.1", 25565, "HelloOne", isRunning);
 	gameState = new GameState(client, isRunning);
-	gameStateLoopThread = std::thread(&Core::UpdateGameState, this);
-	sectionUpdateLoopThread = std::thread(&Core::UpdateSections, this);
+	std::thread loop = std::thread(&Core::UpdateGameState, this);
+	std::swap(loop, gameStateLoopThread);
 	assetManager = new AssetManager;
 	PrepareToRendering();
 	LOG(INFO) << "Core is initialized";
@@ -20,7 +19,6 @@ Core::Core() {
 Core::~Core() {
 	LOG(INFO) << "Core stopping...";
 	gameStateLoopThread.join();
-	sectionUpdateLoopThread.join();
 	delete shader;
 	delete gameState;
 	delete client;
@@ -56,7 +54,6 @@ void Core::Exec() {
 		toWindow << "FPS: " << (1.0f / deltaTime) << " ";
 		toWindow << " (" << deltaTime * 1000 << "ms); ";
 		toWindow << "Tickrate: " << tickRate << " (" << (1.0 / tickRate * 1000) << "ms); ";
-        toWindow << "Sections: " << sectionRate << " (" << (1.0 / sectionRate * 1000) << "ms); ";
 		window->setTitle(toWindow.str());
 
 		HandleEvents();
@@ -64,17 +61,6 @@ void Core::Exec() {
 		glCheckError();
 
 		RenderFrame();
-		if (isRendersShouldBeCreated) {
-			availableChunksMutex.lock();
-			for (auto &it:renders) {
-				auto pair = std::make_pair(it, RenderSection(&gameState->world, it));
-				availableChunks.insert(pair);
-			}
-			renders.clear();
-			availableChunksMutex.unlock();
-			isRendersShouldBeCreated = false;
-			waitRendersCreated.notify_all();
-		}
 
 	}
 }
@@ -112,7 +98,7 @@ void Core::InitSfml(unsigned int WinWidth, unsigned int WinHeight, std::string W
 	contextSetting.depthBits = 24;
 	window = new sf::Window(sf::VideoMode(WinWidth, WinHeight), WinTitle, sf::Style::Default, contextSetting);
 	glCheckError();
-	//window->setVerticalSyncEnabled(true);
+	window->setVerticalSyncEnabled(true);
 	//window->setPosition(sf::Vector2i(sf::VideoMode::getDesktopMode().width / 2, sf::VideoMode::getDesktopMode().height / 2));
 	window->setPosition(sf::Vector2i(sf::VideoMode::getDesktopMode().width / 2 - window->getSize().x / 2,
 	                                 sf::VideoMode::getDesktopMode().height / 2 - window->getSize().y / 2));
@@ -180,6 +166,11 @@ void Core::HandleEvents() {
 					default:
 						break;
 				}
+				/*case sf::Event::MouseWheelScrolled:
+					if (!window->hasFocus())
+						break;
+					camera.ProcessMouseScroll(event.mouseWheelScroll.delta);
+					break;*/
 			default:
 				break;
 		}
@@ -220,16 +211,8 @@ void Core::RenderWorld() {
 
 	glCheckError();
 
-	toRenderMutex.lock();
 	for (auto &render : toRender) {
-		availableChunksMutex.lock();
-		auto iterator = availableChunks.find(render);
-        if (iterator == availableChunks.end()) {
-            availableChunksMutex.unlock();
-            continue;
-        }
-		/*Section &section = *iterator->second.GetSection();
-		//availableChunksMutex.unlock();
+		Section &section = *availableChunks.find(render)->second.GetSection();
 
 		std::vector<Vector> sectionCorners = {
 				Vector(0, 0, 0),
@@ -242,8 +225,8 @@ void Core::RenderWorld() {
 				Vector(16, 16, 16),
 		};
 		bool isBreak = true;
-		glm::mat4 vp = projection * view;
 		for (auto &it:sectionCorners) {
+			glm::mat4 vp = projection * view;
 			glm::vec3 point(section.GetPosition().GetX() * 16 + it.GetX(),
 			                section.GetPosition().GetY() * 16 + it.GetY(),
 			                section.GetPosition().GetZ() * 16 + it.GetZ());
@@ -258,14 +241,10 @@ void Core::RenderWorld() {
 		                           glm::vec3(section.GetPosition().GetX() * 16,
 		                                     section.GetPosition().GetY() * 16,
 		                                     section.GetPosition().GetZ() * 16)) > 30.0f) {
-            availableChunksMutex.unlock();
 			continue;
 		}
-		//availableChunksMutex.lock();*/
-		iterator->second.Render(renderState);
-		availableChunksMutex.unlock();
+		availableChunks.find(render)->second.Render(renderState);
 	}
-	toRenderMutex.unlock();
 	glCheckError();
 }
 
@@ -287,7 +266,6 @@ void Core::PrepareToRendering() {
 }
 
 void Core::UpdateChunksToRender() {
-	return;
 	Vector playerChunk = Vector(floor(gameState->g_PlayerX / 16.0f), 0, floor(gameState->g_PlayerZ / 16.0f));
 	static Vector previousPlayerChunk = playerChunk;
 	static bool firstTime = true;
@@ -332,126 +310,4 @@ void Core::UpdateGameState() {
 		tickRate = 1 / delta.getElapsedTime().asSeconds();
 	}
 	LOG(INFO) << "GameState thread is stopped";
-}
-
-void Core::UpdateSections() {
-	glm::vec3 playerPosition = gameState->Position();
-	float playerPitch = gameState->Pitch();
-	float playerYaw = gameState->Yaw();
-    sf::Clock delta;
-    std::vector<Vector> chunksToRender;
-    auto currentSectionIterator = chunksToRender.begin();
-	while (isRunning) {
-        delta.restart();        
-		if (glm::length(glm::distance(gameState->Position(), playerPosition)) > 5.0f) {
-            chunksToRender.clear();
-			playerPosition = gameState->Position();
-			Vector playerChunk = Vector(floor(playerPosition.x / 16.0f), 0, floor(playerPosition.z / 16.0f));
-			for (auto &it:gameState->world.GetSectionsList()) {
-				Vector chunkPosition = it;
-				chunkPosition.SetY(0);
-				Vector delta = chunkPosition - playerChunk;
-				if (delta.GetMagnitude() > ChunkDistance) continue;
-				chunksToRender.push_back(it);
-			}
-            std::sort(chunksToRender.begin(), chunksToRender.end(), [playerChunk](auto first, auto second) {
-                glm::vec3 fDistance = first - playerChunk;
-                glm::vec3 sDistance = second - playerChunk;
-                return glm::length(fDistance) < glm::length(sDistance);
-            });
-			for (auto &it:chunksToRender) {
-				availableChunksMutex.lock();
-				if (availableChunks.find(it) == availableChunks.end()) {
-					availableChunksMutex.unlock();
-					renders.push_back(it);
-				} else
-                    availableChunksMutex.unlock();
-			}
-			if (!renders.empty()) {
-				std::mutex mutex;
-				std::unique_lock<std::mutex> lock(mutex);
-				isRendersShouldBeCreated = true;
-				while (isRendersShouldBeCreated)
-					waitRendersCreated.wait(lock);
-			}
-            currentSectionIterator = chunksToRender.begin();
-			toRenderMutex.lock();
-			toRender = chunksToRender;
-			toRenderMutex.unlock();
-		}
-        if (currentSectionIterator != chunksToRender.end()) {
-            availableChunksMutex.lock();
-            auto iterator = availableChunks.find(*currentSectionIterator);
-            if (iterator != availableChunks.end() && iterator->second.IsNeedUpdate()) {
-                RenderSection rs = std::move(iterator->second);
-                availableChunks.erase(iterator);
-                auto pair = std::make_pair(*currentSectionIterator, rs);
-                availableChunksMutex.unlock();
-
-                pair.second.UpdateState(assetManager->GetTextureAtlasIndexes());
-
-                availableChunksMutex.lock();
-                availableChunks.insert(pair);
-            }
-            availableChunksMutex.unlock();
-            currentSectionIterator = std::next(currentSectionIterator);
-        }
-		if (gameState->Pitch() != playerPitch || gameState->Yaw() != playerYaw) {
-			playerPitch = gameState->Pitch();
-			playerYaw = gameState->Yaw();
-            const std::vector<Vector> sectionCorners = {
-                Vector(0, 0, 0),
-                Vector(0, 0, 16),
-                Vector(0, 16, 0),
-                Vector(0, 16, 16),
-                Vector(16, 0, 0),
-                Vector(16, 0, 16),
-                Vector(16, 16, 0),
-                Vector(16, 16, 16),
-            };
-            const glm::mat4 projection = glm::perspective(45.0f, (float)width() / (float)height(), 0.1f, 10000000.0f);
-            const glm::mat4 view = gameState->GetViewMatrix();
-            const glm::mat4 vp = projection * view;
-            for (auto& section: toRender) {
-                bool isCulled = true;                
-                for (auto &it : sectionCorners) {
-                    glm::vec3 point(section.GetX() * 16 + it.GetX(), 
-                                    section.GetY() * 16 + it.GetY(),
-                                    section.GetZ() * 16 + it.GetZ());
-                    glm::vec4 p = vp * glm::vec4(point, 1);
-                    glm::vec3 res = glm::vec3(p) / p.w;
-                    if (res.x < 1 && res.x > -1 && res.y < 1 && res.y > -1 && res.z > 0) {
-                        isCulled = false;
-                        break;
-                    }
-                }
-                bool isVisible = !isCulled || glm::length(gameState->Position() -
-                    glm::vec3(section.GetX() * 16, section.GetY() * 16, section.GetZ() * 16)) < 30.0f;      
-                availableChunksMutex.lock();
-                auto iter = availableChunks.find(section);
-                if (iter != availableChunks.end())
-                    iter->second.SetEnabled(isVisible);
-                availableChunksMutex.unlock();
-                
-            }
-		}
-        using namespace std::chrono_literals;
-        std::this_thread::sleep_for(5ms);
-        sectionRate = delta.getElapsedTime().asSeconds();
-        delta.restart();
-	}
-}
-
-MyMutex::MyMutex(std::string name) {
-    str = name;
-}
-
-void MyMutex::lock() {
-    LOG(WARNING) << "Thread " << std::this_thread::get_id() << " locked mutex " << str;
-    mtx.lock();
-}
-
-void MyMutex::unlock() {
-    LOG(WARNING) << "Thread " << std::this_thread::get_id() << " unlocked mutex " << str;
-    mtx.unlock();
 }
\ No newline at end of file
diff --git a/src/core/Core.hpp b/src/core/Core.hpp
deleted file mode 100644
index 039b3a3..0000000
--- a/src/core/Core.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include <iomanip>
-#include <tuple>
-
-#include <easylogging++.h>
-#include <GL/glew.h>
-#include <glm/gtc/type_ptr.hpp>
-#include <SFML/Window.hpp>
-
-#include <world/GameState.hpp>
-#include <core/AssetManager.hpp>
-#include <graphics/Shader.hpp>
-#include <graphics/Gui.hpp>
-#include <graphics/RenderSection.hpp>
-#include <network/NetworkClient.hpp>
-
-struct MyMutex {
-    std::mutex mtx;
-    std::string str;
-    MyMutex(std::string name);
-    void lock();
-    void unlock();
-};
-
-class Core {
-	GameState *gameState;
-	NetworkClient *client;
-	sf::Window *window;
-	AssetManager *assetManager;
-	bool isMouseCaptured = false;
-	bool isRunning = true;
-	enum {
-		MainMenu,
-		Loading,
-		Playing,
-		PauseMenu,
-	} currentState = Playing;
-	float mouseXDelta, mouseYDelta;
-	float deltaTime;
-	float absTime;
-
-	void RenderWorld();
-
-	void HandleMouseCapture();
-
-	void HandleEvents();
-
-	void InitSfml(unsigned int WinWidth, unsigned int WinHeight, std::string WinTitle);
-
-	void InitGlew();
-
-	void SetMouseCapture(bool IsCaptured);
-
-	void PrepareToRendering();
-
-	void RenderFrame();
-
-	unsigned int width();
-
-	unsigned int height();
-
-	void UpdateChunksToRender();
-
-	void UpdateGameState();
-
-	void UpdateSections();
-
-	std::thread gameStateLoopThread;
-	std::thread sectionUpdateLoopThread;
-
-	Shader *shader;
-	//Cube verticies, Cube VAO, Cube UVs, TextureIndexes UboTextureIndexes, TextureData UboTextureIndexes, TextureData2 UboTextureIndexes, Blocks VBO, Models VBO, Line VAO, Lines VBO
-	bool isRendersShouldBeCreated=false;
-	std::condition_variable waitRendersCreated;
-	std::vector<Vector> renders;
-	std::mutex toRenderMutex;
-	std::vector<Vector> toRender;
-	std::map<Vector, RenderSection> availableChunks;
-	std::mutex availableChunksMutex;
-
-	int ChunkDistance = 3;
-
-	RenderState renderState;
-
-	double tickRate = 0;
-    double sectionRate = 0;
-
-public:
-	Core();
-
-	~Core();
-
-	void Exec();
-};
diff --git a/src/core/Event.cpp b/src/core/Event.cpp
deleted file mode 100644
index 10b2eaa..0000000
--- a/src/core/Event.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include <core/Event.hpp>
-#include <easylogging++.h>
-
-std::queue <Event> EventAgregator::eventsToHandle;
-std::mutex EventAgregator::queueMutex;
-bool EventAgregator::isStarted = false;
-std::vector<EventListener*> EventAgregator::listeners;
-std::mutex EventAgregator::listenersMutex;
-
-void EventAgregator::EventHandlingLoop() {
-    while (true) {
-        queueMutex.lock();
-        if (!eventsToHandle.empty()) {
-            auto queue = eventsToHandle;
-            while (!eventsToHandle.empty())
-                eventsToHandle.pop();
-            queueMutex.unlock();
-
-            while (!queue.empty()) {
-                auto event = queue.front();
-                listenersMutex.lock();
-                for (auto& listener : listeners) {
-                    LOG(INFO)<<"Listener notified about event";
-                    listener->PushEvent(event);
-                }
-                listenersMutex.unlock();
-                queue.pop();
-            }
-
-            queueMutex.lock();
-        }
-        queueMutex.unlock();
-    }
-}
-
-void EventAgregator::RegisterListener(EventListener &listener) {
-    listenersMutex.lock();
-    LOG(INFO)<<"Registered handler "<<&listener;
-    listeners.push_back(&listener);
-    listenersMutex.unlock();
-}
-
-void EventAgregator::UnregisterListener(EventListener &listener) {
-    listenersMutex.lock();
-    LOG(INFO)<<"Unregistered handler "<<&listener;
-    listeners.erase(std::find(listeners.begin(), listeners.end(), &listener));
-    listenersMutex.unlock();
-}
-
-
-
-EventListener::EventListener() {
-    EventAgregator::RegisterListener(*this);
-}
-
-EventListener::~EventListener() {
-    EventAgregator::UnregisterListener(*this);
-}
-
-void EventListener::PushEvent(Event event) {
-    eventsMutex.lock();
-    LOG(INFO)<<"Pushed event to queue";
-    events.push(event);
-    eventsMutex.unlock();
-}
-
-/*void EventListener::RegisterHandler(EventType type, std::function<void(void*)> handler) {
-    handlers[type] = handler;
-}*/
-
-bool EventListener::IsEventsQueueIsNotEmpty() {
-    eventsMutex.lock();
-    bool value = !events.empty();
-    eventsMutex.unlock();
-    return value;
-}
\ No newline at end of file
diff --git a/src/core/Event.hpp b/src/core/Event.hpp
deleted file mode 100644
index cfa990a..0000000
--- a/src/core/Event.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#pragma once
-
-#include <queue>
-#include <map>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <chrono>
-#include <variant>
-#include <functional>
-
-#include <Vector.hpp>
-
-enum class EventType {
-	Echo,
-	ChunkChanged,
-};
-
-struct EchoData {
-	std::chrono::time_point<std::chrono::high_resolution_clock> time;
-};
-
-struct ChunkChangedData {
-	Vector chunkPosition;
-};
-
-using EventData = std::variant<EchoData, ChunkChangedData>;
-
-struct Event {
-	EventType type;
-	EventData data;
-};
-
-class EventListener {
-	friend class EventAgregator;
-
-	using HandlerFunc = std::function<void(EventData)>;
-
-	std::map<EventType, HandlerFunc> handlers; //TODO: There must be more elegant solution than std::variant of all data
-
-	std::mutex eventsMutex;
-
-	std::queue<Event> events;
-
-	void PushEvent(Event event);
-
-public:
-	EventListener();
-	~EventListener();
-	bool IsEventsQueueIsNotEmpty();
-
-	void RegisterHandler(EventType type, HandlerFunc handler) {
-		handlers[type] = handler;
-	}
-
-	void HandleEvent() {
-		eventsMutex.lock();
-		if (events.empty()) {
-			eventsMutex.unlock();
-			return;
-		}
-		Event event = events.front();
-		events.pop();
-		eventsMutex.unlock();
-		auto function = handlers[event.type];
-		function(event.data);
-	}
-};
-
-class EventAgregator {
-	friend EventListener;
-
-	EventAgregator() = default;
-	static std::queue<Event> eventsToHandle;
-	static std::mutex queueMutex;
-	static bool isStarted;
-	static std::vector<EventListener *> listeners;
-	static std::mutex listenersMutex;
-
-	static void EventHandlingLoop();
-
-	static void RegisterListener(EventListener &listener);
-	static void UnregisterListener(EventListener &listener);
-
-public:
-	static void PushEvent(EventType type, EventData data) {
-		if (!isStarted) {
-			isStarted = true;
-			std::thread(&EventAgregator::EventHandlingLoop).detach();
-		}
-		Event event;
-		event.type = type;
-		event.data = data;
-		eventsToHandle.push(event);
-	}
-};
\ No newline at end of file