44 files changed, 1092 insertions, 1044 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fb30f12..af0c9cb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,20 +7,21 @@ set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 # SOURCES
 ##########
 
-set(SRC_CORE src/core/Core.hpp src/core/Core.cpp src/core/AssetManager.hpp src/core/AssetManager.cpp)
-set(SRC_GAMESTATE src/gamestate/GameState.hpp src/gamestate/GameState.cpp)
-set(SRC_GRAPHICS src/graphics/Texture.cpp src/graphics/Shader.cpp)
-set(SRC_GUI src/gui/Gui.cpp src/gui/Widget.cpp)
-set(SRC_NBT src/nbt/Nbt.hpp)
-set(SRC_NETWORK src/network/Network.cpp src/network/NetworkClient.cpp src/network/Socket.cpp src/network/Stream.cpp
-        src/network/Packet.hpp)
-set(SRC_UTILITY src/utility/Vector.hpp src/utility/utility.cpp)
-set(SRC_WORLD src/world/Block.cpp src/world/Section.cpp src/world/World.cpp src/world/Collision.cpp src/world/Collision.hpp)
+#[[set(SRC_CORE src/core/Core.cpp src/core/AssetManager.cpp)
+set(SRC_GRAPHICS src/graphics/Texture.cpp src/graphics/Shader.cpp src/graphics/RenderSection.cpp src/graphics/Gui.cpp
+        src/graphics/Widget.cpp)
+set(SRC_NBT include/Nbt.hpp)
+set(SRC_NETWORK src/network/Network.cpp src/network/NetworkClient.cpp src/network/Socket.cpp src/network/Stream.cpp)
+set(SRC_WORLD src/world/Block.cpp src/world/Section.cpp src/world/World.cpp src/world/Collision.cpp
+        src/world/GameState.cpp)*#
 
-set(SOURCE_FILES src/main.cpp ${SRC_CORE} ${SRC_GAMESTATE} ${SRC_GRAPHICS} ${SRC_GUI} ${SRC_GRAPHICS} ${SRC_GUI}
-        ${SRC_NBT} ${SRC_NETWORK} ${SRC_UTILITY} ${SRC_WORLD})
+set(SOURCE_FILES src/main.cpp ${SRC_CORE} ${SRC_GRAPHICS} ${SRC_NETWORK} ${SRC_WORLD})]]#
+file(GLOB_RECURSE SOURCES "./src/*.cpp")
+file(GLOB_RECURSE HEADERS "./include/*.hpp")
 
-add_executable(AltCraft ${SOURCE_FILES})
+add_executable(AltCraft ${HEADERS} ${SOURCES})
+
+target_include_directories(AltCraft PUBLIC include/)
 
 ################
 # CONFIGURATION
diff --git a/include/AssetManager.hpp b/include/AssetManager.hpp
new file mode 100644
index 0000000..f91c722
--- /dev/null
+++ b/include/AssetManager.hpp
@@ -0,0 +1,72 @@
+#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;
+public:
+	AssetManager();
+
+	~AssetManager();
+
+	void LoadTextureResources();
+
+	TextureCoordinates GetTextureByAssetName(std::string AssetName);
+
+	std::string GetTextureAssetNameByBlockId(BlockTextureId block);
+
+	GLuint GetTextureAtlas();
+
+	void LoadIds();
+
+	TextureCoordinates GetTextureByBlock(BlockTextureId block);
+};
diff --git a/src/core/Core.hpp b/include/Core.hpp
index 4cc334c..64fab4e 100644
--- a/src/core/Core.hpp
+++ b/include/Core.hpp
@@ -1,16 +1,19 @@
 #pragma once
 
+#include <iomanip>
+#include <tuple>
+
 #include <easylogging++.h>
 #include <SFML/Window.hpp>
 #include <GL/glew.h>
-#include <iomanip>
-#include <tuple>
 #include <glm/gtc/type_ptr.hpp>
