28 files changed, 408 insertions, 133 deletions

diff --git a/src/core/AssetManager.cpp b/src/core/AssetManager.cpp
index 003f2f0..eaa002f 100644
--- a/src/core/AssetManager.cpp
+++ b/src/core/AssetManager.cpp
@@ -8,9 +8,6 @@ const fs::path pathToAssetsList = "./items.json";
 const fs::path pathToTextureIndex = "./textures.json";
 
 AssetManager::AssetManager() {
-    for (auto &it:fs::recursive_directory_iterator(pathToAssets)) {
-
-    }
     LoadIds();
     LoadTextureResources();
 }
@@ -23,7 +20,7 @@ void AssetManager::LoadIds() {
         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, 0, state);
+        assetIds[blockName] = Block(id, state);
     }
     LOG(INFO) << "Loaded " << assetIds.size() << " ids";
 }
@@ -38,13 +35,15 @@ void AssetManager::LoadTextureResources() {
     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"];
-        TextureCoord coord;
-        coord.x = frame["x"].get<int>();
-        coord.y = frame["y"].get<int>();;
-        coord.w = frame["w"].get<int>();
-        coord.h = frame["h"].get<int>();
+        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);
@@ -55,30 +54,37 @@ void AssetManager::LoadTextureResources() {
     LOG(INFO) << "Texture atlas id is " << textureAtlas->texture;
 }
 
