summaryrefslogtreecommitdiffstats
path: root/old/core
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--old/core/AssetManager.cpp181
-rw-r--r--old/core/AssetManager.hpp75
-rw-r--r--old/core/Core.cpp457
-rw-r--r--old/core/Core.hpp (renamed from src/core/Core.hpp)12
-rw-r--r--old/core/Event.cpp (renamed from src/core/Event.cpp)2
-rw-r--r--old/core/Event.hpp (renamed from src/core/Event.hpp)2
6 files changed, 721 insertions, 8 deletions
diff --git a/old/core/AssetManager.cpp b/old/core/AssetManager.cpp
new file mode 100644
index 0000000..258f5d9
--- /dev/null
+++ b/old/core/AssetManager.cpp
@@ -0,0 +1,181 @@
+#include "AssetManager.hpp"
+
+namespace fs = std::experimental::filesystem;
+
+//const fs::path pathToAssets = "./assets/";
+//const fs::path pathToAssetsList = "./items.json";
+//const fs::path pathToTextureIndex = "./textures.json";
+const std::string pathToAssetsList = "./items.json";
+const std::string pathToTextureIndex = "./textures.json";
+
+AssetManager::AssetManager() {
+ LoadIds();
+ LoadTextureResources();
+}
+
+void AssetManager::LoadIds() {
+ std::ifstream in(pathToAssetsList);
+ nlohmann::json index;
+ in >> index;
+ for (auto &it:index) {
+ int id = it["type"].get<int>();
+ int state = it["meta"].get<int>();
+ std::string blockName = it["text_type"].get<std::string>();
+ assetIds[blockName] = Block(id, state);
+ }
+ LOG(INFO) << "Loaded " << assetIds.size() << " ids";
+}
+
+AssetManager::~AssetManager() {
+ delete textureAtlas;
+}
+
+//TODO: This function must be replaced with runtime texture atlas generating
+void AssetManager::LoadTextureResources() {
+ std::ifstream in(pathToTextureIndex);
+ nlohmann::json index;
+ in >> index;
+ std::string filename = index["meta"]["image"].get<std::string>();
+ float textureWidth = index["meta"]["size"]["w"].get<int>();
+ float textureHeight = index["meta"]["size"]["h"].get<int>();
+ for (auto &it:index["frames"]) {
+ auto frame = it["frame"];
+ TextureCoordinates coord;
+ coord.x = frame["x"].get<int>() / textureWidth;
+ coord.y = frame["y"].get<int>() / textureHeight;
+ coord.w = frame["w"].get<int>() / textureWidth;
+ coord.h = frame["h"].get<int>() / textureHeight;
+ std::string assetName = it["filename"].get<std::string>();
+ assetName.insert(0, "minecraft/textures/");
+ assetName.erase(assetName.length() - 4);
+ assetTextures[assetName] = coord;
+ }
+
+ textureAtlas = new Texture(filename);
+ LOG(INFO) << "Texture atlas id is " << textureAtlas->texture;
+}
+
+TextureCoordinates AssetManager::GetTextureByAssetName(std::string AssetName) {
+ if (assetTextures.find(AssetName) != assetTextures.end())
+ return assetTextures[AssetName];
+ else
+ return TextureCoordinates{-1, -1, -1, -1};
+}
+
+std::string AssetManager::GetTextureAssetNameByBlockId(BlockTextureId block) {
+ //Block sides: 0 - bottom, 1 - top, 2 - north, 3 - south, 4 - west, 5 - east 6 - every side
+ const std::map<BlockTextureId, std::string> lookupTable = {
+ {BlockTextureId(0, 0), "minecraft/textures/blocks/air"},
+ {BlockTextureId(1, 0), "minecraft/textures/blocks/stone"},
+ {BlockTextureId(1, 1), "minecraft/textures/blocks/stone_granite"},
+
+ {BlockTextureId(2, 0, 0), "minecraft/textures/blocks/dirt"},
+ {BlockTextureId(2, 0, 1), "minecraft/textures/blocks/grass_top"},
+ {BlockTextureId(2, 0, 2), "minecraft/textures/blocks/grass_side"},
+ {BlockTextureId(2, 0, 3), "minecraft/textures/blocks/grass_side"},
+ {BlockTextureId(2, 0, 4), "minecraft/textures/blocks/grass_side"},
+ {BlockTextureId(2, 0, 5), "minecraft/textures/blocks/grass_side"},
+
+ {BlockTextureId(3, 0), "minecraft/textures/blocks/dirt"},
+ {BlockTextureId(4, 0), "minecraft/textures/blocks/cobblestone"},
+ {BlockTextureId(5, 0), "minecraft/textures/blocks/planks"},
+
+ {BlockTextureId(7, 0), "minecraft/textures/blocks/bedrock"},
+
+ {BlockTextureId(17, 0, 0), "minecraft/textures/blocks/log_oak_top"},
+ {BlockTextureId(17, 0, 1), "minecraft/textures/blocks/log_oak_top"},
+ {BlockTextureId(17, 0, 2), "minecraft/textures/blocks/log_oak"},
+ {BlockTextureId(17, 0, 3), "minecraft/textures/blocks/log_oak"},
+ {BlockTextureId(17, 0, 4), "minecraft/textures/blocks/log_oak"},
+ {BlockTextureId(17, 0, 5), "minecraft/textures/blocks/log_oak"},
+
+ {BlockTextureId(17, 1, 0), "minecraft/textures/blocks/log_spruce_top"},
+ {BlockTextureId(17, 1, 1), "minecraft/textures/blocks/log_spruce_top"},
+ {BlockTextureId(17, 1, 2), "minecraft/textures/blocks/log_spruce"},
+ {BlockTextureId(17, 1, 3), "minecraft/textures/blocks/log_spruce"},
+ {BlockTextureId(17, 1, 4), "minecraft/textures/blocks/log_spruce"},
+ {BlockTextureId(17, 1, 5), "minecraft/textures/blocks/log_spruce"},
+
+ {BlockTextureId(17, 2, 0), "minecraft/textures/blocks/log_birch_top"},
+ {BlockTextureId(17, 2, 1), "minecraft/textures/blocks/log_birch_top"},
+ {BlockTextureId(17, 2, 2), "minecraft/textures/blocks/log_birch"},
+ {BlockTextureId(17, 2, 3), "minecraft/textures/blocks/log_birch"},
+ {BlockTextureId(17, 2, 4), "minecraft/textures/blocks/log_birch"},
+ {BlockTextureId(17, 2, 5), "minecraft/textures/blocks/log_birch"},
+
+ {BlockTextureId(17, 3, 0), "minecraft/textures/blocks/log_jungle_top"},
+ {BlockTextureId(17, 3, 1), "minecraft/textures/blocks/log_jungle_top"},
+ {BlockTextureId(17, 3, 2), "minecraft/textures/blocks/log_jungle"},
+ {BlockTextureId(17, 3, 3), "minecraft/textures/blocks/log_jungle"},
+ {BlockTextureId(17, 3, 4), "minecraft/textures/blocks/log_jungle"},
+ {BlockTextureId(17, 3, 5), "minecraft/textures/blocks/log_jungle"},
+
+ {BlockTextureId(18, 0), "minecraft/textures/blocks/leaves_oak"},
+ {BlockTextureId(18, 1), "minecraft/textures/blocks/leaves_spruce"},
+ {BlockTextureId(18, 2), "minecraft/textures/blocks/leaves_birch"},
+ {BlockTextureId(18, 3), "minecraft/textures/blocks/leaves_jungle"},
+
+ {BlockTextureId(61, 0, 0), "minecraft/textures/blocks/furnace_side"},
+ {BlockTextureId(61, 0, 1), "minecraft/textures/blocks/furnace_top"},
+ {BlockTextureId(61, 0, 2), "minecraft/textures/blocks/furnace_front_off"},
+ {BlockTextureId(61, 0, 3), "minecraft/textures/blocks/furnace_side"},
+ {BlockTextureId(61, 0, 4), "minecraft/textures/blocks/furnace_side"},
+ {BlockTextureId(61, 0, 5), "minecraft/textures/blocks/furnace_side"},
+
+ {BlockTextureId(62, 0, 0), "minecraft/textures/blocks/furnace_side"},
+ {BlockTextureId(62, 0, 1), "minecraft/textures/blocks/furnace_top"},
+ {BlockTextureId(62, 0, 2), "minecraft/textures/blocks/furnace_front_on"},
+ {BlockTextureId(62, 0, 3), "minecraft/textures/blocks/furnace_side"},
+ {BlockTextureId(62, 0, 4), "minecraft/textures/blocks/furnace_side"},
+ {BlockTextureId(62, 0, 5), "minecraft/textures/blocks/furnace_side"},
+
+
+ {BlockTextureId(31, 0), "minecraft/textures/blocks/deadbush"},
+ {BlockTextureId(31, 1), "minecraft/textures/blocks/tallgrass"},
+ {BlockTextureId(31, 2), "minecraft/textures/blocks/fern"},
+ };
+ auto ret = lookupTable.find(block);
+ if (ret == lookupTable.end())
+ return "";
+ else
+ return ret->second;
+}
+
+GLuint AssetManager::GetTextureAtlas() {
+ return textureAtlas->texture;
+}
+
+TextureCoordinates AssetManager::GetTextureByBlock(BlockTextureId block) {
+ std::string assetName = this->GetTextureAssetNameByBlockId(block);
+ return this->GetTextureByAssetName(assetName);
+}
+
+const std::map<BlockTextureId, glm::vec4> &AssetManager::GetTextureAtlasIndexes() {
+ if (!textureAtlasIndexes.empty())
+ return textureAtlasIndexes;
+
+ LOG(INFO) << "Initializing texture atlas...";
+ for (int id = 1; id < 128; id++) {
+ for (int state = 0; state < 16; state++) {
+ BlockTextureId blockTextureId(id, state, 6);
+ if (!this->GetTextureByBlock(blockTextureId) &&
+ !this->GetTextureByBlock(BlockTextureId(id, state, 0))) {
+ continue;
+ }
+ if (this->GetTextureByBlock(blockTextureId)) {
+ for (int i = 0; i < 6; i++) {
+ TextureCoordinates tc = this->GetTextureByBlock(BlockTextureId(id, state, 6));
+ textureAtlasIndexes[BlockTextureId(id, state, i)] = glm::vec4(tc.x, tc.y, tc.w, tc.h);
+ }
+ } else {
+ for (int i = 0; i < 6; i++) {
+ TextureCoordinates tc = this->GetTextureByBlock(BlockTextureId(id, state, i));
+ textureAtlasIndexes[BlockTextureId(id, state, i)] = glm::vec4(tc.x, tc.y, tc.w, tc.h);
+ }
+ }
+ }
+ }
+ LOG(INFO) << "Created " << textureAtlasIndexes.size() << " texture indexes";
+
+ return textureAtlasIndexes;
+}
diff --git a/old/core/AssetManager.hpp b/old/core/AssetManager.hpp
new file mode 100644
index 0000000..667140a
--- /dev/null
+++ b/old/core/AssetManager.hpp
@@ -0,0 +1,75 @@
+#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/old/core/Core.cpp b/old/core/Core.cpp
new file mode 100644
index 0000000..e98d204
--- /dev/null
+++ b/old/core/Core.cpp
@@ -0,0 +1,457 @@
+#include "Core.hpp"
+
+//Core::Core():toRenderMutex("toRender"),availableChunksMutex("availableChunks") {
+Core::Core() {
+ LOG(INFO) << "Core initializing...";
+ InitSfml(900, 450, "AltCraft");
+ glCheckError();
+ InitGlew();
+ 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);
+ assetManager = new AssetManager;
+ PrepareToRendering();
+ LOG(INFO) << "Core is initialized";
+ glCheckError();
+}
+
+Core::~Core() {
+ LOG(INFO) << "Core stopping...";
+ gameStateLoopThread.join();
+ sectionUpdateLoopThread.join();
+ delete shader;
+ delete gameState;
+ delete client;
+ delete assetManager;
+ delete window;
+ LOG(INFO) << "Core is stopped";
+}
+
+void Core::Exec() {
+ LOG(INFO) << "Main loop is executing!";
+ isRunning = true;
+ while (isRunning) {
+ static sf::Clock clock, clock1;
+ deltaTime = clock.getElapsedTime().asSeconds();
+ absTime = clock1.getElapsedTime().asSeconds();
+ clock.restart();
+
+ static bool alreadyDone = false;
+ if (gameState->g_IsGameStarted && !alreadyDone) {
+ alreadyDone = true;
+ UpdateChunksToRender();
+ }
+
+ std::ostringstream toWindow;
+ auto camPos = gameState->Position();
+ auto velPos = glm::vec3(gameState->g_PlayerVelocityX, gameState->g_PlayerVelocityY,
+ gameState->g_PlayerVelocityZ);
+ toWindow << std::setprecision(2) << std::fixed;
+ toWindow << "Pos: " << camPos.x << ", " << camPos.y << ", " << camPos.z << "; ";
+ toWindow << "Health: " << gameState->g_PlayerHealth << "; ";
+ //toWindow << "OG: " << gameState->g_OnGround << "; ";
+ toWindow << "Vel: " << velPos.x << ", " << velPos.y << ", " << velPos.z << "; ";
+ 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();
+ if (isMouseCaptured) HandleMouseCapture();
+ 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();
+ }
+
+ }
+}
+
+void Core::RenderFrame() {
+ glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ switch (currentState) {
+ case MainMenu:
+ //RenderGui(MenuScreen);
+ break;
+ case Loading:
+ //RenderGui(LoadingScreen);
+ break;
+ case Playing:
+ RenderWorld();
+ //RenderGui(HUD);
+ break;
+ case PauseMenu:
+ RenderWorld();
+ //RenderGui(PauseGui);
+ break;
+ }
+
+ window->display();
+}
+
+void Core::InitSfml(unsigned int WinWidth, unsigned int WinHeight, std::string WinTitle) {
+ LOG(INFO) << "Creating window: " << WinWidth << "x" << WinHeight << " \"" << WinTitle << "\"";
+ sf::ContextSettings contextSetting;
+ contextSetting.majorVersion = 3;
+ contextSetting.minorVersion = 3;
+ contextSetting.attributeFlags = contextSetting.Core;
+ contextSetting.depthBits = 24;
+ window = new sf::Window(sf::VideoMode(WinWidth, WinHeight), WinTitle, sf::Style::Default, contextSetting);
+ glCheckError();
+ //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));
+
+ SetMouseCapture(false);
+}
+
+void Core::InitGlew() {
+ LOG(INFO) << "Initializing GLEW";
+ glewExperimental = GL_TRUE;
+ GLenum glewStatus = glewInit();
+ glCheckError();
+ if (glewStatus != GLEW_OK) {
+ LOG(FATAL) << "Failed to initialize GLEW: " << glewGetErrorString(glewStatus);
+ }
+ glViewport(0, 0, width(), height());
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_CULL_FACE);
+ glCullFace(GL_BACK);
+ glFrontFace(GL_CCW);
+ //glEnable(GL_BLEND);
+ //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glCheckError();
+}
+
+unsigned int Core::width() {
+ return window->getSize().x;
+}
+
+unsigned int Core::height() {
+ return window->getSize().y;
+}
+
+void Core::HandleEvents() {
+ sf::Event event;
+ while (window->pollEvent(event)) {
+ switch (event.type) {
+ case sf::Event::Closed:
+ LOG(INFO) << "Received close event by window closing";
+ isRunning = false;
+ break;
+ case sf::Event::Resized:
+ glViewport(0, 0, width(), height());
+ break;
+ case sf::Event::KeyPressed:
+ if (!window->hasFocus()) break;
+ switch (event.key.code) {
+ case sf::Keyboard::Escape:
+ LOG(INFO) << "Received close event by esc";
+ isRunning = false;
+ break;
+ case sf::Keyboard::T:
+ SetMouseCapture(!isMouseCaptured);
+ break;
+ case sf::Keyboard::L:
+ ChunkDistance++;
+ LOG(INFO) << "Increased render distance: " << ChunkDistance;
+ break;
+ case sf::Keyboard::K:
+ if (ChunkDistance > 1) {
+ ChunkDistance--;
+ LOG(INFO) << "Decreased render distance: " << ChunkDistance;
+ }
+ break;
+ default:
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ if (window->hasFocus()) {
+ if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) gameState->HandleMovement(GameState::FORWARD, deltaTime);
+ if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) gameState->HandleMovement(GameState::BACKWARD, deltaTime);
+ if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) gameState->HandleMovement(GameState::LEFT, deltaTime);
+ if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) gameState->HandleMovement(GameState::RIGHT, deltaTime);
+ if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space)) gameState->HandleMovement(GameState::JUMP, deltaTime);
+ UpdateChunksToRender();
+ }
+}
+
+void Core::HandleMouseCapture() {
+ sf::Vector2i mousePos = sf::Mouse::getPosition(*window);
+ sf::Vector2i center = sf::Vector2i(window->getSize().x / 2, window->getSize().y / 2);
+ sf::Mouse::setPosition(center, *window);
+ mouseXDelta = (mousePos - center).x, mouseYDelta = (center - mousePos).y;
+ const float Sensetivity = 0.7f;
+ gameState->HandleRotation(mouseXDelta * Sensetivity, mouseYDelta * Sensetivity);
+ //camera.ProcessMouseMovement(mouseXDelta, mouseYDelta);
+}
+
+void Core::RenderWorld() {
+ shader->Use();
+ glCheckError();
+
+ GLint projectionLoc = glGetUniformLocation(shader->Program, "projection");
+ GLint viewLoc = glGetUniformLocation(shader->Program, "view");
+ GLint timeLoc = glGetUniformLocation(shader->Program, "time");
+ glm::mat4 projection = glm::perspective(45.0f, (float) width() / (float) height(), 0.1f, 10000000.0f);
+ glm::mat4 view = gameState->GetViewMatrix();
+ glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
+ glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
+ glUniform1f(timeLoc, absTime);
+ glUniform2f(glGetUniformLocation(shader->Program, "windowSize"), width(), height());
+
+ 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();
+
+ 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),
+ };
+ bool isBreak = true;
+ glm::mat4 vp = projection * view;
+ for (auto &it:sectionCorners) {
+ glm::vec3 point(section.GetPosition().GetX() * 16 + it.GetX(),
+ section.GetPosition().GetY() * 16 + it.GetY(),
+ section.GetPosition().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) {
+ isBreak = false;
+ break;
+ }
+ }
+ if (isBreak && glm::length(gameState->Position() -
+ 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();
+ }
+ toRenderMutex.unlock();
+ glCheckError();
+}
+
+void Core::SetMouseCapture(bool IsCaptured) {
+ window->setMouseCursorVisible(!isMouseCaptured);
+ sf::Mouse::setPosition(sf::Vector2i(window->getSize().x / 2, window->getSize().y / 2), *window);
+ isMouseCaptured = IsCaptured;
+ window->setMouseCursorVisible(!IsCaptured);
+}
+
+void Core::PrepareToRendering() {
+ shader = new Shader("./shaders/face.vs", "./shaders/face.fs");
+ shader->Use();
+
+ //TextureAtlas texture
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, assetManager->GetTextureAtlas());
+ glUniform1i(glGetUniformLocation(shader->Program, "textureAtlas"), 0);
+}
+
+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;
+ static int previousRenderDistance = ChunkDistance;
+ if (previousPlayerChunk == playerChunk && !firstTime && ChunkDistance == previousRenderDistance) {
+ return;
+ }
+ previousPlayerChunk = playerChunk;
+ previousRenderDistance = ChunkDistance;
+ toRender.clear();
+ for (auto &it:gameState->world.GetSectionsList()) {
+ Vector chunkPosition = it;
+ chunkPosition.SetY(0);
+ Vector delta = chunkPosition - playerChunk;
+ if (delta.GetMagnitude() > ChunkDistance) continue;
+ toRender.push_back(it);
+ }
+ for (auto &it:toRender) {
+ if (availableChunks.find(it) == availableChunks.end()) {
+ auto pair = std::make_pair(it, RenderSection(&gameState->world, it));
+ pair.second.UpdateState(assetManager->GetTextureAtlasIndexes());
+ availableChunks.insert(pair);
+ } else {
+ //availableChunks.find(it)->second.UpdateState();
+ }
+ }
+ if (firstTime) LOG(INFO) << "Chunks to render: " << toRender.size() << " of " << availableChunks.size();
+ firstTime = false;
+}
+
+void Core::UpdateGameState() {
+ el::Helpers::setThreadName("Game");
+ LOG(INFO) << "GameState thread is started";
+ sf::Clock delta;
+ while (isRunning) {
+ float deltaTime = delta.getElapsedTime().asSeconds();
+ delta.restart();
+ gameState->Update(deltaTime);
+ const double targetDelta = 1 / 60.0;
+ std::chrono::duration<double, std::ratio<1, 1>> timeToSleep(targetDelta - delta.getElapsedTime().asSeconds());
+ std::this_thread::sleep_for(timeToSleep);
+ 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/old/core/Core.hpp
index 039b3a3..aaa143f 100644
--- a/src/core/Core.hpp
+++ b/old/core/Core.hpp
@@ -8,12 +8,12 @@
#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>
+#include "../world/GameState.hpp"
+#include "AssetManager.hpp"
+#include "../graphics/Shader.hpp"
+#include "../graphics/Gui.hpp"
+#include "../graphics/RenderSection.hpp"
+#include "../network/NetworkClient.hpp"
struct MyMutex {
std::mutex mtx;
diff --git a/src/core/Event.cpp b/old/core/Event.cpp
index 10b2eaa..3b2cc7f 100644
--- a/src/core/Event.cpp
+++ b/old/core/Event.cpp
@@ -1,4 +1,4 @@
-#include <core/Event.hpp>
+#include "Event.hpp"
#include <easylogging++.h>
std::queue <Event> EventAgregator::eventsToHandle;
diff --git a/src/core/Event.hpp b/old/core/Event.hpp
index cfa990a..a8de1f3 100644
--- a/src/core/Event.hpp
+++ b/old/core/Event.hpp
@@ -9,7 +9,7 @@
#include <variant>
#include <functional>
-#include <Vector.hpp>
+#include "../Vector.hpp"
enum class EventType {
Echo,
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-01 10:11:24 +0200