-#include "../gamestate/GameState.hpp"
-#include "../network/NetworkClient.hpp"
-#include "../gui/Gui.hpp"
-#include "../graphics/Shader.hpp"
-#include "AssetManager.hpp"
+
+#include <GameState.hpp>
+#include <AssetManager.hpp>
+#include <graphics/Shader.hpp>
+#include <graphics/Gui.hpp>
+#include <graphics/RenderSection.hpp>
+#include <network/NetworkClient.hpp>
 
 class Core {
 	GameState *gameState;
@@ -31,8 +34,6 @@ class Core {
 
 	void RenderWorld();
 
-	void RenderGui(Gui &Target);
-
 	void HandleMouseCapture();
 
 	void HandleEvents();
@@ -43,7 +44,7 @@ class Core {
 
 	void SetMouseCapture(bool IsCaptured);
 
-	void PrepareToWorldRendering();
+	void PrepareToRendering();
 
 	void RenderFrame();
 
@@ -57,19 +58,22 @@ class Core {
 
 	std::thread gameStateLoopThread;
 
-	Shader *shader,*shader2;
-	//Cube verticies, Cube VAO, Cube UVs, TextureIndexes UBO, TextureData UBO, TextureData2 UBO, Blocks VBO, Models VBO, Line VAO, Lines VBO
-	GLuint VBO, VAO, VBO2, UBO, UBO2, VBO3, VBO4, VAO2, VBO5;
+	Shader *shader;
+	//Cube verticies, Cube VAO, Cube UVs, TextureIndexes UboTextureIndexes, TextureData UboTextureIndexes, TextureData2 UboTextureIndexes, Blocks VBO, Models VBO, Line VAO, Lines VBO
+	//GLuint VBO, VAO, VBO2, UboTextureIndexes, UboTextureData, VBO3, VBO4, VAO2, VBO5;
+	GLuint UboTextureIndexes, UboTextureData;
+	//std::vector<Vector> toRender;
 	std::vector<Vector> toRender;
-	std::vector<Vector> optimizedRender;
+	std::map<Vector, RenderSection> availableChunks;
 
 	int ChunkDistance = 2;
 
-	std::map<Vector, std::vector<glm::mat4>> toRenderModels;
-	std::map<Vector, std::vector<glm::vec2>> toRenderBlocks;
-	//std::map<Vector, std::tuple<std::vector<glm::mat4>, std::vector<glm::vec2> > > sectionsRenderingData;
+	RenderState renderState;
+
+	/*std::map<Vector, std::vector<glm::mat4>> toRenderModels;
+	std::map<Vector, std::vector<glm::vec2>> toRenderBlocks;*/
 
-	double tickRate=0;
+	double tickRate = 0;
 
 public:
 	Core();
diff --git a/src/gamestate/GameState.hpp b/include/GameState.hpp
index 27338fb..6741882 100644
--- a/src/gamestate/GameState.hpp
+++ b/include/GameState.hpp
@@ -3,9 +3,10 @@
 #include <nlohmann/json.hpp>
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
-#include "../world/World.hpp"
-#include "../network/NetworkClient.hpp"
-#include "../utility/Vector.hpp"
+
+#include <world/World.hpp>
+#include <network/NetworkClient.hpp>
+#include <Vector.hpp>
 
 class GameState {
 	NetworkClient *nc;
diff --git a/include/Nbt.hpp b/include/Nbt.hpp
new file mode 100644
index 0000000..03f5af0
--- /dev/null
+++ b/include/Nbt.hpp
@@ -0,0 +1,516 @@
+#pragma once
+
+#include <cstddef>
+#include <vector>
+#include <fstream>
+#include <zlib.h>
+
+#include <Utility.hpp>
+
+namespace nbt {
+	enum TagType {
+		End,        //nullptr
+		Byte,       //int8_t
+		Short,      //int16_t
+		Int,        //int32_t
+		Long,       //int64_t
+		Float,      //float
+		Double,     //double
+		ByteArray,  //std::vector<signed char>
+		String,     //std::string
+		List,       //std::vector<NbtTag>
+		Compound,   //std::vector<NbtTag>
+		IntArray,   //std::vector<int32_t>
+		Unknown,    //dummy value
+	};
+
+	class NbtTag;
+
+	typedef std::vector<NbtTag> compound_t;
+
+	typedef std::string string_t;
+
+	typedef std::vector<signed char> byteArray_t;
+
+	typedef std::vector<int> intArray_t;
+
+	class NbtTag {
+		TagType type = Unknown;
+		string_t name = "";
+		unsigned char *data = nullptr;
+	public:
+		NbtTag(TagType type, string_t name) : type(type), name(name) {
+			switch (type) {
+				case End:
+					data = nullptr;
+					break;
+				case Compound:
+					data = (unsigned char *) new compound_t;
+					break;
+				case String:
+					data = (unsigned char *) new string_t;
+					break;
+				case Int:
+					data = (unsigned char *) new int32_t;
+					break;
+				case Long:
+					data = (unsigned char *) new int64_t;
+					break;
+				case Byte:
+					data = (unsigned char *) new int8_t;
+					break;
+				case Short:
+					data = (unsigned char *) new int16_t;
+					break;
+				case Float:
+					data = (unsigned char *) new float;
+					break;
+				case Double:
+					data = (unsigned char *) new double;
+					break;
+				case ByteArray:
+					data = (unsigned char *) new byteArray_t;
+					break;
+				case List:
+					data = (unsigned char *) new compound_t;
+					break;
+				case IntArray:
+					data = (unsigned char *) new intArray_t;
+			}
+		}
+
+		NbtTag(const NbtTag &other) : type(other.type), name(other.name) {
+			switch (type) {
+				case Byte:
+					data = (unsigned char *) new int8_t;
+					*((int8_t *) data) = *((int8_t *) other.data);
+					break;
+				case Short:
+					data = (unsigned char *) new int16_t;
+					*((int16_t *) data) = *((int16_t *) other.data);
+					break;
+				case Int:
+					data = (unsigned char *) new int32_t;
+					*((int32_t *) data) = *((int32_t *) other.data);
+					break;
+				case Long:
+					data = (unsigned char *) new int64_t;
+					*((int64_t *) data) = *((int64_t *) other.data);
+					break;
+				case Float:
+					data = (unsigned char *) new float;
+					*((float *) data) = *((float *) other.data);
+					break;
+				case Double:
+					data = (unsigned char *) new double;
+					*((double *) data) = *((double *) other.data);
+					break;
+				case ByteArray:
+					data = (unsigned char *) new byteArray_t;
+					*((std::vector<signed char> *) data) = *((std::vector<signed char> *) other.data);
+					break;
+				case String:
+					data = (unsigned char *) new string_t;
+					*((std::string *) data) = *((std::string *) other.data);
+					break;
+				case List:
+					data = (unsigned char *) new compound_t;
+					*((std::vector<NbtTag> *) data) = *((std::vector<NbtTag> *) other.data);
+					break;
+				case Compound:
+					data = (unsigned char *) new compound_t;
+					*((std::vector<NbtTag> *) data) = *((std::vector<NbtTag> *) other.data);
+					break;
+				case IntArray:
+					data = (unsigned char *) new intArray_t;
+					*((std::vector<int> *) data) = *((std::vector<int> *) other.data);
+					break;
+			}
+		}
+
+		~NbtTag() {
+			switch (type) {
+				case Byte:
+					delete ((int8_t *) data);
+					break;
+				case Short:
+					delete ((int16_t *) data);
+					break;
+				case Int:
+					delete ((int32_t *) data);
+					break;
+				case Long:
+					delete ((int64_t *) data);
+					break;
+				case Float:
+					delete ((float *) data);
+					break;
+				case Double:
+					delete ((double *) data);
+					break;
+				case ByteArray:
+					delete ((std::vector<signed char> *) data);
+					break;
+				case String:
+					delete ((std::string *) data);
+					break;
+				case List:
+					delete ((std::vector<NbtTag> *) data);
+					break;
+				case Compound:
+					delete ((std::vector<NbtTag> *) data);
+					break;
+				case IntArray:
+					delete ((std::vector<int> *) data);
+					break;
+			}
+		};
+
+		void swap(NbtTag &other) {
+			std::swap(other.data, data);
+			std::swap(other.name, name);
+			std::swap(other.type, type);
+		}
+
+		NbtTag &operator=(NbtTag other) {
+			other.swap(*this);
+			return *this;
+		}
+
+		TagType GetType() const {
+			return type;
+		}
+
+		string_t GetName() const {
+			return name;
+		}
+
+
+		string_t &GetString() {
+			string_t &val = *reinterpret_cast<std::string *>(data);
+			return val;
+		}
+
+		compound_t &GetCompound() {
+			std::vector<NbtTag> &val = *reinterpret_cast<std::vector<NbtTag> *>(data);
+			return val;
+		}
+
+		compound_t &GetList() {
+			std::vector<NbtTag> &val = *reinterpret_cast<std::vector<NbtTag> *>(data);
+			return val;
+		}
+
+		int64_t &GetLong() {
+			int64_t &val = *reinterpret_cast<int64_t *>(data);
+			return val;
+		}
+
+		float &GetFloat() {
+			float &val = *reinterpret_cast<float *>(data);
+			return val;
+		}
+
+		double &GetDouble() {
+			double &val = *reinterpret_cast<double *>(data);
+			return val;
+		}
+
+		byteArray_t &GetByteArray() {
+			auto &val = *reinterpret_cast<byteArray_t *>(data);
+			return val;
+		}
+
+		intArray_t &GetIntArray() {
+			auto &val = *reinterpret_cast<intArray_t *>(data);
+			return val;
+		}
+
+		int16_t &GetShort() {
+			auto &val = *reinterpret_cast<int16_t *>(data);
+			return val;
+		}
+
+		int32_t &GetInt() {
+			auto &val = *reinterpret_cast<int32_t *>(data);
+			return val;
+		}
+
+		int8_t &GetByte() {
+			auto &val = *reinterpret_cast<int8_t *>(data);
+			return val;
+		}
+	};
+
+	NbtTag ParseTag(unsigned char *data, size_t &size, TagType listItemType = Unknown) {
+		size = 0;
+		TagType type;
+		if (listItemType == Unknown) {
+			type = (TagType) *data;
+			data += 1;
+			size += 1;
+		} else
+			type = listItemType;
+		string_t name;
+		if (listItemType == Unknown && type != End) {
+			short nameLen = *((short *) data);
+			data += 2;
+			size += 2;
+			endswap(&nameLen);
+			name = std::string((char *) data, nameLen);
+			data += nameLen;
+			size += nameLen;
+		}
+		NbtTag tag(type, name);
+		switch (type) {
+			case Compound: {
+				do {
+					size_t s;
+					tag.GetCompound().push_back(ParseTag(data, s));
+					data += s;
+					size += s;
+				} while (tag.GetCompound().back().GetType() != End);
+				tag.GetCompound().pop_back();
+				return tag;
+			}
+			case String: {
+				short len = *((short *) data);
+				data += 2;
+				size += 2;
+				endswap(&len);
+				string_t str((char *) data, len);
+				data += len;
+				size += len;
+				tag.GetString() = str;
+				return tag;
+			}
+			case End:
+				return tag;
+			case Long:
+				tag.GetLong() = *((int64_t *) data);
+				endswap(&tag.GetLong());
+				data += 8;
+				size += 8;
+				return tag;
+			case Short:
+				tag.GetShort() = *((int16_t *) data);
+				endswap(&tag.GetShort());
+				data += 2;
+				size += 2;
+				return tag;
+			case Float:
+				tag.GetFloat() = *((float *) data);
+				endswap(&tag.GetFloat());
+				data += 4;
+				size += 4;
+				return tag;
+			case Double:
+				tag.GetDouble() = *((double *) data);
+				endswap(&tag.GetDouble());
+				data += 8;
+				size += 8;
+				return tag;
+			case Byte:
+				tag.GetByte() = *((int8_t *) data);
+				endswap(&tag.GetByte());
+				data += 1;
+				size += 1;
+				return tag;
+			case Int:
+				tag.GetInt() = *((int32_t *) data);
+				endswap(&tag.GetInt());
+				data += 4;
+				size += 4;
+				return tag;
+			case List: {
+				TagType listType = *((TagType *) data);
+				data += 1;
+				size += 1;
+				int32_t listLength = *((int32_t *) data);
+				endswap(&listLength);
+				data += 4;
+				size += 4;
+				for (int i = 0; i < listLength; i++) {
+					size_t s = 0;
+					std::vector<NbtTag> &vec = tag.GetCompound();
+					vec.push_back(ParseTag(data, s, listType));
+					data += s;
+					size += s;
+				}
+				return tag;
+			}
+			case ByteArray: {
+				int32_t arrLength = *((int32_t *) data);
+				endswap(&arrLength);
+				data += 4;
+				size += 4;
+				for (int i = 0; i < arrLength; i++) {
+					signed char val = (signed char) data[i];
+					std::vector<signed char> &vec = tag.GetByteArray();
+					vec.push_back(val);
+				}
+				data += arrLength;
+				size += arrLength;
+				return tag;
+			}
+			default:
+				throw 13;
+		}
+	}
+
+	NbtTag ParseTag(unsigned char *data, size_t *optionalSize = nullptr) {
+		size_t s = 0;
+		size_t &size = (optionalSize ? *optionalSize : s);
+		return ParseTag(data, size);
+	}
+
+	std::vector<unsigned char> Decompress(unsigned char *data, size_t dataLen) {
+		const size_t decompBuffSize = 1024 * 16;
+		unsigned char *decompBuff = new unsigned char[decompBuffSize];
+		std::vector<unsigned char> uncompressed;
+		for (int i = 0; i < decompBuffSize; i++)
+			decompBuff[i] = 0;
+
+
+		z_stream stream;
+		stream.zalloc = Z_NULL;
+		stream.zfree = Z_NULL;
+		stream.opaque = Z_NULL;
+		stream.next_in = data;
+		stream.avail_in = dataLen;
+		stream.next_out = decompBuff;
+		stream.avail_out = decompBuffSize;
+
+		if (inflateInit2(&stream, 15 + 32) != Z_OK) {
+			delete[] decompBuff;
+			throw 171;
+		}
+
+		int res;
+		do {
+			stream.avail_out = decompBuffSize;
+
+			switch ((res = inflate(&stream, Z_NO_FLUSH))) {
+				case Z_MEM_ERROR:
+					throw 172;
+				case Z_DATA_ERROR:
+					throw 173;
+				case Z_NEED_DICT:
+					throw 174;
+			}
+
+			uncompressed.resize(uncompressed.size() + decompBuffSize);
+			std::copy(decompBuff, decompBuff + decompBuffSize, uncompressed.end() - decompBuffSize);
+		} while (stream.avail_out == 0);
+		if (res != Z_STREAM_END)
+			throw 175;
+		if (inflateEnd(&stream) != Z_OK)
+			throw 176;
+		delete[] decompBuff;
+		return uncompressed;
+	}
+
+	NbtTag ParseCompressed(unsigned char *data, size_t dataLen) {
+		auto uncompressed = Decompress(data, dataLen);
+		NbtTag root = ParseTag(uncompressed.data());
+		return root;
+	}
+
+	NbtTag Parse(unsigned char *data, size_t dataLen) {
+		bool isCompressed = *data != 10;
+		if (isCompressed)
+			return ParseCompressed(data, dataLen);
+		else
+			return ParseTag(data);
+	}
+
+	void PrintTree(NbtTag &tree, int deepness = 0, std::ostream &ostream = std::cout) {
+		ostream << std::string(deepness, '\t') << "Tag ";
+		switch (tree.GetType()) {
+			case Byte:
+				ostream << "byte";
+				break;
+			case Short:
+				ostream << "short";
+				break;
+			case Int:
+				ostream << "int";
+				break;
+			case Long:
+				ostream << "long";
+				break;
+			case Float:
+				ostream << "float";
+				break;
+			case Double:
+				ostream << "double";
+				break;
+			case ByteArray:
+				ostream << "byte array";
+				break;
+			case String:
+				ostream << "string";
+				break;
+			case List:
+				ostream << "list";
+				break;
+			case Compound:
+				ostream << "compound";
+				break;
+			case IntArray:
+				ostream << "int array";
+				break;
+			case End:
+				ostream << "end";
+				break;
+		}
+		if (tree.GetName().length() > 0)
+			ostream << " (" << tree.GetName() << ")";
+		ostream << ": ";
+
+		if (tree.GetType() == Compound || tree.GetType() == List) {
+			std::vector<NbtTag> &vec = (tree.GetType() == Compound ? tree.GetCompound() : tree.GetList());
+			ostream << vec.size() << " entries {" << std::endl;
+			for (auto it = vec.begin(); it != vec.end(); ++it) {
+				PrintTree(*it, deepness + 1, std::cout);
+			}
+			ostream << std::string(deepness, '\t') << "}" << std::endl;
+			return;
+		} else {
+			switch (tree.GetType()) {
+				case Int:
+					ostream << tree.GetInt();
+					break;
+				case String:
+					ostream << "\"" << tree.GetString() << "\"";
+					break;
+				case Double:
+					ostream << tree.GetDouble();
+					break;
+				case Float:
+					ostream << tree.GetFloat();
+					break;
+				case Short:
+					ostream << tree.GetShort();
+					break;
+				case Byte:
+					ostream << (int) tree.GetByte();
+					break;
+				case Long:
+					ostream << tree.GetLong();
+					break;
+				case ByteArray:
+					ostream << "[" << tree.GetByteArray().size() << " bytes]: ";
+					for (int i = 0; i < (tree.GetByteArray().size() > 10 ? 10 : tree.GetByteArray().size()); i++) {
+						ostream << std::hex << "0x" << (tree.GetByteArray()[i] > 15 ? "" : "0")
+						        << (int) tree.GetByteArray()[i]
+						        << std::dec << " ";
+					}
+					break;
+				case IntArray:
+					break;
+			}
+			ostream << std::endl;
+		}
+	}
+}
\ No newline at end of file
diff --git a/include/Utility.hpp b/include/Utility.hpp
new file mode 100644
index 0000000..92e924f
--- /dev/null
+++ b/include/Utility.hpp
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <algorithm>
+
+#include <GL/glew.h>
+
+template<class T>
+void endswap(T *objp) {
+	unsigned char *memp = reinterpret_cast<unsigned char *>(objp);
+	std::reverse(memp, memp + sizeof(T));
+}
+
+template<class T>
+void endswap(T &obj) {
+	unsigned char *raw = reinterpret_cast<unsigned char *>(&obj);
+	std::reverse(raw, raw + sizeof(T));
+}
+
+inline void endswap(unsigned char *arr, size_t arrLen) {
+	std::reverse(arr, arr + arrLen);
+}
+
+inline 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__)
\ No newline at end of file
diff --git a/src/utility/Vector.hpp b/include/Vector.hpp
index 9d6c1be..a2d5c6a 100644
--- a/src/utility/Vector.hpp
+++ b/include/Vector.hpp
@@ -1,10 +1,11 @@
 #pragma once
 
-#include <glm/vec3.hpp>
 #include <ostream>
 #include <cmath>
 #include <tuple>
 
+#include <glm/vec3.hpp>
+
 template<class T>
 class Vector3 {
 	T x, y, z;
@@ -101,14 +102,6 @@ public:
 	}
 
 	bool operator<(const Vector3 &rhs) const {
-		//return (x < rhs.x || y < rhs.y ||z z < rhs.z);
-		/*if (x < rhs.x)
-			return true;
-		else if (z < rhs.z)
-			return true;
-		else if (y < rhs.y)
-			return true;
-		return false;*/
 		return std::tie(x, y, z) < std::tie(rhs.x, rhs.y, rhs.z);
 	}
 
diff --git a/src/gui/Gui.hpp b/include/graphics/Gui.hpp
index 641b941..641b941 100644
--- a/src/gui/Gui.hpp
+++ b/include/graphics/Gui.hpp
diff --git a/include/graphics/RenderSection.hpp b/include/graphics/RenderSection.hpp
new file mode 100644
index 0000000..6a2f3ce
--- /dev/null
+++ b/include/graphics/RenderSection.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <GL/glew.h>
+#include <glm/detail/type_mat.hpp>
+#include <glm/vec2.hpp>
+#include <glm/detail/type_mat4x4.hpp>
+#include <glm/gtx/transform.hpp>
+#include <easylogging++.h>
+
+#include <world/Section.hpp>
+#include <world/World.hpp>
+
+class RenderState {
+	GLuint ActiveVao;
+	GLuint ActiveShader;
+public:
+	void SetActiveVao(GLuint Vao);
+	void SetActiveShader(GLuint Shader);
+};
+
+class RenderSection {
+	Vector sectionPosition;
+	World *world;
+	GLuint Vao,VboBlocks,VboModels;
+
+	static GLuint VboVertices,VboUvs;
+	static std::map<GLuint,int> refCounterVbo;
+	static std::map<GLuint,int> refCounterVao;
+
+	size_t numOfBlocks;
+
+public:
+	RenderSection(World *world, Vector position);
+	RenderSection(const RenderSection &other);
+	~RenderSection();
+
+	void UpdateState();
+	void Render(RenderState &state);
+
+	Section* GetSection();
+};
\ No newline at end of file
diff --git a/src/graphics/Shader.hpp b/include/graphics/Shader.hpp
index 1bcee3a..17a434e 100644
--- a/src/graphics/Shader.hpp
+++ b/include/graphics/Shader.hpp
@@ -1,7 +1,9 @@
 #pragma once
+
 #include <string>
 #include <fstream>
 #include <sstream>
+
 #include <easylogging++.h>
 #include <GL/glew.h>
 
diff --git a/src/graphics/Texture.hpp b/include/graphics/Texture.hpp
index 277806a..277806a 100644
--- a/src/graphics/Texture.hpp
+++ b/include/graphics/Texture.hpp
diff --git a/src/gui/Widget.hpp b/include/graphics/Widget.hpp
index c4d5dc1..c4d5dc1 100644
--- a/src/gui/Widget.hpp
+++ b/include/graphics/Widget.hpp
diff --git a/src/network/Network.hpp b/include/network/Network.hpp
index 1281289..1281289 100644
--- a/src/network/Network.hpp
+++ b/include/network/Network.hpp
diff --git a/src/network/NetworkClient.hpp b/include/network/NetworkClient.hpp
index bf7aa4e..22b1b22 100644
--- a/src/network/NetworkClient.hpp
+++ b/include/network/NetworkClient.hpp
@@ -3,7 +3,8 @@
 #include <thread>
 #include <queue>
 #include <mutex>
-#include "Network.hpp"
+
+#include <network/Network.hpp>
 
 class NetworkClient {
 	Network network;
diff --git a/src/network/Packet.hpp b/include/network/Packet.hpp
index 3cf4d26..685e3da 100644
--- a/src/network/Packet.hpp
+++ b/include/network/Packet.hpp
@@ -1,7 +1,8 @@
 #pragma once
 
 #include <easylogging++.h>
-#include "Stream.hpp"
+
+#include <network/Stream.hpp>
 
 enum PacketNameLoginSB {
 	LoginStart = 0x00,
diff --git a/src/network/Socket.hpp b/include/network/Socket.hpp
index ee449b3..48bcad9 100644
--- a/src/network/Socket.hpp
+++ b/include/network/Socket.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+
 #include <SFML/Network.hpp>
 
 /**
diff --git a/src/network/Stream.hpp b/include/network/Stream.hpp
index 5babb08..a24dfbe 100644
--- a/src/network/Stream.hpp
+++ b/include/network/Stream.hpp
@@ -5,23 +5,15 @@
 #include <stdexcept>
 #include <vector>
 #include <cstring>
+
 #include <nlohmann/json.hpp>
 #include <easylogging++.h>
-#include "Socket.hpp"
-#include "../utility/Vector.hpp"
-
-class Stream {
-protected:
-	template<class T>
-	void endswap(T &obj) {
-		unsigned char *raw = reinterpret_cast<unsigned char *>(&obj);
-		std::reverse(raw, raw + sizeof(T));
-	}
 
-	void endswap(unsigned char *arr, size_t arrLen) {
-		std::reverse(arr, arr + arrLen);
-	}
+#include <network/Socket.hpp>
+#include <Vector.hpp>
+#include <Utility.hpp>
 
+class Stream {
 public:
 	virtual ~Stream() {};
 };
diff --git a/src/world/Block.hpp b/include/world/Block.hpp
index 2f823fe..2f823fe 100644
--- a/src/world/Block.hpp
+++ b/include/world/Block.hpp
diff --git a/src/world/Collision.hpp b/include/world/Collision.hpp
index b88fbf7..b88fbf7 100644
--- a/src/world/Collision.hpp
+++ b/include/world/Collision.hpp
diff --git a/src/world/Section.hpp b/include/world/Section.hpp
index 657fc13..139b5b5 100644
--- a/src/world/Section.hpp
+++ b/include/world/Section.hpp
@@ -3,10 +3,12 @@
 #include <vector>
 #include <map>
 #include <condition_variable>
+
 #include <easylogging++.h>
-#include "Block.hpp"
-#include "../utility/Vector.hpp"
-#include "../utility/utility.h"
+
+#include <world/Block.hpp>
+#include <Vector.hpp>
+#include <Utility.hpp>
 
 const int SECTION_WIDTH = 16;
 const int SECTION_LENGTH = 16;
@@ -24,11 +26,13 @@ class Section {
 
 	Section();
 
+	Vector worldPosition;
+
 public:
 	void Parse();
 
-	Section(byte *dataBlocks, size_t dataBlocksLength, byte *dataLight, byte *dataSky, byte bitsPerBlock,
-	                 std::vector<unsigned short> palette);
+	Section(Vector position, byte *dataBlocks, size_t dataBlocksLength, byte *dataLight, byte *dataSky, byte bitsPerBlock,
+	        std::vector<unsigned short> palette);
 
 	~Section();
 
@@ -36,8 +40,9 @@ public:
 
 	Section &operator=(Section other);
 
-	friend void swap(Section &a, Section& b);
+	friend void swap(Section &a, Section &b);
 
 	Section(const Section &other);
 
+	Vector GetPosition();
 };
\ No newline at end of file
diff --git a/src/world/World.hpp b/include/world/World.hpp
index e315baf..6e5eedb 100644
--- a/src/world/World.hpp
+++ b/include/world/World.hpp
@@ -1,16 +1,14 @@
 #pragma once
 
 #include <map>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <queue>
 #include <bitset>
+
 #include <easylogging++.h>
-#include "Block.hpp"
-#include "Section.hpp"
-#include "../network/Packet.hpp"
-#include "Collision.hpp"
+
+#include <world/Block.hpp>
+#include <world/Section.hpp>
+#include <network/Packet.hpp>
+#include <world/Collision.hpp>
 
 class World {
 	//utility vars
@@ -22,7 +20,7 @@ class World {
 	int dimension = 0;
 
 	//game methods
-	Section ParseSection(StreamInput *data);
+	Section ParseSection(StreamInput *data, Vector position);
 
 public:
 	World();
diff --git a/src/core/AssetManager.cpp b/src/core/AssetManager.cpp
index 4fb5388..f4c0801 100644
--- a/src/core/AssetManager.cpp
+++ b/src/core/AssetManager.cpp
@@ -1,5 +1,4 @@
-
-#include "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 ebb339f..0000000
--- a/src/core/AssetManager.hpp
+++ /dev/null
@@ -1,71 +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;
-public:
-    AssetManager();
-
-    ~AssetManager();
-
-    void LoadTextureResources();
-
-    TextureCoordinates GetTextureByAssetName(std::string AssetName);
-
-    std::string GetTextureAssetNameByBlockId(BlockTextureId block);
-
-    GLuint GetTextureAtlas();
-
-    void LoadIds();
-
-    TextureCoordinates GetTextureByBlock(BlockTextureId block);
-};
diff --git a/src/core/Core.cpp b/src/core/Core.cpp
index 50bcd81..5538439 100644
--- a/src/core/Core.cpp
+++ b/src/core/Core.cpp
@@ -1,139 +1,5 @@
 #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,
-		-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,
-		0.0f, 0.0f,
-		1.0f, 0.0f,
-		0.0f, 1.0f,
-		1.0f, 0.0f,
-		1.0f, 1.0f,
-
-		//Z-
-		1.0f, 0.0f,
-		1.0f, 1.0f,
-		0.0f, 0.0f,
-		0.0f, 0.0f,
-		1.0f, 1.0f,
-		0.0f, 1.0f,
-
-		//X+
-		0.0f, 0.0f,
-		1.0f, 0.0f,
-		0.0f, 1.0f,
-		0.0f, 1.0f,
-		1.0f, 0.0f,
-		1.0f, 1.0f,
-
-		//X-
-		0.0f, 0.0f,
-		1.0f, 1.0f,
-		0.0f, 1.0f,
-		0.0f, 0.0f,
-		1.0f, 0.0f,
-		1.0f, 1.0f,
-
-		//Y+
-		0.0f, 0.0f,
-		1.0f, 1.0f,
-		0.0f, 1.0f,
-		0.0f, 0.0f,
-		1.0f, 0.0f,
-		1.0f, 1.0f,
-
-		//Y-
-		1.0f, 0.0f,
-		0.0f, 1.0f,
-		0.0f, 0.0f,
-		1.0f, 1.0f,
-		0.0f, 1.0f,
-		1.0f, 0.0f,
-};
-
 Core::Core() {
 	LOG(INFO) << "Core initializing...";
 	InitSfml(900, 450, "AltCraft");
@@ -145,7 +11,7 @@ Core::Core() {
 	std::thread loop = std::thread(&Core::UpdateGameState, this);
 	std::swap(loop, gameStateLoopThread);
 	assetManager = new AssetManager;
-	PrepareToWorldRendering();
+	PrepareToRendering();
 	LOG(INFO) << "Core is initialized";
 	glCheckError();
 }
@@ -254,8 +120,8 @@ void Core::InitGlew() {
 	//glEnable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
 	glFrontFace(GL_CCW);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	//glEnable(GL_BLEND);
+	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	glCheckError();
 }
 
@@ -336,10 +202,6 @@ void Core::HandleMouseCapture() {
 	//camera.ProcessMouseMovement(mouseXDelta, mouseYDelta);
 }
 
-void Core::RenderGui(Gui &Target) {
-	Target.WHY++;
-}
-
 void Core::RenderWorld() {
 	shader->Use();
 	glCheckError();
@@ -356,9 +218,8 @@ void Core::RenderWorld() {
 
 	glCheckError();
 
-	glBindVertexArray(VAO);
-	for (auto &sectionPos : toRender) {
-		//Section &section = gameState->world.sections.find(sectionPos)->second;
+	for (auto &render : toRender) {
+		Section &section = *availableChunks.find(render)->second.GetSection();
 
 		std::vector<Vector> sectionCorners = {
 				Vector(0, 0, 0),
@@ -373,8 +234,9 @@ void Core::RenderWorld() {
 		bool isBreak = true;
 		for (auto &it:sectionCorners) {
 			glm::mat4 vp = projection * view;
-			glm::vec3 point(sectionPos.GetX() * 16 + it.GetX(), sectionPos.GetY() * 16 + it.GetY(),
-			                sectionPos.GetZ() * 16 + it.GetZ());
+			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) {
@@ -383,24 +245,13 @@ void Core::RenderWorld() {
 			}
 		}
 		if (isBreak && glm::length(gameState->Position() -
-		                           glm::vec3(sectionPos.GetX() * 16, sectionPos.GetY() * 16, sectionPos.GetZ() * 16)) >
-		               30) {
+		                           glm::vec3(section.GetPosition().GetX() * 16,
+		                                     section.GetPosition().GetY() * 16,
+		                                     section.GetPosition().GetZ() * 16)) > 30.0f) {
 			continue;
 		}
-
-		std::vector<glm::mat4> &arrOfModels = toRenderModels[sectionPos];
-		std::vector<glm::vec2> &arrOfBlocks = toRenderBlocks[sectionPos];
-
-		glBindBuffer(GL_ARRAY_BUFFER, VBO3);
-		glBufferData(GL_ARRAY_BUFFER, arrOfModels.size() * sizeof(glm::mat4), arrOfModels.data(), GL_DYNAMIC_DRAW);
-
-		glBindBuffer(GL_ARRAY_BUFFER, VBO4);
-		glBufferData(GL_ARRAY_BUFFER, arrOfBlocks.size() * sizeof(glm::vec2), arrOfBlocks.data(), GL_DYNAMIC_DRAW);
-
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-		glDrawArraysInstanced(GL_TRIANGLES, 0, 36, arrOfModels.size());
+		availableChunks.find(render)->second.Render(renderState);
 	}
-	glBindVertexArray(0);
 	glCheckError();
 }
 
@@ -411,66 +262,10 @@ void Core::SetMouseCapture(bool IsCaptured) {
 	window->setMouseCursorVisible(!IsCaptured);
 }
 
-void Core::PrepareToWorldRendering() {
-	//Cube-rendering data
-	glGenBuffers(1, &VBO);
-	glGenBuffers(1, &VBO2);
-	glGenBuffers(1, &VBO3);
-	glGenBuffers(1, &VBO4);
-	glGenVertexArrays(1, &VAO);
-
-	glBindVertexArray(VAO);
-	{
-		//Cube vertices
-		glBindBuffer(GL_ARRAY_BUFFER, VBO);
-		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
-		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0);
-		glEnableVertexAttribArray(0);
-
-		//Cube UVs
-		glBindBuffer(GL_ARRAY_BUFFER, VBO2);
-		glBufferData(GL_ARRAY_BUFFER, sizeof(uv_coords), uv_coords, GL_STATIC_DRAW);
-		glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), 0);
-		glEnableVertexAttribArray(2);
-
-		//Blocks ids
-		glBindBuffer(GL_ARRAY_BUFFER, VBO4);
-		glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 16 * 16 * 16, NULL, GL_DYNAMIC_DRAW);
-		glVertexAttribPointer(7, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), 0);
-		glEnableVertexAttribArray(7);
-		glVertexAttribDivisor(7, 1);
-		glCheckError();
-
-		//Blocks models
-		glBindBuffer(GL_ARRAY_BUFFER, VBO3);
-		glBufferData(GL_ARRAY_BUFFER, sizeof(glm::mat4) * 16 * 16 * 16, NULL, GL_DYNAMIC_DRAW);
-		glVertexAttribPointer(8, 4, GL_FLOAT, GL_FALSE, 4 * 4 * sizeof(GLfloat), 0);
-		glEnableVertexAttribArray(8);
-		glVertexAttribPointer(8 + 1, 4, GL_FLOAT, GL_FALSE, 4 * 4 * sizeof(GLfloat),
-		                      (void *) (1 * 4 * sizeof(GLfloat)));
-		glEnableVertexAttribArray(8 + 1);
-		glVertexAttribPointer(8 + 2, 4, GL_FLOAT, GL_FALSE, 4 * 4 * sizeof(GLfloat),
-		                      (void *) (2 * 4 * sizeof(GLfloat)));
-		glEnableVertexAttribArray(8 + 2);
-		glVertexAttribPointer(8 + 3, 4, GL_FLOAT, GL_FALSE, 4 * 4 * sizeof(GLfloat),
-		                      (void *) (3 * 4 * sizeof(GLfloat)));
-		glEnableVertexAttribArray(8 + 3);
-		glVertexAttribDivisor(8, 1);
-		glVertexAttribDivisor(8 + 1, 1);
-		glVertexAttribDivisor(8 + 2, 1);
-		glVertexAttribDivisor(8 + 3, 1);
-
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-	}
-	glBindVertexArray(0);
-
-	glCheckError();
-
+void Core::PrepareToRendering() {
 	shader = new Shader("./shaders/block.vs", "./shaders/block.fs");
 	shader->Use();
 
-	shader2 = new Shader("./shaders/simple.vs", "./shaders/simple.fs");
-
 	LOG(INFO) << "Initializing texture atlas...";
 	//TextureAtlas texture
 	glActiveTexture(GL_TEXTURE0);
@@ -507,10 +302,10 @@ void Core::PrepareToWorldRendering() {
 	GLuint bp1 = 0;
 	GLuint ubo = glGetUniformBlockIndex(shader->Program, "TextureIndexes");
 	glUniformBlockBinding(shader->Program, ubo, bp1);
-	glGenBuffers(1, &UBO);
-	glBindBuffer(GL_UNIFORM_BUFFER, UBO);
-	glBindBufferBase(GL_UNIFORM_BUFFER, bp1, UBO);
-	glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::vec4) + sizeof(glm::vec4) * 1023, NULL, GL_STATIC_DRAW);
+	glGenBuffers(1, &UboTextureIndexes);
+	glBindBuffer(GL_UNIFORM_BUFFER, UboTextureIndexes);
+	glBindBufferBase(GL_UNIFORM_BUFFER, bp1, UboTextureIndexes);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::vec4) + sizeof(glm::vec4) * 1023, nullptr, GL_STATIC_DRAW);
 	glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(GLint), &totalTextures); //copy totalTextures
 	for (size_t i = 0; i < indexes.size(); i++) {
 		size_t baseOffset = sizeof(glm::vec4);
@@ -523,26 +318,13 @@ void Core::PrepareToWorldRendering() {
 	GLuint bp2 = 1;
 	GLuint ubo2_index = glGetUniformBlockIndex(shader->Program, "TextureData");
 	glUniformBlockBinding(shader->Program, ubo2_index, bp2);
-	glGenBuffers(1, &UBO2);
-	glBindBuffer(GL_UNIFORM_BUFFER, UBO2);
-	glBindBufferBase(GL_UNIFORM_BUFFER, bp2, UBO2);
-	glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::vec4) * 1024, NULL, GL_STATIC_DRAW);
+	glGenBuffers(1, &UboTextureData);
+	glBindBuffer(GL_UNIFORM_BUFFER, UboTextureData);
+	glBindBufferBase(GL_UNIFORM_BUFFER, bp2, UboTextureData);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::vec4) * 1024, nullptr, GL_STATIC_DRAW);
 	glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::vec4) * textureCoordinates.size(), textureCoordinates.data());
 	glBindBuffer(GL_UNIFORM_BUFFER, 0);
 	glCheckError();
-
-	//Draw Lines preparing
-	glGenBuffers(1, &VBO5);
-	glGenVertexArrays(1, &VAO2);
-	glBindVertexArray(VAO2);
-	{
-		glBindBuffer(GL_ARRAY_BUFFER, VBO5);
-		glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(GLfloat), NULL, GL_DYNAMIC_DRAW);
-		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0);
-		glEnableVertexAttribArray(0);
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-	}
-	glBindVertexArray(0);
 }
 
 void Core::UpdateChunksToRender() {
@@ -564,51 +346,16 @@ void Core::UpdateChunksToRender() {
 			continue;
 		toRender.push_back(it.first);
 	}
-	if (firstTime)
-		LOG(INFO) << "Chunks to render: " << toRender.size();
 	for (auto &it:toRender) {
-		Section &section = gameState->world.sections.find(it)->second;
-		std::vector<glm::mat4> models;
-		std::vector<glm::vec2> blocks;
-		for (int y = 0; y < 16; y++) {
-			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)
-						continue;
-					unsigned char isVisible = 0;
-					if (x == 0 || x == 15 || y == 0 || y == 15 || z == 0 || z == 15) {
-						isVisible = 0;
-					} else {
-						isVisible |= (section.GetBlock(Vector(x + 1, y, z)).id != 0) << 0;
-						isVisible |= (section.GetBlock(Vector(x - 1, y, z)).id != 0) << 1;
-						isVisible |= (section.GetBlock(Vector(x, y + 1, z)).id != 0) << 2;
-						isVisible |= (section.GetBlock(Vector(x, y - 1, z)).id != 0) << 3;
-						isVisible |= (section.GetBlock(Vector(x, y, z + 1)).id != 0) << 4;
-						isVisible |= (section.GetBlock(Vector(x, y, z - 1)).id != 0) << 5;
-					}
-					if (isVisible == 0x3F)
-						continue;
-					glm::vec2 data(block.id, block.state);
-					blocks.push_back(data);
-					glm::mat4 model;
-					model = glm::translate(model, glm::vec3(it.GetX() * 16, it.GetY() * 16, it.GetZ() * 16));
-					model = glm::translate(model, glm::vec3(x, y, z));
-					double size = 0.999;
-					model = glm::scale(model, glm::vec3(size, size, size));
-					models.push_back(model);
-				}
-			}
+		if (availableChunks.find(it) == availableChunks.end()) {
+			auto pair = std::make_pair(it, RenderSection(&gameState->world, it));
+			availableChunks.insert(pair);
+		} else {
+			availableChunks.find(it)->second.UpdateState();
 		}
-		toRenderBlocks[it] = blocks;
-		toRenderModels[it] = models;
 	}
-	std::sort(toRender.begin(), toRender.end(), [this](const Vector &lhs, const Vector &rhs) {
-		return glm::length((glm::vec3) lhs - gameState->Position()) <
-		       glm::length((glm::vec3) rhs - gameState->Position());
-	});
 	if (firstTime)
-		LOG(INFO) << "Chunks is prepared to rendering...";
+		LOG(INFO) << "Chunks to render: " << toRender.size() << " of " << availableChunks.size();
 	firstTime = false;
 }
 
diff --git a/src/graphics/Gui.cpp b/src/graphics/Gui.cpp
new file mode 100644
index 0000000..bbf7cf2
--- /dev/null
+++ b/src/graphics/Gui.cpp
@@ -0,0 +1 @@
+#include <graphics/Gui.hpp>
\ No newline at end of file
diff --git a/src/graphics/RenderSection.cpp b/src/graphics/RenderSection.cpp
new file mode 100644
index 0000000..fec67b5
--- /dev/null
+++ b/src/graphics/RenderSection.cpp
@@ -0,0 +1,281 @@
+#include <graphics/RenderSection.hpp>
+
+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,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		0.0f, 1.0f,
+		1.0f, 0.0f,
+		1.0f, 1.0f,
+
+		//Z-
+		1.0f, 0.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		0.0f, 0.0f,
+		1.0f, 1.0f,
+		0.0f, 1.0f,
+
+		//X+
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		0.0f, 1.0f,
+		0.0f, 1.0f,
+		1.0f, 0.0f,
+		1.0f, 1.0f,
+
+		//X-
+		0.0f, 0.0f,
+		1.0f, 1.0f,
+		0.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		1.0f, 1.0f,
+
+		//Y+
+		0.0f, 0.0f,
+		1.0f, 1.0f,
+		0.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		1.0f, 1.0f,
+
+		//Y-
+		1.0f, 0.0f,
+		0.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 1.0f,
+		0.0f, 1.0f,
+		1.0f, 0.0f,
+};
+
+void RenderState::SetActiveVao(GLuint Vao) {
+	if (Vao != ActiveVao) {
+		glBindVertexArray(Vao);
+		ActiveVao = Vao;
+	}
+}
+
+void RenderState::SetActiveShader(GLuint Shader) {
+	if (Shader != ActiveShader) {
+		glUseProgram(Shader);
+		ActiveShader = Shader;
+	}
+}
+
+const GLuint magicUniqueConstant = 88375;
+GLuint RenderSection::VboVertices = magicUniqueConstant;
+GLuint RenderSection::VboUvs = magicUniqueConstant;
+std::map<GLuint, int> RenderSection::refCounterVbo;
+std::map<GLuint, int> RenderSection::refCounterVao;
+
+
+RenderSection::RenderSection(World *world, Vector position) : sectionPosition(position), world(world) {
+
+	if (VboVertices == magicUniqueConstant) {
+		glGenBuffers(1, &VboVertices);
+		glGenBuffers(1, &VboUvs);
+
+		//Cube vertices
+		glBindBuffer(GL_ARRAY_BUFFER, VboVertices);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+		//Cube UVs
+		glBindBuffer(GL_ARRAY_BUFFER, VboUvs);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(uv_coords), uv_coords, GL_STATIC_DRAW);
+
+		LOG(INFO) << "Created VBOs with vertices (" << VboVertices << ") and UVs (" << VboUvs
+		          << ") for ordinary blocks";
+	}
+
+	glGenBuffers(1, &VboBlocks);
+	if (refCounterVbo.find(VboBlocks) == refCounterVbo.end())
+		refCounterVbo[VboBlocks] = 0;
+	refCounterVbo[VboBlocks]++;
+
+	glGenBuffers(1, &VboModels);
+	if (refCounterVbo.find(VboModels) == refCounterVbo.end())
+		refCounterVbo[VboModels] = 0;
+	refCounterVbo[VboModels]++;
+
+	glGenVertexArrays(1, &Vao);
+	if (refCounterVao.find(Vao) == refCounterVao.end())
+		refCounterVao[Vao] = 0;
+	refCounterVao[Vao]++;
+
+	glBindVertexArray(Vao);
+	{
+		//Cube vertices
+		glBindBuffer(GL_ARRAY_BUFFER, VboVertices);
+		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), nullptr);
+		glEnableVertexAttribArray(0);
+
+		//Cube UVs
+		glBindBuffer(GL_ARRAY_BUFFER, VboUvs);
+		glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), nullptr);
+		glEnableVertexAttribArray(2);
+
+		//Blocks ids
+		glBindBuffer(GL_ARRAY_BUFFER, VboBlocks);
+		glVertexAttribPointer(7, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), nullptr);
+		glEnableVertexAttribArray(7);
+		glVertexAttribDivisor(7, 1);
+		glCheckError();
+
+		//Blocks models
+		size_t sizeOfMat4 = 4 * 4 * sizeof(GLfloat);
+		glBindBuffer(GL_ARRAY_BUFFER, VboModels);
+		glVertexAttribPointer(8 + 0, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, nullptr);
+		glVertexAttribPointer(8 + 1, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *) (1 * 4 * sizeof(GLfloat)));
+		glVertexAttribPointer(8 + 2, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *) (2 * 4 * sizeof(GLfloat)));
+		glVertexAttribPointer(8 + 3, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *) (3 * 4 * sizeof(GLfloat)));
+		glEnableVertexAttribArray(8 + 0);
+		glEnableVertexAttribArray(8 + 1);
+		glEnableVertexAttribArray(8 + 2);
+		glEnableVertexAttribArray(8 + 3);
+		glVertexAttribDivisor(8 + 0, 1);
+		glVertexAttribDivisor(8 + 1, 1);
+		glVertexAttribDivisor(8 + 2, 1);
+		glVertexAttribDivisor(8 + 3, 1);
+
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+	}
+	glBindVertexArray(0);
+	UpdateState();
+	glCheckError();
+}
+
+RenderSection::~RenderSection() {
+	refCounterVbo[VboBlocks]--;
+	refCounterVbo[VboModels]--;
+	refCounterVao[Vao]--;
+	if (refCounterVbo[VboBlocks] <= 0)
+		glDeleteBuffers(1, &VboBlocks);
+	if (refCounterVbo[VboModels] <= 0)
+		glDeleteBuffers(1, &VboBlocks);
+	if (refCounterVao[Vao] <= 0)
+		glDeleteVertexArrays(1, &Vao);
+}
+
+void RenderSection::UpdateState() {
+	Section *section = &world->sections.find(sectionPosition)->second;
+	std::vector<glm::mat4> models;
+	std::vector<glm::vec2> blocks;
+	for (int y = 0; y < 16; y++) {
+		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)
+					continue;
+
+				unsigned char isVisible = 0;
+				if (x == 0 || x == 15 || y == 0 || y == 15 || z == 0 || z == 15) {
+					isVisible = 0;
+				} else {
+					isVisible |= (section->GetBlock(Vector(x + 1, y, z)).id != 0) << 0;
+					isVisible |= (section->GetBlock(Vector(x - 1, y, z)).id != 0) << 1;
+					isVisible |= (section->GetBlock(Vector(x, y + 1, z)).id != 0) << 2;
+					isVisible |= (section->GetBlock(Vector(x, y - 1, z)).id != 0) << 3;
+					isVisible |= (section->GetBlock(Vector(x, y, z + 1)).id != 0) << 4;
+					isVisible |= (section->GetBlock(Vector(x, y, z - 1)).id != 0) << 5;
+				}
+				if (isVisible == 0x3F)
+					continue;
+
+				glm::vec2 data(block.id, block.state);
+				blocks.push_back(data);
+				glm::mat4 model;
+				model = glm::translate(model, glm::vec3(section->GetPosition().GetX() * 16,
+				                                        section->GetPosition().GetY() * 16,
+				                                        section->GetPosition().GetZ() * 16));
+				model = glm::translate(model, glm::vec3(x, y, z));
+				double size = 0.999;
+				model = glm::scale(model, glm::vec3(size, size, size));
+				models.push_back(model);
+			}
+		}
+	}
+	glBindBuffer(GL_ARRAY_BUFFER, VboBlocks);
+	glBufferData(GL_ARRAY_BUFFER, blocks.size() * sizeof(glm::vec2), blocks.data(), GL_DYNAMIC_DRAW);
+
+	glBindBuffer(GL_ARRAY_BUFFER, VboModels);
+	glBufferData(GL_ARRAY_BUFFER, models.size() * sizeof(glm::mat4), models.data(), GL_DYNAMIC_DRAW);
+
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	numOfBlocks = blocks.size();
+}
+
+void RenderSection::Render(RenderState &state) {
+	state.SetActiveVao(Vao);
+	glDrawArraysInstanced(GL_TRIANGLES, 0, 36, numOfBlocks);
+	glCheckError();
+}
+
+Section *RenderSection::GetSection() {
+	return &world->sections.find(sectionPosition)->second;
+}
+
+RenderSection::RenderSection(const RenderSection &other) {
+	this->world = other.world;
+	this->VboModels = other.VboModels;
+	this->VboBlocks = other.VboBlocks;
+	this->sectionPosition = other.sectionPosition;
+	this->Vao = other.Vao;
+	this->numOfBlocks = other.numOfBlocks;
+
+	refCounterVbo[VboBlocks]++;
+	refCounterVbo[VboModels]++;
+	refCounterVao[Vao]++;
+}
diff --git a/src/graphics/Shader.cpp b/src/graphics/Shader.cpp
index cf43115..3d2efb8 100644
--- a/src/graphics/Shader.cpp
+++ b/src/graphics/Shader.cpp
@@ -1,4 +1,4 @@
-#include "Shader.hpp"
+#include <graphics/Shader.hpp>
 
 Shader::Shader(const GLchar *vertexPath, const GLchar *fragmentPath, const GLchar *geometryPath) {
 	vertex = vertexPath;
diff --git a/src/graphics/Texture.cpp b/src/graphics/Texture.cpp
index 5d183c3..e5e2bba 100644
--- a/src/graphics/Texture.cpp
+++ b/src/graphics/Texture.cpp
@@ -1,4 +1,4 @@
-#include "Texture.hpp"
+#include <graphics/Texture.hpp>
 
 Texture::Texture(std::string filename, GLenum textureWrapping, GLenum textureFiltering) {
     glGenTextures(1, &texture);
diff --git a/src/graphics/Widget.cpp b/src/graphics/Widget.cpp
new file mode 100644
index 0000000..e53bc87
--- /dev/null
+++ b/src/graphics/Widget.cpp
@@ -0,0 +1 @@
+#include <graphics/Widget.hpp>
\ No newline at end of file
diff --git a/src/gui/Gui.cpp b/src/gui/Gui.cpp
deleted file mode 100644
index bf600cb..0000000
--- a/src/gui/Gui.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "Gui.hpp"
diff --git a/src/gui/Widget.cpp b/src/gui/Widget.cpp
deleted file mode 100644
index a88a2bb..0000000
--- a/src/gui/Widget.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "Widget.hpp"
diff --git a/src/main.cpp b/src/main.cpp
index 8a7b974..aa30ff8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,4 +1,4 @@
-#include "core/Core.hpp"
+#include "../include/Core.hpp"
 
 const char *getTimeSinceProgramStart(void) {
     static auto initialTime = std::chrono::steady_clock().now();
diff --git a/src/nbt/Nbt.hpp b/src/nbt/Nbt.hpp
deleted file mode 100644
index 28e5345..0000000
--- a/src/nbt/Nbt.hpp
+++ /dev/null
@@ -1,515 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <vector>
-#include <zlib.h>
-#include <fstream>
-#include "../utility/utility.h"
-
-namespace nbt {
-    enum TagType {
-        End,        //nullptr
-        Byte,       //int8_t
-        Short,      //int16_t
-        Int,        //int32_t
-        Long,       //int64_t
-        Float,      //float
-        Double,     //double
-        ByteArray,  //std::vector<signed char>
-        String,     //std::string
-        List,       //std::vector<NbtTag>
-        Compound,   //std::vector<NbtTag>
-        IntArray,   //std::vector<int32_t>
-        Unknown,    //dummy value
-    };
-
-    class NbtTag;
-
-    typedef std::vector<NbtTag> compound_t;
-
-    typedef std::string string_t;
-
-    typedef std::vector<signed char> byteArray_t;
-
-    typedef std::vector<int> intArray_t;
-
-    class NbtTag {
-        TagType type = Unknown;
-        string_t name = "";
-        unsigned char *data = nullptr;
-    public:
-        NbtTag(TagType type, string_t name) : type(type), name(name) {
-            switch (type) {
-                case End:
-                    data = nullptr;
-                    break;
-                case Compound:
-                    data = (unsigned char *) new compound_t;
-                    break;
-                case String:
-                    data = (unsigned char *) new string_t;
-                    break;
-                case Int:
-                    data = (unsigned char *) new int32_t;
-                    break;
-                case Long:
-                    data = (unsigned char *) new int64_t;
-                    break;
-                case Byte:
-                    data = (unsigned char *) new int8_t;
-                    break;
-                case Short:
-                    data = (unsigned char *) new int16_t;
-                    break;
-                case Float:
-                    data = (unsigned char *) new float;
-                    break;
-                case Double:
-                    data = (unsigned char *) new double;
-                    break;
-                case ByteArray:
-                    data = (unsigned char *) new byteArray_t;
-                    break;
-                case List:
-                    data = (unsigned char *) new compound_t;
-                    break;
-                case IntArray:
-                    data = (unsigned char *) new intArray_t;
-            }
-        }
-
-        NbtTag(const NbtTag &other) : type(other.type), name(other.name) {
-            switch (type) {
-                case Byte:
-                    data = (unsigned char *) new int8_t;
-                    *((int8_t *) data) = *((int8_t *) other.data);
-                    break;
-                case Short:
-                    data = (unsigned char *) new int16_t;
-                    *((int16_t *) data) = *((int16_t *) other.data);
-                    break;
-                case Int:
-                    data = (unsigned char *) new int32_t;
-                    *((int32_t *) data) = *((int32_t *) other.data);
-                    break;
-                case Long:
-                    data = (unsigned char *) new int64_t;
-                    *((int64_t *) data) = *((int64_t *) other.data);
-                    break;
-                case Float:
-                    data = (unsigned char *) new float;
-                    *((float *) data) = *((float *) other.data);
-                    break;
-                case Double:
-                    data = (unsigned char *) new double;
-                    *((double *) data) = *((double *) other.data);
-                    break;
-                case ByteArray:
-                    data = (unsigned char *) new byteArray_t;
-                    *((std::vector<signed char> *) data) = *((std::vector<signed char> *) other.data);
-                    break;
-                case String:
-                    data = (unsigned char *) new string_t;
-                    *((std::string *) data) = *((std::string *) other.data);
-                    break;
-                case List:
-                    data = (unsigned char *) new compound_t;
-                    *((std::vector<NbtTag> *) data) = *((std::vector<NbtTag> *) other.data);
-                    break;
-                case Compound:
-                    data = (unsigned char *) new compound_t;
-                    *((std::vector<NbtTag> *) data) = *((std::vector<NbtTag> *) other.data);
-                    break;
-                case IntArray:
-                    data = (unsigned char *) new intArray_t;
-                    *((std::vector<int> *) data) = *((std::vector<int> *) other.data);
-                    break;
-            }
-        }
-
-        ~NbtTag() {
-            switch (type) {
-                case Byte:
-                    delete ((int8_t *) data);
-                    break;
-                case Short:
-                    delete ((int16_t *) data);
-                    break;
-                case Int:
-                    delete ((int32_t *) data);
-                    break;
-                case Long:
-                    delete ((int64_t *) data);
-                    break;
-                case Float:
-                    delete ((float *) data);
-                    break;
-                case Double:
-                    delete ((double *) data);
-                    break;
-                case ByteArray:
-                    delete ((std::vector<signed char> *) data);
-                    break;
-                case String:
-                    delete ((std::string *) data);
-                    break;
-                case List:
-                    delete ((std::vector<NbtTag> *) data);
-                    break;
-                case Compound:
-                    delete ((std::vector<NbtTag> *) data);
-                    break;
-                case IntArray:
-                    delete ((std::vector<int> *) data);
-                    break;
-            }
-        };
-
-        void swap(NbtTag &other) {
-            std::swap(other.data, data);
-            std::swap(other.name, name);
-            std::swap(other.type, type);
-        }
-
-        NbtTag &operator=(NbtTag other) {
-            other.swap(*this);
-            return *this;
-        }
-
-        TagType GetType() const{
-            return type;
-        }
-
-        string_t GetName() const{
-            return name;
-        }
-
-
-        string_t &GetString() {
-            string_t &val = *reinterpret_cast<std::string *>(data);
-            return val;
-        }
-
-        compound_t &GetCompound() {
-            std::vector<NbtTag> &val = *reinterpret_cast<std::vector<NbtTag> *>(data);
-            return val;
-        }
-
-        compound_t &GetList() {
-            std::vector<NbtTag> &val = *reinterpret_cast<std::vector<NbtTag> *>(data);
-            return val;
-        }
-
-        int64_t &GetLong() {
-            int64_t &val = *reinterpret_cast<int64_t *>(data);
-            return val;
-        }
-
-        float &GetFloat() {
-            float &val = *reinterpret_cast<float *>(data);
-            return val;
-        }
-
-        double &GetDouble() {
-            double &val = *reinterpret_cast<double *>(data);
-            return val;
-        }
-
-        byteArray_t &GetByteArray() {
-            auto &val = *reinterpret_cast<byteArray_t *>(data);
-            return val;
-        }
-
-        intArray_t &GetIntArray() {
-            auto &val = *reinterpret_cast<intArray_t *>(data);
-            return val;
-        }
-
-        int16_t &GetShort() {
-            auto &val = *reinterpret_cast<int16_t *>(data);
-            return val;
-        }
-
-        int32_t &GetInt() {
-            auto &val = *reinterpret_cast<int32_t *>(data);
-            return val;
-        }
-
-        int8_t &GetByte() {
-            auto &val = *reinterpret_cast<int8_t *>(data);
-            return val;
-        }
-    };
-
-    NbtTag ParseTag(unsigned char *data, size_t &size, TagType listItemType = Unknown) {
-        size = 0;
-        TagType type;
-        if (listItemType == Unknown) {
-            type = (TagType) *data;
-            data += 1;
-            size += 1;
-        } else
-            type = listItemType;
-        string_t name;
-        if (listItemType == Unknown && type != End) {
-            short nameLen = *((short *) data);
-            data += 2;
-            size += 2;
-            endswap(&nameLen);
-            name = std::string((char *) data, nameLen);
-            data += nameLen;
-            size += nameLen;
-        }
-        NbtTag tag(type, name);
-        switch (type) {
-            case Compound: {
-                do {
-                    size_t s;
-                    tag.GetCompound().push_back(ParseTag(data, s));
-                    data += s;
-                    size += s;
-                } while (tag.GetCompound().back().GetType() != End);
-                tag.GetCompound().pop_back();
-                return tag;
-            }
-            case String: {
-                short len = *((short *) data);
-                data += 2;
-                size += 2;
-                endswap(&len);
-                string_t str((char *) data, len);
-                data += len;
-                size += len;
-                tag.GetString() = str;
-                return tag;
-            }
-            case End:
-                return tag;
-            case Long:
-                tag.GetLong() = *((int64_t *) data);
-                endswap(&tag.GetLong());
-                data += 8;
-                size += 8;
-                return tag;
-            case Short:
-                tag.GetShort() = *((int16_t *) data);
-                endswap(&tag.GetShort());
-                data += 2;
-                size += 2;
-                return tag;
-            case Float:
-                tag.GetFloat() = *((float *) data);
-                endswap(&tag.GetFloat());
-                data += 4;
-                size += 4;
-                return tag;
-            case Double:
-                tag.GetDouble() = *((double *) data);
-                endswap(&tag.GetDouble());
-                data += 8;
-                size += 8;
-                return tag;
-            case Byte:
-                tag.GetByte() = *((int8_t *) data);
-                endswap(&tag.GetByte());
-                data += 1;
-                size += 1;
-                return tag;
-            case Int:
-                tag.GetInt() = *((int32_t *) data);
-                endswap(&tag.GetInt());
-                data += 4;
-                size += 4;
-                return tag;
-            case List: {
-                TagType listType = *((TagType *) data);
-                data += 1;
-                size += 1;
-                int32_t listLength = *((int32_t *) data);
-                endswap(&listLength);
-                data += 4;
-                size += 4;
-                for (int i = 0; i < listLength; i++) {
-                    size_t s = 0;
-                    std::vector<NbtTag> &vec = tag.GetCompound();
-                    vec.push_back(ParseTag(data, s, listType));
-                    data += s;
-                    size += s;
-                }
-                return tag;
-            }
-            case ByteArray: {
-                int32_t arrLength = *((int32_t *) data);
-                endswap(&arrLength);
-                data += 4;
-                size += 4;
-                for (int i = 0; i < arrLength; i++) {
-                    signed char val = (signed char) data[i];
-                    std::vector<signed char> &vec = tag.GetByteArray();
-                    vec.push_back(val);
-                }
-                data += arrLength;
-                size += arrLength;
-                return tag;
-            }
-            default:
-                throw 13;
-        }
-    }
-
-    NbtTag ParseTag(unsigned char *data, size_t *optionalSize = nullptr) {
-        size_t s = 0;
-        size_t &size = (optionalSize ? *optionalSize : s);
-        return ParseTag(data, size);
-    }
-
-    std::vector<unsigned char> Decompress(unsigned char *data, size_t dataLen) {
-        const size_t decompBuffSize = 1024 * 16;
-        unsigned char *decompBuff = new unsigned char[decompBuffSize];
-        std::vector<unsigned char> uncompressed;
-        for (int i = 0; i < decompBuffSize; i++)
-            decompBuff[i] = 0;
-
-
-        z_stream stream;
-        stream.zalloc = Z_NULL;
-        stream.zfree = Z_NULL;
-        stream.opaque = Z_NULL;
-        stream.next_in = data;
-        stream.avail_in = dataLen;
-        stream.next_out = decompBuff;
-        stream.avail_out = decompBuffSize;
-
-        if (inflateInit2(&stream, 15 + 32) != Z_OK) {
-            delete[] decompBuff;
-            throw 171;
-        }
-
-        int res;
-        do {
-            stream.avail_out = decompBuffSize;
-
-            switch ((res = inflate(&stream, Z_NO_FLUSH))) {
-                case Z_MEM_ERROR:
-                    throw 172;
-                case Z_DATA_ERROR:
-                    throw 173;
-                case Z_NEED_DICT:
-                    throw 174;
-            }
-
-            uncompressed.resize(uncompressed.size() + decompBuffSize);
-            std::copy(decompBuff, decompBuff + decompBuffSize, uncompressed.end() - decompBuffSize);
-        } while (stream.avail_out == 0);
-        if (res != Z_STREAM_END)
-            throw 175;
-        if (inflateEnd(&stream) != Z_OK)
-            throw 176;
-        delete[] decompBuff;
-        return uncompressed;
-    }
-
-    NbtTag ParseCompressed(unsigned char *data, size_t dataLen) {
-        auto uncompressed = Decompress(data, dataLen);
-        NbtTag root = ParseTag(uncompressed.data());
-        return root;
-    }
-
-    NbtTag Parse(unsigned char *data, size_t dataLen) {
-        bool isCompressed = *data!=10;
-        if (isCompressed)
-            return ParseCompressed(data,dataLen);
-        else
-            return ParseTag(data);
-    }
-
-    void PrintTree(NbtTag &tree, int deepness = 0, std::ostream &ostream = std::cout) {
-        ostream << std::string(deepness, '\t') << "Tag ";
-        switch (tree.GetType()) {
-            case Byte:
-                ostream << "byte";
-                break;
-            case Short:
-                ostream << "short";
-                break;
-            case Int:
-                ostream << "int";
-                break;
-            case Long:
-                ostream << "long";
-                break;
-            case Float:
-                ostream << "float";
-                break;
-            case Double:
-                ostream << "double";
-                break;
-            case ByteArray:
-                ostream << "byte array";
-                break;
-            case String:
-                ostream << "string";
-                break;
-            case List:
-                ostream << "list";
-                break;
-            case Compound:
-                ostream << "compound";
-                break;
-            case IntArray:
-                ostream << "int array";
-                break;
-            case End:
-                ostream << "end";
-                break;
-        }
-        if (tree.GetName().length() > 0)
-            ostream << " (" << tree.GetName() << ")";
-        ostream << ": ";
-
-        if (tree.GetType() == Compound || tree.GetType() == List) {
-            std::vector<NbtTag> &vec = (tree.GetType() == Compound ? tree.GetCompound() : tree.GetList());
-            ostream << vec.size() << " entries {" << std::endl;
-            for (auto it = vec.begin(); it != vec.end(); ++it) {
-                PrintTree(*it, deepness + 1, std::cout);
-            }
-            ostream << std::string(deepness, '\t') << "}" << std::endl;
-            return;
-        } else {
-            switch (tree.GetType()) {
-                case Int:
-                    ostream << tree.GetInt();
-                    break;
-                case String:
-                    ostream << "\"" << tree.GetString() << "\"";
-                    break;
-                case Double:
-                    ostream << tree.GetDouble();
-                    break;
-                case Float:
-                    ostream << tree.GetFloat();
-                    break;
-                case Short:
-                    ostream << tree.GetShort();
-                    break;
-                case Byte:
-                    ostream << (int) tree.GetByte();
-                    break;
-                case Long:
-                    ostream << tree.GetLong();
-                    break;
-                case ByteArray:
-                    ostream << "[" << tree.GetByteArray().size() << " bytes]: ";
-                    for (int i = 0; i < (tree.GetByteArray().size() > 10 ? 10 : tree.GetByteArray().size()); i++) {
-                        ostream << std::hex << "0x" << (tree.GetByteArray()[i] > 15 ? "" : "0")
-                                << (int) tree.GetByteArray()[i]
-                                << std::dec << " ";
-                    }
-                    break;
-                case IntArray:
-                    break;
-            }
-            ostream << std::endl;
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/network/Network.cpp b/src/network/Network.cpp
index 68df158..91cb481 100644
--- a/src/network/Network.cpp
+++ b/src/network/Network.cpp
@@ -1,5 +1,4 @@
-#include "Network.hpp"
-#include <iostream>
+#include <network/Network.hpp>
 
 Network::Network(std::string address, unsigned short port) {
 	socket = new Socket(address, port);
diff --git a/src/network/NetworkClient.cpp b/src/network/NetworkClient.cpp
index b8d880d..73880cf 100644
--- a/src/network/NetworkClient.cpp
+++ b/src/network/NetworkClient.cpp
@@ -1,5 +1,4 @@
-#include "NetworkClient.hpp"
-#include "Packet.hpp"
+#include <network/NetworkClient.hpp>
 
 NetworkClient::NetworkClient(std::string address, unsigned short port, std::string username, bool &quit)
 		: network(address, port), isRunning(quit) {
diff --git a/src/network/Socket.cpp b/src/network/Socket.cpp
index 2bbf49a..f4e6787 100644
--- a/src/network/Socket.cpp
+++ b/src/network/Socket.cpp
@@ -1,4 +1,4 @@
-#include "Socket.hpp"
+#include <network/Socket.hpp>
 
 Socket::Socket(std::string address, unsigned short port) {
 	sf::Socket::Status connectionStatus = socket.connect(sf::IpAddress(address), port);
diff --git a/src/network/Stream.cpp b/src/network/Stream.cpp
index d492428..447b13f 100644
--- a/src/network/Stream.cpp
+++ b/src/network/Stream.cpp
@@ -1,4 +1,4 @@
-#include "Stream.hpp"
+#include <network/Stream.hpp>
 
 const int MAX_VARINT_LENGTH = 5;
 
diff --git a/src/utility/utility.cpp b/src/utility/utility.cpp
deleted file mode 100644
index aa50e9f..0000000
--- a/src/utility/utility.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "utility.h"
-
-int VarIntRead(unsigned char *data, size_t &readed) {
-    readed = 0;
-    int result = 0;
-    char read;
-    do {
-        read = data[readed];
-        int value = (read & 0b01111111);
-        result |= (value << (7 * readed));
-
-        readed++;
-        if (readed > 5) {
-            throw "VarInt is too big";
-        }
-    } while ((read & 0b10000000) != 0);
-
-    return result;
-}
-
-size_t VarIntWrite(unsigned int value, unsigned char *data) {
-    size_t len = 0;
-    do {
-        unsigned char temp = (unsigned char) (value & 0b01111111);
-        value >>= 7;
-        if (value != 0) {
-            temp |= 0b10000000;
-        }
-        data[len] = temp;
-        len++;
-    } while (value != 0);
-    return len;
-}
-
-long long int ReadVarLong(unsigned char *data, int &readed) {
-    readed = 0;
-    long long result = 0;
-    unsigned char read;
-    do {
-        read = data[readed];
-        long long value = (read & 0b01111111);
-        result |= (value << (7 * readed));
-
-        readed++;
-        if (readed > 10) {
-            throw "VarLong is too big";
-        }
-    } while ((read & 0b10000000) != 0);
-    return result;
-}
-
-unsigned char *WriteVarLong(unsigned long long int value, int &len) {
-    unsigned char *data = new unsigned char[10];
-    len = 0;
-    do {
-        unsigned char temp = (unsigned char) (value & 0b01111111);
-        value >>= 7;
-        if (value != 0) {
-            temp |= 0b10000000;
-        }
-        data[len] = temp;
-        len++;
-    } while (value != 0);
-
-    return data;
-}
\ No newline at end of file
diff --git a/src/utility/utility.h b/src/utility/utility.h
deleted file mode 100644
index 32120cb..0000000
--- a/src/utility/utility.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-#include <algorithm>
-
-int VarIntRead(unsigned char *data, size_t &readed);
-
-size_t VarIntWrite(unsigned int value, unsigned char *data);
-
-long long int ReadVarLong(unsigned char *data, int &readed);
-
-unsigned char *WriteVarLong(unsigned long long int value, int &len);
-
-template<class T>
-void endswap(T *objp) {
-    unsigned char *memp = reinterpret_cast<unsigned char *>(objp);
-    std::reverse(memp, memp + sizeof(T));
-}
\ No newline at end of file
diff --git a/src/world/Block.cpp b/src/world/Block.cpp
index e88068a..74ac406 100644
--- a/src/world/Block.cpp
+++ b/src/world/Block.cpp
@@ -1,4 +1,4 @@
-#include "Block.hpp"
+#include <world/Block.hpp>
 
 Block::~Block() {}
 
diff --git a/src/world/Collision.cpp b/src/world/Collision.cpp
index 4f2c837..8fc562b 100644
--- a/src/world/Collision.cpp
+++ b/src/world/Collision.cpp
@@ -1,4 +1,4 @@
-#include "Collision.hpp"
+#include <world/Collision.hpp>
 
 bool TestCollision(AABB first, AABB second) {
 	double firstXl = first.x;
diff --git a/src/gamestate/GameState.cpp b/src/world/GameState.cpp
index 316d5f1..b484b06 100644
--- a/src/gamestate/GameState.cpp
+++ b/src/world/GameState.cpp
@@ -1,4 +1,4 @@
-#include "GameState.hpp"
+#include <GameState.hpp>
 
 GameState::GameState(NetworkClient *Net, bool &quit) : nc(Net), isRunning(quit) {
 	Front = glm::vec3(0.0f, 0.0f, -1.0f);
diff --git a/src/world/Section.cpp b/src/world/Section.cpp
index 8f94ad7..a338e49 100644
--- a/src/world/Section.cpp
+++ b/src/world/Section.cpp
@@ -1,8 +1,11 @@
-#include "Section.hpp"
+#include <world/Section.hpp>
 
 
-Section::Section(byte *dataBlocks, size_t dataBlocksLength, byte *dataLight, byte *dataSky, byte bitsPerBlock,
+Section::Section(Vector position, byte *dataBlocks, size_t dataBlocksLength, byte *dataLight, byte *dataSky,
+                 byte bitsPerBlock,
                  std::vector<unsigned short> palette) {
+	worldPosition = position;
+
 	m_dataBlocksLen = dataBlocksLength;
 	m_dataBlocks = new byte[m_dataBlocksLen];
 	std::copy(dataBlocks, dataBlocks + m_dataBlocksLen, m_dataBlocks);
@@ -97,7 +100,7 @@ void Section::Parse() {
 }
 
 Section &Section::operator=(Section other) {
-	std::swap(*this,other);
+	std::swap(*this, other);
 	return *this;
 }
 
@@ -113,6 +116,7 @@ void swap(Section &a, Section &b) {
 }
 
 Section::Section(const Section &other) {
+	worldPosition = other.worldPosition;
 	m_dataBlocksLen = other.m_dataBlocksLen;
 	m_dataBlocks = new byte[m_dataBlocksLen];
 	std::copy(other.m_dataBlocks, other.m_dataBlocks + m_dataBlocksLen, m_dataBlocks);
@@ -127,4 +131,8 @@ Section::Section(const Section &other) {
 
 	m_palette = other.m_palette;
 	m_bitsPerBlock = other.m_bitsPerBlock;
-}
\ No newline at end of file
+}
+
+Vector Section::GetPosition() {
+	return worldPosition;
+}
diff --git a/src/world/World.cpp b/src/world/World.cpp
index 394598b..abcfebf 100644
--- a/src/world/World.cpp
+++ b/src/world/World.cpp
@@ -1,4 +1,4 @@
-#include "World.hpp"
+#include <world/World.hpp>
 
 void World::ParseChunkData(std::shared_ptr<PacketChunkData> packet) {
 	StreamBuffer chunkData(packet->Data.data(), packet->Data.size());
@@ -6,7 +6,7 @@ void World::ParseChunkData(std::shared_ptr<PacketChunkData> packet) {
 	for (int i = 0; i < 16; i++) {
 		if (bitmask[i]) {
 			Vector chunkPosition = Vector(packet->ChunkX, i, packet->ChunkZ);
-			Section section = ParseSection(&chunkData);
+			Section section = ParseSection(&chunkData, chunkPosition);
 			auto it = sections.find(chunkPosition);
 			if (it == sections.end()) {
 				sections.insert(std::make_pair(chunkPosition, section));
@@ -19,7 +19,7 @@ void World::ParseChunkData(std::shared_ptr<PacketChunkData> packet) {
 	}
 }
 
-Section World::ParseSection(StreamInput *data) {
+Section World::ParseSection(StreamInput *data, Vector position) {
 	unsigned char bitsPerBlock = data->ReadUByte();
 	int paletteLength = data->ReadVarInt();
 	std::vector<unsigned short> palette;
@@ -32,7 +32,7 @@ Section World::ParseSection(StreamInput *data) {
 	std::vector<unsigned char> skyLight;
 	if (dimension == 0)
 		skyLight = data->ReadByteArray(4096 / 2);
-	return Section(dataArray.data(), dataArray.size(), blockLight.data(),
+	return Section(position, dataArray.data(), dataArray.size(), blockLight.data(),
 	               (skyLight.size() > 0 ? skyLight.data() : nullptr), bitsPerBlock, palette);
 }