-TextureCoord AssetManager::GetTextureByAssetName(std::string AssetName) {
-    return assetTextures[AssetName];
+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(unsigned short BlockId, unsigned char BlockSide) {
-    //Block sides: 0 - bottom, 1 - top, 2 - north, 3 - south, 4 - west, 5 - east
-    std::map<Block, std::string> lookupTable = {
-            {Block(0),       "minecraft/textures/blocks/air"},
-            {Block(1, 0),    "minecraft/textures/blocks/stone"},
-            {Block(1, 1),    "minecraft/textures/blocks/stone_granite"},
+std::string AssetManager::GetTextureAssetNameByBlockId(BlockTextureId block) {
+    //Block sides: 0 - bottom, 1 - top, 2 - north, 3 - south, 4 - west, 5 - east 6 - every side
+    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"},
 
-            {Block(2, 0, 0), "minecraft/textures/blocks/dirt"},
-            {Block(2, 0, 1), "minecraft/textures/blocks/grass_top"},
-            {Block(2, 0, 2), "minecraft/textures/blocks/grass_side"},
-            {Block(2, 0, 3), "minecraft/textures/blocks/grass_side"},
-            {Block(2, 0, 4), "minecraft/textures/blocks/grass_side"},
-            {Block(2, 0, 5), "minecraft/textures/blocks/grass_side"},
+            {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"},
 
-            {Block(3),       "minecraft/textures/blocks/dirt"},
-            {Block(4),       "minecraft/textures/blocks/cobblestone"},
+            {BlockTextureId(3, 0),    "minecraft/textures/blocks/dirt"},
+            {BlockTextureId(4, 0),    "minecraft/textures/blocks/cobblestone"},
     };
-    return lookupTable[Block(BlockId, BlockSide)];
+    return lookupTable[block];
 }
 
-const GLuint AssetManager::GetTextureAtlas() {
+GLuint AssetManager::GetTextureAtlas() {
     return textureAtlas->texture;
 }
+
+TextureCoordinates AssetManager::GetTextureByBlock(BlockTextureId block) {
+    return this->GetTextureByAssetName(this->GetTextureAssetNameByBlockId(block));
+}
diff --git a/src/core/AssetManager.hpp b/src/core/AssetManager.hpp
index 23b2ba6..b378764 100644
--- a/src/core/AssetManager.hpp
+++ b/src/core/AssetManager.hpp
@@ -8,14 +8,44 @@
 #include "../world/Block.hpp"
 #include "../graphics/Texture.hpp"
 
-struct TextureCoord{
-    unsigned int x,y,w,h;
+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;
+        return state < rhs.state;
+    }
 };
 
 class AssetManager {
     Texture *textureAtlas;
-    std::map<std::string,Block> assetIds;
-    std::map<std::string,TextureCoord> assetTextures;
+    std::map<std::string, Block> assetIds;
+    std::map<std::string, TextureCoordinates> assetTextures;
 public:
     AssetManager();
 
@@ -23,11 +53,13 @@ public:
 
     void LoadTextureResources();
 
-    TextureCoord GetTextureByAssetName(std::string AssetName);
+    TextureCoordinates GetTextureByAssetName(std::string AssetName);
 
-    std::string GetTextureAssetNameByBlockId(unsigned short BlockId, unsigned char BlockSide = 0);
+    std::string GetTextureAssetNameByBlockId(BlockTextureId block);
 
-    const GLuint GetTextureAtlas();
+    GLuint GetTextureAtlas();
 
     void LoadIds();
+
+    TextureCoordinates GetTextureByBlock(BlockTextureId block);
 };
diff --git a/src/core/Core.cpp b/src/core/Core.cpp
index 1481e36..ade043e 100644
--- a/src/core/Core.cpp
+++ b/src/core/Core.cpp
@@ -1,5 +1,39 @@
 #include "Core.hpp"
 
+GLenum glCheckError_(const char *file, int line) {
+    GLenum errorCode;
+    while ((errorCode = glGetError()) != GL_NO_ERROR) {
+        std::string error;
+        switch (errorCode) {
+            case GL_INVALID_ENUM:
+                error = "INVALID_ENUM";
+                break;
+            case GL_INVALID_VALUE:
+                error = "INVALID_VALUE";
+                break;
+            case GL_INVALID_OPERATION:
+                error = "INVALID_OPERATION";
+                break;
+            case GL_STACK_OVERFLOW:
+                error = "STACK_OVERFLOW";
+                break;
+            case GL_STACK_UNDERFLOW:
+                error = "STACK_UNDERFLOW";
+                break;
+            case GL_OUT_OF_MEMORY:
+                error = "OUT_OF_MEMORY";
+                break;
+            case GL_INVALID_FRAMEBUFFER_OPERATION:
+                error = "INVALID_FRAMEBUFFER_OPERATION";
+                break;
+        }
+        LOG(ERROR) << "OpenGL error: " << error << " at " << file << ":" << line;
+    }
+    return errorCode;
+}
+
+#define glCheckError() glCheckError_(__FILE__, __LINE__)
+
 const GLfloat vertices[] = {
         //Z+ edge
         -0.5f, 0.5f, 0.5f,
@@ -49,6 +83,56 @@ const GLfloat vertices[] = {
         0.5f, -0.5f, -0.5f,
         -0.5f, -0.5f, 0.5f,
 };
+
+/*const GLfloat vertices[] = {
+        //Z+ edge
+        -0.5f, 0.5f, 0.5f,
+        -0.5f, -0.5f, 0.5f,
+        0.5f, -0.5f, 0.5f,
+        -0.5f, 0.5f, 0.5f,
+        0.5f, -0.5f, 0.5f,
+        0.5f, 0.5f, 0.5f,
+
+        //Z- edge
+        -0.5f, -0.5f, -0.5f,
+        -0.5f, 0.5f, -0.5f,
+        0.5f, -0.5f, -0.5f,
+        0.5f, -0.5f, -0.5f,
+        -0.5f, 0.5f, -0.5f,
+        0.5f, 0.5f, -0.5f,
+
+        //X+ edge
+        -0.5f, -0.5f, -0.5f,
+        -0.5f, -0.5f, 0.5f,
+        -0.5f, 0.5f, -0.5f,
+        -0.5f, 0.5f, -0.5f,
+        -0.5f, -0.5f, 0.5f,
+        -0.5f, 0.5f, 0.5f,
+
+        //X- edge
+        0.5f, -0.5f, 0.5f,
+        0.5f, 0.5f, -0.5f,
+        0.5f, 0.5f, 0.5f,
+        0.5f, -0.5f, 0.5f,
+        0.5f, -0.5f, -0.5f,
+        0.5f, 0.5f, -0.5f,
+
+        //Y+ edge
+        0.5f, 0.5f, -0.5f,
+        -0.5f, 0.5f, 0.5f,
+        0.5f, 0.5f, 0.5f,
+        0.5f, 0.5f, -0.5f,
+        -0.5f, 0.5f, -0.5f,
+        -0.5f, 0.5f, 0.5f,
+
+        //Y- edge
+        -0.5f, -0.5f, 0.5f,
+        0.5f, -0.5f, -0.5f,
+        0.5f, -0.5f, 0.5f,
+        -0.5f, -0.5f, -0.5f,
+        0.5f, -0.5f, -0.5f,
+        -0.5f, -0.5f, 0.5f,
+};*/
 const GLfloat uv_coords[] = {
         //Z+
         0.0f, 1.0f,
@@ -102,7 +186,9 @@ const GLfloat uv_coords[] = {
 Core::Core() {
     LOG(INFO) << "Core initializing...";
     InitSfml(1280, 720, "AltCraft");
+    glCheckError();
     InitGlew();
+    glCheckError();
     client = new NetworkClient("127.0.0.1", 25565, "HelloOne");
     gameState = new GameState(client);
     std::thread loop = std::thread(&Core::UpdateGameState, this);
@@ -110,6 +196,7 @@ Core::Core() {
     assetManager = new AssetManager;
     PrepareToWorldRendering();
     LOG(INFO) << "Core is initialized";
+    glCheckError();
 }
 
 Core::~Core() {
@@ -118,10 +205,13 @@ Core::~Core() {
     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;
@@ -145,8 +235,10 @@ void Core::Exec() {
         HandleEvents();
         if (isMouseCaptured)
             HandleMouseCapture();
+        glCheckError();
 
         RenderFrame();
+
     }
 }
 
@@ -162,11 +254,11 @@ void Core::RenderFrame() {
             //RenderGui(LoadingScreen);
             break;
         case Playing:
-            RenderWorld(gameState->world);
+            RenderWorld();
             //RenderGui(HUD);
             break;
         case PauseMenu:
-            RenderWorld(gameState->world);
+            RenderWorld();
             //RenderGui(PauseGui);
             break;
     }
@@ -182,7 +274,8 @@ void Core::InitSfml(unsigned int WinWidth, unsigned int WinHeight, std::string W
     contextSetting.attributeFlags = contextSetting.Core;
     contextSetting.depthBits = 24;
     window = new sf::Window(sf::VideoMode(WinWidth, WinHeight), WinTitle, sf::Style::Default, contextSetting);
-    //window->setVerticalSyncEnabled(true);
+    glCheckError();
+    window->setVerticalSyncEnabled(true);
     window->setPosition(sf::Vector2i(sf::VideoMode::getDesktopMode().width / 2 - window->getSize().x / 2,
                                      sf::VideoMode::getDesktopMode().height / 2 - window->getSize().y / 2));
 
@@ -193,6 +286,7 @@ 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);
     }
@@ -201,6 +295,7 @@ void Core::InitGlew() {
     glEnable(GL_CULL_FACE);
     glCullFace(GL_BACK);
     glFrontFace(GL_CCW);
+    glCheckError();
 }
 
 unsigned int Core::width() {
@@ -216,14 +311,18 @@ void Core::HandleEvents() {
     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:
@@ -239,21 +338,24 @@ void Core::HandleEvents() {
                         break;
                 }
             case sf::Event::MouseWheelScrolled:
-                //camera.ProcessMouseScroll(event.mouseWheelScroll.delta);
+                if (!window->hasFocus())
+                    break;
+                camera.ProcessMouseScroll(event.mouseWheelScroll.delta);
                 break;
             default:
                 break;
         }
     }
-
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
-        camera.ProcessKeyboard(Camera_Movement::FORWARD, deltaTime);
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
-        camera.ProcessKeyboard(Camera_Movement::BACKWARD, deltaTime);
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
-        camera.ProcessKeyboard(Camera_Movement::LEFT, deltaTime);
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
-        camera.ProcessKeyboard(Camera_Movement::RIGHT, deltaTime);
+    if (window->hasFocus()) {
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
+            camera.ProcessKeyboard(Camera_Movement::FORWARD, deltaTime);
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
+            camera.ProcessKeyboard(Camera_Movement::BACKWARD, deltaTime);
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
+            camera.ProcessKeyboard(Camera_Movement::LEFT, deltaTime);
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
+            camera.ProcessKeyboard(Camera_Movement::RIGHT, deltaTime);
+    }
 }
 
 void Core::HandleMouseCapture() {
@@ -265,23 +367,26 @@ void Core::HandleMouseCapture() {
 }
 
 void Core::RenderGui(Gui &Target) {
-
+    Target.WHY++;
 }
 
-void Core::RenderWorld(World &Target) {
+void Core::RenderWorld() {
     shader->Use();
+    glCheckError();
 
     GLint modelLoc = glGetUniformLocation(shader->Program, "model");
     GLint projectionLoc = glGetUniformLocation(shader->Program, "projection");
     GLint viewLoc = glGetUniformLocation(shader->Program, "view");
     GLint blockLoc = glGetUniformLocation(shader->Program, "block");
     GLint timeLoc = glGetUniformLocation(shader->Program, "time");
-    glm::mat4 projection = glm::perspective(camera.Zoom, (float) width() / (float) height(), 0.0001f, 1000.0f);
+    glm::mat4 projection = glm::perspective(camera.Zoom, (float) width() / (float) height(), 0.1f, 10000000.0f);
     glm::mat4 view = camera.GetViewMatrix();
     glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
     glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
     glUniform1f(timeLoc, absTime);
 
+    glCheckError();
+
     glBindVertexArray(VAO);
 
     for (auto &sectionPos:toRender) {
@@ -290,7 +395,7 @@ void Core::RenderWorld(World &Target) {
             for (int z = 0; z < 16; z++) {
                 for (int x = 0; x < 16; x++) {
                     Block block = section.GetBlock(Vector(x, y, z));
-                    if (block.id==0)
+                    if (block.id == 0)
                         continue;
 
                     glm::mat4 model;
@@ -298,7 +403,6 @@ void Core::RenderWorld(World &Target) {
                                                             sectionPos.GetZ() * 16));
                     model = glm::translate(model, glm::vec3(x, y, z));
 
-
                     glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
                     glUniform1i(blockLoc, block.id);
 
@@ -308,6 +412,7 @@ void Core::RenderWorld(World &Target) {
         }
     }
     glBindVertexArray(0);
+    glCheckError();
 }
 
 void Core::SetMouseCapture(bool IsCaptured) {
@@ -318,6 +423,7 @@ void Core::SetMouseCapture(bool IsCaptured) {
 }
 
 void Core::PrepareToWorldRendering() {
+    //Cube-rendering data
     glGenBuffers(1, &VBO);
     glGenBuffers(1, &VBO2);
     glGenVertexArrays(1, &VAO);
@@ -336,19 +442,116 @@ void Core::PrepareToWorldRendering() {
     }
     glBindVertexArray(0);
 
+    glCheckError();
+
     shader = new Shader("./shaders/block.vs", "./shaders/block.fs");
     shader->Use();
 
+    LOG(INFO) << "Initializing texture atlas...";
+    //TextureAtlas texture
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, assetManager->GetTextureAtlas());
     glUniform1i(glGetUniformLocation(shader->Program, "textureAtlas"), 0);
 
+    //TextureAtlas coordinates
+    std::vector<glm::vec4> textureCoordinates;
+    std::vector<GLint> indexes;
+    GLint totalTextures;
+    for (int id = 0; id < 4096; id++) {
+        bool isReachedEnd = true;
+        for (int state = 0; state < 16; state++) {
+            if (!assetManager->GetTextureByBlock(BlockTextureId(id, state, 6)) ||
+                !assetManager->GetTextureByBlock(BlockTextureId(id, state, 0))) {
+                continue;
+            }
+            isReachedEnd = false;
+            int side = assetManager->GetTextureByBlock(BlockTextureId(id, state, 6)) ? 6 : 0;
+            do {
+                int index = (side << 16) | (id << 4) | state;
+                TextureCoordinates tc = assetManager->GetTextureByBlock(BlockTextureId(id, state, side));
+                textureCoordinates.push_back(glm::vec4(tc.x, tc.y, tc.w, tc.h));
+                indexes.push_back(index);
+                /*LOG(ERROR) << "Encoded (" << side << " " << id << " " << state << ") as " << index << " ("
+                           << std::bitset<20>(index) << ")";*/
+                /*LOG(FATAL)<<std::bitset<18>(index);
+                side = 0x7;
+                id = 0xFFF;
+                state = 0xF;
+                LOG(WARNING) << "side: " << side << " id: " << id << " state: " << state;
+                int i, si, st, index = 0;
+                si = side << 15;
+                i = id<<3;
+                st = state;
+                index = i | si | st;
+                LOG(FATAL) << std::bitset<18>(index) << " (" << index << "): " << std::bitset<18>(si) << " "
+                           << std::bitset<18>(i) << " " << std::bitset<18>(st);*/
+                /*if (rand() == 73) //Almost impossible(Almost==1/32768)
+                {
+                    int index = 393233;
+                    LOG(WARNING) << std::bitset<20>(index) << "(" << index << ")";
+                    int side = (index & 0xE0000) >> 16;
+                    int id = (index & 0xFF0) >> 4;
+                    int state = index & 0xF;
+                    LOG(WARNING) << std::bitset<20>(side) << " " << std::bitset<20>(id) << " "
+                                 << std::bitset<20>(state);
+                    LOG(FATAL) << side << " " << id << " " << state;
+                }*/
+                side++;
+            } while (side < 7);
+        }
+        if (isReachedEnd)
+            break;
+
+    }
+    totalTextures = indexes.size();
+    LOG(INFO) << "Created " << totalTextures << " texture indexes";
+    CHECK_EQ(indexes.size(), textureCoordinates.size()) << "Arrays of textureCoordinates and of indexes is not equals";
+    CHECK_LE(totalTextures, 2048) << "There is more texture indexes, than GLSL buffer allows";
+
+    for (auto& it:indexes){
+        LOG(WARNING)<<it;
+    }
+
+    indexes.insert(indexes.begin(), totalTextures);
+    indexes.resize(2048);
+
+
+
+    GLuint ubo = glGetUniformBlockIndex(shader->Program, "TextureIndexes");
+    glUniformBlockBinding(shader->Program, ubo, 0);
+    glGenBuffers(1, &UBO);
+    glBindBuffer(GL_UNIFORM_BUFFER, UBO);
+    glBufferData(GL_UNIFORM_BUFFER, indexes.size() * sizeof(GLint), NULL, GL_STATIC_DRAW);
+    glBindBufferRange(GL_UNIFORM_BUFFER, 0, UBO, 0, indexes.size() * sizeof(GLint));
+    glBufferSubData(GL_UNIFORM_BUFFER, 0, indexes.size() * sizeof(GLint), &indexes[0]);
+    glCheckError();
+
+    LOG(WARNING)<<"Uploaded "<<indexes.size() * sizeof(GLint)<<" bytes";
+
+    /*GLuint ubo2 = glGetUniformBlockIndex(shader->Program, "TextureData");
+    glUniformBlockBinding(shader->Program, ubo2, 1);
+    glGenBuffers(1, &UBO2);
+    glBindBuffer(GL_UNIFORM_BUFFER, UBO2);
+    glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::vec4) * 1024, NULL, GL_STATIC_DRAW);
+    glBindBufferRange(GL_UNIFORM_BUFFER, 1, UBO2, 0, 1024 * sizeof(glm::vec4));
+    glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::vec4) * textureCoordinates.size(), textureCoordinates.data());*/
+
+    /*
+    GLuint ubo3 = glGetUniformBlockIndex(shader->Program, "TextureData2");
+    glUniformBlockBinding(shader->Program, ubo3, 2);
+    glGenBuffers(1, &UBO3);
+    glBindBuffer(GL_UNIFORM_BUFFER, UBO3);
+    glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::vec4) * 1024, NULL, GL_STATIC_DRAW);
+    glBindBufferRange(GL_UNIFORM_BUFFER, 2, UBO3, 0, 1024 * sizeof(glm::vec4));*/
+
+    glBindBuffer(GL_UNIFORM_BUFFER,0);
+    glCheckError();
 }
 
 void Core::UpdateChunksToRender() {
     camera.Position = glm::vec3(gameState->g_PlayerX, gameState->g_PlayerY, gameState->g_PlayerZ);
     toRender.clear();
-    const float ChunkDistance = 1.3;
+    const float ChunkDistance = 1;
     Vector playerChunk = Vector(floor(gameState->g_PlayerX / 16.0f), floor(gameState->g_PlayerY / 16.0f),
                                 floor(gameState->g_PlayerZ / 16.0f));
     for (auto &it:gameState->world.m_sections) {
@@ -359,12 +562,26 @@ void Core::UpdateChunksToRender() {
         toRender.push_back(chunkPosition);
     }
     LOG(INFO) << "Chunks to render: " << toRender.size();
+
+    /*std::map<Block, int> totalBlocks;
+    for (auto &section:toRender)
+        for (int x = 0; x < 16; x++)
+            for (int y = 0; y < 16; y++)
+                for (int z = 0; z < 16; z++)
+                    totalBlocks[gameState->world.m_sections.find(section)->second.GetBlock(Vector(x, y, z))]++;
+    for (auto &it:totalBlocks) {
+        LOG(WARNING) << it.first.id << ":" << (int) it.first.state << " = " << it.second << " ("
+                     << std::bitset<13>(it.first.id) << ")";
+    }*/
 }
 
 void Core::UpdateGameState() {
+    el::Helpers::setThreadName("Game");
     LOG(INFO) << "GameState thread is started";
     while (isRunning) {
         gameState->Update();
+        if (toRender.size() > 0)
+            break;
     }
     LOG(INFO) << "GameState thread is stopped";
 }
diff --git a/src/core/Core.hpp b/src/core/Core.hpp
index 8bf74da..e5fe315 100644
--- a/src/core/Core.hpp
+++ b/src/core/Core.hpp
@@ -29,7 +29,7 @@ class Core {
     float deltaTime;
     float absTime;
 
-    void RenderWorld(World &Target);
+    void RenderWorld();
 
     void RenderGui(Gui &Target);
 
@@ -59,7 +59,8 @@ class Core {
 
     Camera3D camera;
     Shader *shader;
-    GLuint VBO, VAO, VBO2;
+    //Cube verticies, Cube VAO, Cube UVs, TextureIndexes UBO, TextureData UBO, TextureData2 UBO
+    GLuint VBO, VAO, VBO2, UBO,UBO2,UBO3;
     std::vector<Vector> toRender;
 
 public:
diff --git a/src/gamestate/GameState.hpp b/src/gamestate/GameState.hpp
index c9ca44a..8817f4c 100644
--- a/src/gamestate/GameState.hpp
+++ b/src/gamestate/GameState.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <nlohmann/json.hpp>
 #include "../world/World.hpp"
 #include "../network/NetworkClient.hpp"
 #include "../packet/PacketParser.hpp"
diff --git a/src/graphics/Shader.cpp b/src/graphics/Shader.cpp
index 9bb08ba..83eb93f 100644
--- a/src/graphics/Shader.cpp
+++ b/src/graphics/Shader.cpp
@@ -1,4 +1,3 @@
-#include <easylogging++.h>
 #include "Shader.hpp"
 
 Shader::Shader(const GLchar *vertexPath, const GLchar *fragmentPath) {
@@ -70,7 +69,7 @@ Shader::Shader(const GLchar *vertexPath, const GLchar *fragmentPath) {
     glGetProgramiv(this->Program, GL_LINK_STATUS, &success);
     if (!success) {
         glGetProgramInfoLog(this->Program, 512, NULL, infoLog);
-        LOG(ERROR) << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog;
+        LOG(FATAL) << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog;
     }
 
     // Удаляем шейдеры, поскольку они уже в программу и нам больше не нужны.
diff --git a/src/graphics/Shader.hpp b/src/graphics/Shader.hpp
index 66d687c..a336b1a 100644
--- a/src/graphics/Shader.hpp
+++ b/src/graphics/Shader.hpp
@@ -2,7 +2,7 @@
 #include <string>
 #include <fstream>
 #include <sstream>
-
+#include <easylogging++.h>
 #include <GL/glew.h>
 
 class Shader
diff --git a/src/graphics/Texture.cpp b/src/graphics/Texture.cpp
index bd5c53f..5d183c3 100644
--- a/src/graphics/Texture.cpp
+++ b/src/graphics/Texture.cpp
@@ -1,5 +1,3 @@
-#include <SFML/Graphics.hpp>
-#include <easylogging++.h>
 #include "Texture.hpp"
 
 Texture::Texture(std::string filename, GLenum textureWrapping, GLenum textureFiltering) {
diff --git a/src/graphics/Texture.hpp b/src/graphics/Texture.hpp
index 8e3f1af..277806a 100644
--- a/src/graphics/Texture.hpp
+++ b/src/graphics/Texture.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <SFML/Graphics.hpp>
+#include <easylogging++.h>
 #include <GL/glew.h>
 
 class Texture {
diff --git a/src/gui/Gui.hpp b/src/gui/Gui.hpp
index 1ea4e11..641b941 100644
--- a/src/gui/Gui.hpp
+++ b/src/gui/Gui.hpp
@@ -2,4 +2,6 @@
 
 class Gui {
 
+public:
+    int WHY=0;
 };
diff --git a/src/main.cpp b/src/main.cpp
index de2c9d8..8a7b974 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -15,10 +15,12 @@ int main() {
     el::Configurations loggerConfiguration;
     el::Helpers::installCustomFormatSpecifier(
             el::CustomFormatSpecifier("%startTime", std::bind(getTimeSinceProgramStart)));
-    std::string format = "[%startTime][%level][%fbase]: %msg";
+    std::string format = "[%startTime][%level][%thread][%fbase]: %msg";
     loggerConfiguration.set(el::Level::Info, el::ConfigurationType::Format, format);
     loggerConfiguration.set(el::Level::Error, el::ConfigurationType::Format, format);
     loggerConfiguration.set(el::Level::Fatal, el::ConfigurationType::Format, format);
+    loggerConfiguration.set(el::Level::Warning, el::ConfigurationType::Format, format);
+    el::Helpers::setThreadName("Render");
     el::Loggers::reconfigureAllLoggers(loggerConfiguration);
     el::Loggers::addFlag(el::LoggingFlag::ColoredTerminalOutput);
     LOG(INFO) << "Logger is configured";
diff --git a/src/network/Network.cpp b/src/network/Network.cpp
index b3b1e4b..7757be9 100644
--- a/src/network/Network.cpp
+++ b/src/network/Network.cpp
@@ -1,5 +1,4 @@
 #include "Network.hpp"
-#include "../packet/PacketBuilder.hpp"
 
 Network::Network(std::string address, unsigned short port) : m_address(address), m_port(port) {
     LOG(INFO) << "Connecting to server " << m_address << ":" << m_port;
@@ -55,7 +54,7 @@ Packet Network::ReceivePacket() {
             break;
         }
     }
-    Field fLen = FieldParser::Parse(VarInt, bufLen);
+    Field fLen = FieldParser::Parse(VarIntType, bufLen);
     size_t packetLen = fLen.GetVarInt() + fLen.GetLength();
     if (packetLen > 1024 * 1024 * 15)
         LOG(WARNING)<<"OMG SIZEOF PACKAGE IS "<<packetLen;
diff --git a/src/network/Network.hpp b/src/network/Network.hpp
index 7d8cfeb..84f2e7f 100644
--- a/src/network/Network.hpp
+++ b/src/network/Network.hpp
@@ -4,6 +4,7 @@
 #include <easylogging++.h>
 #include <SFML/Network.hpp>
 #include "../packet/Packet.hpp"
+#include "../packet/PacketBuilder.hpp"
 
 
 class Network {
diff --git a/src/network/NetworkClient.cpp b/src/network/NetworkClient.cpp
index 9916b10..fd957a5 100644
--- a/src/network/NetworkClient.cpp
+++ b/src/network/NetworkClient.cpp
@@ -95,6 +95,7 @@ void NetworkClient::Update() {
 }
 
 void NetworkClient::MainLoop() {
+    el::Helpers::setThreadName("Network");
     try {
         while (isContinue) {
             Update();
diff --git a/src/network/NetworkClient.hpp b/src/network/NetworkClient.hpp
index 9f68e37..14745a5 100644
--- a/src/network/NetworkClient.hpp
+++ b/src/network/NetworkClient.hpp
@@ -3,6 +3,7 @@
 #include <queue>
 #include <thread>
 #include <mutex>
+#include <nlohmann/json.hpp>
 #include "Network.hpp"
 #include "../packet/PacketParser.hpp"
 #include "../packet/PacketBuilder.hpp"
diff --git a/src/packet/Field.cpp b/src/packet/Field.cpp
index 69402f1..9be2469 100644
--- a/src/packet/Field.cpp
+++ b/src/packet/Field.cpp
@@ -1,4 +1,3 @@
-#include <cmath>
 #include "Field.hpp"
 
 Field::Field() {
@@ -59,7 +58,7 @@ int Field::GetVarInt() {
 
 void Field::SetVarInt(int value) {
     Clear();
-    m_type = VarInt;
+    m_type = VarIntType;
     m_data = new byte[5];
     m_dataLength = VarIntWrite(value, m_data);
 }
@@ -252,7 +251,7 @@ void Field::SetDouble(double value) {
 
 size_t Field::GetFieldLength(FieldType type) {
     switch (type) {
-        case Unknown:
+        case UnknownType:
             return 0;
         case Boolean:
             return 1;
diff --git a/src/packet/Field.hpp b/src/packet/Field.hpp
index 8be9c9b..c33cd1c 100644
--- a/src/packet/Field.hpp
+++ b/src/packet/Field.hpp
@@ -2,8 +2,10 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <cmath>
 #include <string>
 #include <vector>
+
 #include "../utility/utility.h"
 #include "../utility/Vector.hpp"
 
@@ -11,7 +13,7 @@ typedef unsigned char byte;
 typedef signed char sbyte;
 
 enum FieldType {
-    Unknown = 0,
+    UnknownType = 0,
     Boolean,        //Bool
     Byte8_t,           //int8_t
     UnsignedByte,   //uint8_t
@@ -28,7 +30,7 @@ enum FieldType {
 
     String = 100,   //std::string
     Chat,           //std::string
-    VarInt,         //int32_t
+    VarIntType,         //int32_t
     VarLong,        //int64_t
     ChunkSection,   //byte*
     EntityMetadata, //byte*
@@ -55,7 +57,7 @@ public:
 
     void CopyToBuff(byte *ptr);
 
-    void SetRaw(byte *ptr, size_t len = 0, FieldType type = Unknown);
+    void SetRaw(byte *ptr, size_t len = 0, FieldType type = UnknownType);
 
     FieldType GetType();
 
@@ -114,6 +116,6 @@ public:
 private:
     size_t m_dataLength = 0;
     byte *m_data = nullptr;
-    FieldType m_type = Unknown;
+    FieldType m_type = UnknownType;
     std::vector<Field> m_childs;
 };
diff --git a/src/packet/FieldParser.cpp b/src/packet/FieldParser.cpp
index 500a973..295e78f 100644
--- a/src/packet/FieldParser.cpp
+++ b/src/packet/FieldParser.cpp
@@ -2,26 +2,26 @@
 
 Field FieldParser::Parse(FieldType type, byte *data, size_t len) {
     switch (type) {
-        case VarInt:
+        case VarIntType:
             return ParseVarInt(data, len);
         case Boolean:
-            return ParseBool(data, len);
+            return ParseBool(data);
         case String:
-            return ParseString(data, len);
+            return ParseString(data);
         case Long:
-            return ParseLong(data, len);
+            return ParseLong(data);
         case Int:
-            return ParseInt(data, len);
+            return ParseInt(data);
         case UnsignedByte:
-            return ParseUByte(data, len);
+            return ParseUByte(data);
         case Byte8_t:
-            return ParseByte(data, len);
+            return ParseByte(data);
         case Float:
-            return ParseFloat(data, len);
+            return ParseFloat(data);
         case Position:
-            return ParsePosition(data, len);
+            return ParsePosition(data);
         case Double:
-            return ParseDouble(data, len);
+            return ParseDouble(data);
         case ByteArray:
             return ParseByteArray(data, len);
         default:
@@ -29,23 +29,23 @@ Field FieldParser::Parse(FieldType type, byte *data, size_t len) {
     }
 }
 
-Field FieldParser::ParseString(byte *data, size_t len) {
+Field FieldParser::ParseString(byte *data) {
     Field fLen = ParseVarInt(data, 0);
     Field f;
     f.SetRaw(data, fLen.GetLength() + fLen.GetVarInt(), String);
     return f;
 }
 
-Field FieldParser::ParseBool(byte *data, size_t len) {
+Field FieldParser::ParseBool(byte *data) {
     Field f;
-    f.SetRaw(data,1,Boolean);
+    f.SetRaw(data, 1, Boolean);
     return f;
 }
 
 Field FieldParser::ParseVarInt(byte *data, size_t len) {
     if (len != 0) {
         Field f;
-        f.SetRaw(data, len, VarInt);
+        f.SetRaw(data, len, VarIntType);
         return f;
     }
     int val = VarIntRead(data, len);
@@ -54,43 +54,43 @@ Field FieldParser::ParseVarInt(byte *data, size_t len) {
     return f;
 }
 
-Field FieldParser::ParseLong(byte *data, size_t len) {
+Field FieldParser::ParseLong(byte *data) {
     Field f;
     f.SetRaw(data, 8, Long);
     return f;
 }
 
-Field FieldParser::ParseInt(byte *data, size_t len) {
+Field FieldParser::ParseInt(byte *data) {
     Field f;
     f.SetRaw(data, 4, Int);
     return f;
 }
 
-Field FieldParser::ParseUByte(byte *data, size_t len) {
+Field FieldParser::ParseUByte(byte *data) {
     Field f;
     f.SetRaw(data, 1, UnsignedByte);
     return f;
 }
 
-Field FieldParser::ParseByte(byte *data, size_t len) {
+Field FieldParser::ParseByte(byte *data) {
     Field f;
     f.SetRaw(data, 1, Byte8_t);
     return f;
 }
 
-Field FieldParser::ParseFloat(byte *data, size_t len) {
+Field FieldParser::ParseFloat(byte *data) {
     Field f;
     f.SetRaw(data, 4, Float);
     return f;
 }
 
-Field FieldParser::ParsePosition(byte *data, size_t len) {
+Field FieldParser::ParsePosition(byte *data) {
     Field f;
     f.SetRaw(data, 8, Position);
     return f;
 }
 
-Field FieldParser::ParseDouble(byte *data, size_t len) {
+Field FieldParser::ParseDouble(byte *data) {
     Field f;
     f.SetRaw(data, 8, Double);
     return f;
@@ -101,6 +101,5 @@ Field FieldParser::ParseByteArray(byte *data, size_t len) {
         throw 119;
     Field f;
     f.SetRaw(data, len, Byte8_t);
-    //f.SetRaw(data, len, ByteArray);
     return f;
 }
diff --git a/src/packet/FieldParser.hpp b/src/packet/FieldParser.hpp
index 274ab9e..f256b34 100644
--- a/src/packet/FieldParser.hpp
+++ b/src/packet/FieldParser.hpp
@@ -6,25 +6,25 @@ class FieldParser {
 public:
     static Field ParseVarInt(byte *data, size_t len);
 
-    static Field ParseBool(byte *data, size_t len);
+    static Field ParseBool(byte *data);
 
-    static Field ParseString(byte *data, size_t len);
+    static Field ParseString(byte *data);
 
     static Field Parse(FieldType type, byte* data, size_t len=0);
 
-    static Field ParseLong(byte *data, size_t len);
+    static Field ParseLong(byte *data);
 
-    static Field ParseInt(byte *data, size_t len);
+    static Field ParseInt(byte *data);
 
-    static Field ParseUByte(byte *data, size_t len);
+    static Field ParseUByte(byte *data);
 
-    static Field ParseByte(byte *data, size_t len);
+    static Field ParseByte(byte *data);
 
-    static Field ParseFloat(byte *data, size_t len);
+    static Field ParseFloat(byte *data);
 
-    static Field ParsePosition(byte *data, size_t len);
+    static Field ParsePosition(byte *data);
 
-    static Field ParseDouble(byte *data, size_t len);
+    static Field ParseDouble(byte *data);
 
     static Field ParseByteArray(byte *data, size_t len);
 };
\ No newline at end of file
diff --git a/src/packet/Packet.cpp b/src/packet/Packet.cpp
index 695e371..68cc3c3 100644
--- a/src/packet/Packet.cpp
+++ b/src/packet/Packet.cpp
@@ -23,9 +23,9 @@ void Packet::swap(Packet &other) {
 
 void Packet::CopyToBuff(byte *ptr) {
     m_fields[0].SetVarInt(GetLength() - m_fields[0].GetLength());
-    for (int i = 0; i < m_fields.size(); i++) {
-        m_fields[i].CopyToBuff(ptr);
-        ptr += m_fields[i].GetLength();
+    for (auto &it:m_fields) {
+        it.CopyToBuff(ptr);
+        ptr += it.GetLength();
     }
 }
 
@@ -44,28 +44,29 @@ void Packet::ParseField(FieldType type, size_t len) {
 }
 
 Packet::Packet(byte *data) {
-    Field fLen = FieldParser::Parse(VarInt, data);
+    Field fLen = FieldParser::Parse(VarIntType, data);
     data += fLen.GetLength();
-    Field fId = FieldParser::Parse(VarInt, data);
+    Field fId = FieldParser::Parse(VarIntType, data);
     data += fId.GetLength();
     m_dataLength = fLen.GetVarInt() - fId.GetLength();
     m_data = new byte[m_dataLength];
-    std::copy(data,data+m_dataLength,m_data);
+    std::copy(data, data + m_dataLength, m_data);
     m_parsePtr = m_data;
     m_fields.push_back(fLen);
     m_fields.push_back(fId);
 }
 
 Field &Packet::GetField(int id) {
-    if (id < -2 || id >= m_fields.size() - 2)
+    if (id < -2 || id >= (int) m_fields.size() - 2)
         throw 111;
     return m_fields[id + 2];
 }
 
 size_t Packet::GetLength() {
     size_t len = 0;
-    for (int i = 0; i < m_fields.size(); i++)
-        len += m_fields[i].GetLength();
+    for (auto &it:m_fields) {
+        len += it.GetLength();
+    }
     return len + m_dataLength;
 }
 
diff --git a/src/packet/Packet.hpp b/src/packet/Packet.hpp
index 67e95e5..68a5d5e 100644
--- a/src/packet/Packet.hpp
+++ b/src/packet/Packet.hpp
@@ -30,7 +30,7 @@ enum PacketsClientBound{
     ChatMessage,
     MultiBlockChange,
     ConfirmTransaction,
-    CloseWindow,
+    CloseWindowEvent,
     OpenWindow,
     WindowItems,
     WindowProperty,
diff --git a/src/packet/PacketParser.cpp b/src/packet/PacketParser.cpp
index 488c812..a609011 100644
--- a/src/packet/PacketParser.cpp
+++ b/src/packet/PacketParser.cpp
@@ -21,7 +21,8 @@ void PacketParser::Parse(Packet &packet, ConnectionState state, bool ClientBound
 }
 
 void PacketParser::ParseServerBound(Packet &packet, ConnectionState state) {
-    throw 107;
+    if (packet.GetLength() != state)
+        throw 107;
 }
 
 void PacketParser::ParseLogin(Packet &packet) {
@@ -32,9 +33,8 @@ void PacketParser::ParseLogin(Packet &packet) {
         case 0x02:
             ParseLogin0x02(packet);
             break;
-        default:
-        {
-            int i = packet.GetId();
+        default: {
+
             //throw 112;
         }
     }
@@ -94,7 +94,7 @@ void PacketParser::ParsePlay0x23(Packet &packet) {
 }
 
 void PacketParser::ParsePlay0x1F(Packet &packet) {
-    packet.ParseField(VarInt);
+    packet.ParseField(VarIntType);
 }
 
 void PacketParser::ParsePlay0x0D(Packet &packet) {
@@ -118,7 +118,7 @@ void PacketParser::ParsePlay0x2E(Packet &packet) {
     packet.ParseField(Float);
     packet.ParseField(Float);
     packet.ParseField(Byte8_t);
-    packet.ParseField(VarInt);
+    packet.ParseField(VarIntType);
 }
 
 void PacketParser::ParsePlay0x1A(Packet &packet) {
@@ -129,19 +129,19 @@ void PacketParser::ParsePlay0x20(Packet &packet) {
     packet.ParseField(Int);
     packet.ParseField(Int);
     packet.ParseField(Boolean);
-    packet.ParseField(VarInt);
-    packet.ParseField(VarInt);
+    packet.ParseField(VarIntType);
+    packet.ParseField(VarIntType);
     packet.ParseField(ByteArray, packet.GetField(4).GetVarInt());
-    packet.ParseField(VarInt);
+    packet.ParseField(VarIntType);
     //packet.ParseField(NbtTag);
     //packet.GetField(7).SetArray(packet.GetField(6).GetVarInt());
 }
 
 void PacketParser::ParsePlay0x07(Packet &packet) {
-    packet.ParseField(VarInt);
+    packet.ParseField(VarIntType);
     packet.AddField(Field());
-    for (int i=0;i<packet.GetField(0).GetVarInt();i++){
+    for (int i = 0; i < packet.GetField(0).GetVarInt(); i++) {
         packet.ParseFieldArray(packet.GetField(1), String, 0);
-        packet.ParseFieldArray(packet.GetField(1), VarInt, 0);
+        packet.ParseFieldArray(packet.GetField(1), VarIntType, 0);
     }
 }
diff --git a/src/world/Block.cpp b/src/world/Block.cpp
index 54b7e5e..74423e0 100644
--- a/src/world/Block.cpp
+++ b/src/world/Block.cpp
@@ -2,7 +2,7 @@
 
 Block::~Block() {}
 
-Block::Block(unsigned short id, unsigned short state, unsigned char light) : id(id), state(state) {}
+Block::Block(unsigned short id, unsigned short state) : id(id), state(state) {}
 
 Block::Block() : id(0), state(0) {}
 
diff --git a/src/world/Block.hpp b/src/world/Block.hpp
index 1a53868..50268f3 100644
--- a/src/world/Block.hpp
+++ b/src/world/Block.hpp
@@ -3,7 +3,7 @@
 struct Block {
     Block();
 
-    Block(unsigned short id, unsigned short state = 0, unsigned char light = 0);
+    Block(unsigned short id, unsigned short state);
 
     ~Block();
 
diff --git a/src/world/Section.cpp b/src/world/Section.cpp
index 5c42ea5..6147295 100644
--- a/src/world/Section.cpp
+++ b/src/world/Section.cpp
@@ -36,6 +36,7 @@ Block &Section::GetBlock(Vector pos) {
         while (m_dataBlocks != nullptr) {
             parseWaiter.wait(parseLocker);
         }
+        LOG(WARNING)<<"Successfully waited for block render!";
     }
     return m_blocks[pos.GetY() * 256 + pos.GetZ() * 16 + pos.GetX()];
 }
@@ -45,13 +46,13 @@ void Section::Parse() {
         return;
 
     long long *longArray = reinterpret_cast<long long *>(m_dataBlocks);
-    for (int i = 0; i < m_dataBlocksLen / 8; i++)
+    for (size_t i = 0; i < m_dataBlocksLen / 8; i++)
         endswap(&longArray[i]);
     std::vector<unsigned short> blocks;
     blocks.reserve(4096);
     int bitPos = 0;
     unsigned short t = 0;
-    for (int i = 0; i < m_dataBlocksLen; i++) {
+    for (size_t i = 0; i < m_dataBlocksLen; i++) {
         for (int j = 0; j < 8; j++) {
             t |= (m_dataBlocks[i] & 0x01) ? 0x80 : 0x00;
             t >>= 1;
@@ -77,7 +78,7 @@ void Section::Parse() {
     }
     for (int i = 0; i < 4096; i++) {
         unsigned short blockId = m_palette.size() > 0 ? m_palette[blocks[i]] : blocks[i];
-        Block block(blockId, 0, light[i]);
+        Block block(blockId>>4, blockId>>4 & 0xF);
         m_blocks.push_back(block);
     }
     if ((light.size() + blocks.size()) / 2 != 4096) {
@@ -90,7 +91,17 @@ void Section::Parse() {
     m_dataLight = nullptr;
     delete[] m_dataSkyLight;
     m_dataSkyLight = nullptr;
+
     parseWaiter.notify_all();
+    /*static std::map<Block,int> totalBlocks;
+    for (int x=0;x<16;x++)
+        for (int y=0;y<16;y++)
+            for (int z=0;z<16;z++)
+                totalBlocks[GetBlock(Vector(x,y,z))]++;
+    LOG(ERROR)<<"Logging chunk";
+    for (auto& it:totalBlocks){
+        LOG(WARNING)<<it.first.id<<":"<<(int)it.first.state<<" = "<<it.second;
+    }*/
 }
 
 Section &Section::operator=(Section other) {
diff --git a/src/world/Section.hpp b/src/world/Section.hpp
index 3065cbd..36fc91a 100644
--- a/src/world/Section.hpp
+++ b/src/world/Section.hpp
@@ -3,6 +3,7 @@
 #include <vector>
 #include <map>
 #include <condition_variable>
+#include <easylogging++.h>
 #include "Block.hpp"
 #include "../packet/Field.hpp"
 
diff --git a/src/world/World.cpp b/src/world/World.cpp
index d13d01d..121b904 100644
--- a/src/world/World.cpp
+++ b/src/world/World.cpp
@@ -1,5 +1,3 @@
-#include <bitset>
-#include <easylogging++.h>
 #include "World.hpp"
 
 void World::ParseChunkData(Packet packet) {
@@ -43,7 +41,7 @@ Section World::ParseSection(byte *data, size_t &dataLen) {
     data += fBitsPerBlock.GetLength();
     dataLen += fBitsPerBlock.GetLength();
 
-    Field fPaletteLength = FieldParser::Parse(VarInt, data);
+    Field fPaletteLength = FieldParser::Parse(VarIntType, data);
     int paletteLength = fPaletteLength.GetVarInt();
     data += fPaletteLength.GetLength();
     dataLen += fPaletteLength.GetLength();
@@ -52,7 +50,7 @@ Section World::ParseSection(byte *data, size_t &dataLen) {
     if (paletteLength > 0) {
         for (unsigned char i = 0; i < paletteLength; i++) {
             endswap(&i);
-            Field f = FieldParser::Parse(VarInt, data);
+            Field f = FieldParser::Parse(VarIntType, data);
             data += f.GetLength();
             dataLen += f.GetLength();
             palette.push_back(f.GetVarInt());
@@ -60,7 +58,7 @@ Section World::ParseSection(byte *data, size_t &dataLen) {
         }
     }
 
-    Field fDataLength = FieldParser::Parse(VarInt, data);
+    Field fDataLength = FieldParser::Parse(VarIntType, data);
     data += fDataLength.GetLength();
     dataLen += fDataLength.GetLength();
 
diff --git a/src/world/World.hpp b/src/world/World.hpp
index cef9eea..b33499c 100644
--- a/src/world/World.hpp
+++ b/src/world/World.hpp
@@ -5,6 +5,8 @@
 #include <mutex>
 #include <condition_variable>
 #include <queue>
+#include <bitset>
+#include <easylogging++.h>
 #include "Block.hpp"
 #include "../packet/Packet.hpp"
 #include "Section.hpp"