nice

src/main.cpp

@@ -1,18 +1,210 @@
 #include <iostream>
-// #include <td/protocol/packet/PacketVisitor.h>
-#include <td/game/GameHistory.h>
-#include <td/protocol/command/Commands.h>
 
-class Test : public td::protocol::CommandHandler {};
+#include <sp/common/DataBuffer.h>
+#include <sp/extensions/Compress.h>
+#include <td/input/Display.h>
+
+#include <td/game/World.h>
+#include <td/protocol/packet/Packets.h>
+#include <td/render/renderer/WorldRenderer.h>
+
+namespace td {
+namespace game {
+
+sp::DataBuffer& operator>>(sp::DataBuffer& buffer, game::TilePtr& tile) {
+	game::TileType tileType;
+	buffer >> tileType;
+	switch (tileType) {
+		case game::TileType::Tower: {
+			auto tilePtr = std::make_shared<game::TowerTile>();
+			buffer >> tilePtr->color_palette_ref >> tilePtr->team_owner;
+			tile = tilePtr;
+			break;
+		}
+		case game::TileType::Walk: {
+			auto tilePtr = std::make_shared<game::WalkableTile>();
+			buffer >> tilePtr->direction;
+			tile = tilePtr;
+			break;
+		}
+		case game::TileType::Decoration: {
+			auto tilePtr = std::make_shared<game::DecorationTile>();
+			buffer >> tilePtr->color_palette_ref;
+			tile = tilePtr;
+			break;
+		}
+		default:
+			break;
+	}
+	return buffer;
+}
+}  // namespace game
+}  // namespace td
+
+namespace sp {
+namespace details {
+
+template <>
+void ReadMessage(DataBuffer& a_Buffer, td::protocol::pdata::WorldHeader& a_Header) {
+	a_Buffer >> a_Header.m_TowerPlacePalette >> a_Header.m_WalkablePalette;
+
+	std::uint16_t decoPaletteSize;
+	a_Buffer >> decoPaletteSize;
+
+	std::size_t decoPalletteSizeByte = decoPaletteSize * sizeof(td::Color);
+
+	a_Header.m_DecorationPalette.resize(decoPaletteSize);
+
+	memcpy(reinterpret_cast<std::uint8_t*>(a_Header.m_DecorationPalette.data()), a_Buffer.data() + a_Buffer.GetReadOffset(),
+		decoPalletteSizeByte);
+
+	a_Buffer.SetReadOffset(a_Buffer.GetReadOffset() + decoPalletteSizeByte);
+
+	a_Buffer >> a_Header.m_Background;
+
+	td::utils::shape::Rectangle redCastle, blueCastle;
+
+	a_Buffer >> a_Header.m_RedSpawn >> redCastle;
+	a_Buffer >> a_Header.m_BlueSpawn >> blueCastle;
+
+	a_Header.m_RedCastle.SetShape(redCastle);
+	a_Header.m_BlueCastle.SetShape(blueCastle);
+
+	std::uint64_t tilePaletteSize;
+	a_Buffer >> tilePaletteSize;
+
+	a_Header.m_TilePalette.reserve(tilePaletteSize);
+
+	for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++) {
+		td::game::TilePtr tile;
+		a_Buffer >> tile;
+		a_Header.m_TilePalette.push_back(tile);
+	}
+
+	a_Buffer >> a_Header.m_SpawnColorPalette;
+}
+
+typedef std::vector<uint64_t> ChunkPackedData;
+
+const int BITS_IN_BYTE = 8;
+const int BITS_IN_LONG = BITS_IN_BYTE * sizeof(std::uint64_t);
+
+static unsigned int countBits(unsigned int number) {
+	// log function in base 2
+	// take only integer part
+	return static_cast<unsigned int>(std::log2(number) + 1);
+}
+
+
+template <>
+void ReadMessage(DataBuffer& a_Buffer, td::protocol::pdata::WorldData& a_WorldData) {
+	std::uint64_t chunkCount;
+	a_Buffer >> chunkCount;
+
+	for (std::uint64_t chunkNumber = 0; chunkNumber < chunkCount; chunkNumber++) {
+		td::game::ChunkPtr chunk = std::make_shared<td::game::Chunk>();
+
+		td::game::ChunkCoord chunkCoords;
+		a_Buffer >> chunkCoords.x >> chunkCoords.y;
+
+		std::uint64_t chunkPaletteSize;
+		// std::reverse(reinterpret_cast<std::uint8_t*>(&chunkPaletteSize), reinterpret_cast<std::uint8_t*>(&chunkPaletteSize) + 4);
+		a_Buffer >> chunkPaletteSize;
+
+		td::game::ChunkPalette chunkPalette(chunkPaletteSize);
+
+		memcpy(reinterpret_cast<void*>(chunkPalette.data()), a_Buffer.data() + a_Buffer.GetReadOffset(),
+			chunkPaletteSize * sizeof(td::game::ChunkPalette::value_type));
+		a_Buffer.SetReadOffset(a_Buffer.GetReadOffset() + chunkPaletteSize * sizeof(td::game::ChunkPalette::value_type));
+
+		chunk->palette = chunkPalette;
+
+		std::uint8_t bitsPerTile = countBits(chunkPaletteSize);
+
+		// A bitmask that contains bitsPerTile set bits
+		td::game::Chunk::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1);
+
+		ChunkPackedData chunkData(td::game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
+
+		memcpy(reinterpret_cast<void*>(chunkData.data()), a_Buffer.data() + a_Buffer.GetReadOffset(),
+			chunkData.size() * sizeof(ChunkPackedData::value_type));
+		a_Buffer.SetReadOffset(a_Buffer.GetReadOffset() + chunkData.size() * sizeof(ChunkPackedData::value_type));
+
+		for (unsigned int tileNumber = 0; tileNumber < td::game::Chunk::ChunkSize; tileNumber++) {
+			std::size_t startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG;
+			std::size_t startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG;
+			std::size_t endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG;
+
+			td::game::Chunk::ChunkData::value_type value;
+			if (startLong == endLong) {
+				value = (chunkData[startLong] >> startOffset);
+			} else {
+				int endOffset = BITS_IN_LONG - startOffset;
+				value = (chunkData[startLong] >> startOffset | chunkData[endLong] << endOffset);
+			}
+			value &= individualValueMask;
+
+			chunk->tiles[tileNumber] = value;
+		}
+		a_WorldData.m_Chunks.insert({chunkCoords, chunk});
+	}
+}
+
+}  // namespace details
+}  // namespace sp
+
+class WorldApply : public td::protocol::PacketHandler {
+  private:
+	td::game::World& m_World;
+  public:
+	WorldApply(td::game::World& a_World) : m_World(a_World) {}
+
+	void Handle(const td::protocol::pdata::WorldHeader& a_Header) override {
+		m_World.LoadMap(a_Header);
+	}
+	void Handle(const td::protocol::pdata::WorldData& a_Data) override {
+		m_World.LoadMap(a_Data);
+	}
+};
 
 int main(int argc, char** argv) {
-	// Test visitor;
-	// td::protocol::packets::ChatMessage chat{{"coucou"}};
-	// visitor.Check(chat);
+	sp::DataBuffer buffer;
+	buffer.ReadFile("test/tdmap.tdmap2");
 
+	sp::DataBuffer buffer1 = sp::zlib::Decompress(buffer, 84);
+	buffer.SetReadOffset(buffer.GetReadOffset() + 83);
+	sp::DataBuffer buffer2 = sp::zlib::Decompress(buffer, 511);
+
+	td::protocol::packets::WorldHeaderPacket header;
+	header.Read(buffer1);
+
+	td::protocol::packets::WorldDataPacket data;
+	data.Read(buffer2);
+
+	td::game::World w;
+	WorldApply wa(w);
+
+	td::protocol::PacketDispatcher d;
+	d.RegisterHandler(td::protocol::PacketID::WorldData, &wa);
+	d.RegisterHandler(td::protocol::PacketID::WorldHeader, &wa);
+
+	d.Dispatch(header);
+	d.Dispatch(data);
+
+	td::Display display(1920, 1080, "Tower-Defense 2");
+
+	td::render::Camera cam;
+	cam.SetCamPos({77, 25, 13});
+	cam.UpdatePerspective(display.GetAspectRatio());
+
+	td::render::RenderPipeline renderer;
+	renderer.AddRenderer(std::make_unique<td::render::WorldRenderer>(cam, w));
+
+	while (!display.IsCloseRequested()) {
+		display.PollEvents();
+		renderer.Render();
+		display.Update();
+	}
 
-	td::protocol::commands::UpgradeTowerCommand com{1, 2};
-	std::cout << (unsigned)com.GetId() << std::endl;
-	td::protocol::CommandDispatcher disptacher;
 	return 0;
 }

src/td/Maths.cpp

@@ -0,0 +1,169 @@
+#include <td/Maths.h>
+
+#include <cassert>
+#include <cmath>
+
+namespace td {
+namespace maths {
+
+template <typename T>
+T Length(const Vec3<T>& vect) {
+	return std::sqrt(vect.x * vect.x + vect.y * vect.y + vect.z * vect.z);
+}
+
+template <typename T>
+Vec3<T> Normalize(const Vec3<T>& vect) {
+	T length = Length(vect);
+
+	return {vect.x / length, vect.y / length, vect.z / length};
+}
+
+template <typename T>
+Vec4<T> Normalize(const Vec4<T>& vect) {
+	T length = std::sqrt(vect.x * vect.x + vect.y * vect.y + vect.z * vect.z + vect.w * vect.w);
+
+	return {vect.x / length, vect.y / length, vect.z / length, vect.w / length};
+}
+
+template <typename T>
+T Dot(const Vec3<T>& vect, const Vec3<T>& other) {
+	return vect.x * other.x + vect.y * other.y + vect.z * other.z;
+}
+
+template <typename T>
+Vec3<T> Cross(const Vec3<T>& vect, const Vec3<T>& other) {
+	return {
+		vect.y * other.z - vect.z * other.y,
+		vect.z * other.x - vect.x * other.z,
+		vect.x * other.y - vect.y * other.x,
+	};
+}
+
+template <typename T>
+T Dot(const Vec4<T>& vect, const Vec4<T>& other) {
+	return vect.x * other.x + vect.y * other.y + vect.z * other.z + vect.w * other.w;
+}
+
+template <typename T>
+T Distance(const Vec3<T>& vect, const Vec3<T>& other) {
+	return Length(vect - other);
+}
+
+template <typename T>
+Vec4<T> Dot(const Mat4<T>& mat, const Vec4<T>& vect) {
+	return {mat.x0 * vect.x + mat.x1 * vect.y + mat.x2 * vect.z + mat.x3 * vect.w,
+		mat.y0 * vect.x + mat.y1 * vect.y + mat.y2 * vect.z + mat.y3 * vect.w,
+		mat.z0 * vect.x + mat.z1 * vect.y + mat.z2 * vect.z + mat.z3 * vect.w,
+		mat.w0 * vect.x + mat.w1 * vect.y + mat.w2 * vect.z + mat.w3 * vect.w};
+}
+
+template <typename T>
+Mat4<T> Dot(const Mat4<T>& mat, const Mat4<T>& other) {
+	Mat4<T> result{};
+
+	for (std::size_t i = 0; i < Mat4<T>::MATRIX_SIZE; i++) {
+		for (std::size_t j = 0; j < Mat4<T>::MATRIX_SIZE; j++) {
+			for (std::size_t k = 0; k < Mat4<T>::MATRIX_SIZE; k++) {
+				result.at(i, j) += mat.at(i, k) * other.at(k, j);
+			}
+		}
+	}
+
+	return result;
+}
+
+template <typename T>
+Mat4<T> Identity() {
+	Mat4<T> result{};
+
+	result.x0 = static_cast<T>(1);
+	result.y1 = static_cast<T>(1);
+	result.z2 = static_cast<T>(1);
+	result.w3 = static_cast<T>(1);
+
+	return result;
+}
+
+Mat4f Perspective(float fovY, float aspectRatio, float zNear, float zFar) {
+	const float tanHalfFovy = std::tan(fovY / 2.0f);
+
+	Mat4f result{};
+	result.x0 = 1.0f / (aspectRatio * tanHalfFovy);
+	result.y1 = 1.0f / (tanHalfFovy);
+	result.z2 = -(zFar + zNear) / (zFar - zNear);
+	result.z3 = -1.0f;
+	result.w2 = -(2.0f * zFar * zNear) / (zFar - zNear);
+
+	return result;
+}
+
+Mat4f Look(const Vec3f& eye, const Vec3f& center, const Vec3f& up) {
+	const Vec3f f = Normalize(center);
+	const Vec3f s = Normalize(Cross(f, up));
+	const Vec3f u = Cross(s, f);
+
+	Mat4f result = Identity<float>();
+	result.x0 = s.x;
+	result.y0 = s.y;
+	result.z0 = s.z;
+	result.x1 = u.x;
+	result.y1 = u.y;
+	result.z1 = u.z;
+	result.x2 = -f.x;
+	result.y2 = -f.y;
+	result.z2 = -f.z;
+	result.w0 = -Dot(s, eye);
+	result.w1 = -Dot(u, eye);
+	result.w2 = Dot(f, eye);
+
+	return result;
+}
+
+Mat4f Inverse(const Mat4f& mat) {
+	float s0 = mat.at(0, 0) * mat.at(1, 1) - mat.at(1, 0) * mat.at(0, 1);
+	float s1 = mat.at(0, 0) * mat.at(1, 2) - mat.at(1, 0) * mat.at(0, 2);
+	float s2 = mat.at(0, 0) * mat.at(1, 3) - mat.at(1, 0) * mat.at(0, 3);
+	float s3 = mat.at(0, 1) * mat.at(1, 2) - mat.at(1, 1) * mat.at(0, 2);
+	float s4 = mat.at(0, 1) * mat.at(1, 3) - mat.at(1, 1) * mat.at(0, 3);
+	float s5 = mat.at(0, 2) * mat.at(1, 3) - mat.at(1, 2) * mat.at(0, 3);
+
+	float c5 = mat.at(2, 2) * mat.at(3, 3) - mat.at(3, 2) * mat.at(2, 3);
+	float c4 = mat.at(2, 1) * mat.at(3, 3) - mat.at(3, 1) * mat.at(2, 3);
+	float c3 = mat.at(2, 1) * mat.at(3, 2) - mat.at(3, 1) * mat.at(2, 2);
+	float c2 = mat.at(2, 0) * mat.at(3, 3) - mat.at(3, 0) * mat.at(2, 3);
+	float c1 = mat.at(2, 0) * mat.at(3, 2) - mat.at(3, 0) * mat.at(2, 2);
+	float c0 = mat.at(2, 0) * mat.at(3, 1) - mat.at(3, 0) * mat.at(2, 1);
+
+	float det = s0 * c5 - s1 * c4 + s2 * c3 + s3 * c2 - s4 * c1 + s5 * c0;
+
+	assert(det != 0 && "Determinant equals 0 !");
+
+	float invdet = 1.0 / det;
+
+	Mat4f result;
+
+	result.at(0, 0) = (mat.at(1, 1) * c5 - mat.at(1, 2) * c4 + mat.at(1, 3) * c3) * invdet;
+	result.at(0, 1) = (-mat.at(0, 1) * c5 + mat.at(0, 2) * c4 - mat.at(0, 3) * c3) * invdet;
+	result.at(0, 2) = (mat.at(3, 1) * s5 - mat.at(3, 2) * s4 + mat.at(3, 3) * s3) * invdet;
+	result.at(0, 3) = (-mat.at(2, 1) * s5 + mat.at(2, 2) * s4 - mat.at(2, 3) * s3) * invdet;
+
+	result.at(1, 0) = (-mat.at(1, 0) * c5 + mat.at(1, 2) * c2 - mat.at(1, 3) * c1) * invdet;
+	result.at(1, 1) = (mat.at(0, 0) * c5 - mat.at(0, 2) * c2 + mat.at(0, 3) * c1) * invdet;
+	result.at(1, 2) = (-mat.at(3, 0) * s5 + mat.at(3, 2) * s2 - mat.at(3, 3) * s1) * invdet;
+	result.at(1, 3) = (mat.at(2, 0) * s5 - mat.at(2, 2) * s2 + mat.at(2, 3) * s1) * invdet;
+
+	result.at(2, 0) = (mat.at(1, 0) * c4 - mat.at(1, 1) * c2 + mat.at(1, 3) * c0) * invdet;
+	result.at(2, 1) = (-mat.at(0, 0) * c4 + mat.at(0, 1) * c2 - mat.at(0, 3) * c0) * invdet;
+	result.at(2, 2) = (mat.at(3, 0) * s4 - mat.at(3, 1) * s2 + mat.at(3, 3) * s0) * invdet;
+	result.at(2, 3) = (-mat.at(2, 0) * s4 + mat.at(2, 1) * s2 - mat.at(2, 3) * s0) * invdet;
+
+	result.at(3, 0) = (-mat.at(1, 0) * c3 + mat.at(1, 1) * c1 - mat.at(1, 2) * c0) * invdet;
+	result.at(3, 1) = (mat.at(0, 0) * c3 - mat.at(0, 1) * c1 + mat.at(0, 2) * c0) * invdet;
+	result.at(3, 2) = (-mat.at(3, 0) * s3 + mat.at(3, 1) * s1 - mat.at(3, 2) * s0) * invdet;
+	result.at(3, 3) = (mat.at(2, 0) * s3 - mat.at(2, 1) * s1 + mat.at(2, 2) * s0) * invdet;
+
+	return result;
+}
+
+}  // namespace maths
+}  // namespace td

src/td/common/DataBuffer.cpp

@@ -1,163 +0,0 @@
-#include <td/common/DataBuffer.h>
-
-#include <fstream>
-#include <iomanip>
-#include <sstream>
-
-#include <td/misc/Format.h>
-#include <td/misc/Log.h>
-
-namespace td {
-
-DataBuffer::DataBuffer() : m_ReadOffset(0) {}
-
-DataBuffer::DataBuffer(const DataBuffer& other) : m_Buffer(other.m_Buffer), m_ReadOffset(other.m_ReadOffset) {}
-
-DataBuffer::DataBuffer(DataBuffer&& other) : m_Buffer(std::move(other.m_Buffer)), m_ReadOffset(std::move(other.m_ReadOffset)) {}
-
-DataBuffer::DataBuffer(const std::string& str) : m_Buffer(str.begin(), str.end()), m_ReadOffset(0) {}
-
-DataBuffer::DataBuffer(const DataBuffer& other, Data::difference_type offset) : m_ReadOffset(0) {
-	m_Buffer.reserve(other.GetSize() - static_cast<std::size_t>(offset));
-	std::copy(other.m_Buffer.begin() + offset, other.m_Buffer.end(), std::back_inserter(m_Buffer));
-}
-
-DataBuffer& DataBuffer::operator<<(const std::string& str) {
-	std::size_t strlen = str.length() + 1;	// including null character
-	Resize(GetSize() + strlen);
-	std::memcpy(m_Buffer.data() + GetSize() - strlen, str.data(), strlen);
-	return *this;
-}
-
-DataBuffer& DataBuffer::operator<<(const DataBuffer& data) {
-	m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
-	return *this;
-}
-
-DataBuffer& DataBuffer::operator>>(std::string& str) {
-	std::size_t stringSize = strlen(reinterpret_cast<const char*>(m_Buffer.data()) + m_ReadOffset) + 1;	 // including null character
-	str.resize(stringSize);
-	std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset),
-		m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset + stringSize), str.begin());
-	m_ReadOffset += stringSize;
-	str.resize(stringSize - 1);
-	return *this;
-}
-
-DataBuffer& DataBuffer::operator>>(DataBuffer& data) {
-	data.Resize(GetSize() - m_ReadOffset);
-	std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), m_Buffer.end(), data.begin());
-	m_ReadOffset = m_Buffer.size();
-	return *this;
-}
-
-void DataBuffer::WriteSome(const char* buffer, std::size_t amount) {
-	std::size_t end_pos = m_Buffer.size();
-	m_Buffer.resize(m_Buffer.size() + amount);
-	std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
-}
-
-void DataBuffer::WriteSome(const std::uint8_t* buffer, std::size_t amount) {
-	std::size_t end_pos = m_Buffer.size();
-	m_Buffer.resize(m_Buffer.size() + amount);
-	std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
-}
-
-void DataBuffer::ReadSome(char* buffer, std::size_t amount) {
-	assert(m_ReadOffset + amount <= GetSize());
-	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
-	m_ReadOffset += amount;
-}
-
-
-void DataBuffer::ReadSome(std::uint8_t* buffer, std::size_t amount) {
-	assert(m_ReadOffset + amount <= GetSize());
-	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
-	m_ReadOffset += amount;
-}
-
-
-void DataBuffer::ReadSome(DataBuffer& buffer, std::size_t amount) {
-	assert(m_ReadOffset + amount <= GetSize());
-	buffer.Resize(amount);
-	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer.begin());
-	m_ReadOffset += amount;
-}
-
-
-DataBuffer& DataBuffer::operator=(const DataBuffer& other) {
-	m_Buffer = other.m_Buffer;
-	m_ReadOffset = other.m_ReadOffset;
-	return *this;
-}
-
-DataBuffer& DataBuffer::operator=(DataBuffer&& other) {
-	m_Buffer = std::move(other.m_Buffer);
-	m_ReadOffset = std::move(other.m_ReadOffset);
-	return *this;
-}
-
-void DataBuffer::SetReadOffset(std::size_t pos) {
-	assert(pos <= GetSize());
-	m_ReadOffset = pos;
-}
-
-std::size_t DataBuffer::GetSize() const {
-	return m_Buffer.size();
-}
-
-std::size_t DataBuffer::GetRemaining() const {
-	return m_Buffer.size() - m_ReadOffset;
-}
-
-DataBuffer::iterator DataBuffer::begin() {
-	return m_Buffer.begin();
-}
-
-DataBuffer::iterator DataBuffer::end() {
-	return m_Buffer.end();
-}
-
-DataBuffer::const_iterator DataBuffer::begin() const {
-	return m_Buffer.begin();
-}
-
-DataBuffer::const_iterator DataBuffer::end() const {
-	return m_Buffer.end();
-}
-
-std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer) {
-	for (unsigned char u : buffer)
-		os << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(u) << " ";
-	os << std::dec;
-	return os;
-}
-
-bool DataBuffer::ReadFile(const std::string& fileName) {
-	try {
-		std::ifstream file(fileName, std::istream::binary);
-		std::ostringstream ss;
-		ss << file.rdbuf();
-		const std::string& s = ss.str();
-		m_Buffer = DataBuffer::Data(s.begin(), s.end());
-		m_ReadOffset = 0;
-	} catch (std::exception& e) {
-		utils::LOGE(utils::Format("[IO] Failed to read file %s ! reason : %s", fileName.c_str(), e.what()));
-		return false;
-	}
-	return m_Buffer.size() > 0;
-}
-
-bool DataBuffer::WriteFile(const std::string& fileName) const {
-	try {
-		std::ofstream file(fileName, std::ostream::binary);
-		file.write(reinterpret_cast<const char*>(m_Buffer.data()), static_cast<std::streamsize>(m_Buffer.size()));
-		file.flush();
-	} catch (std::exception& e) {
-		utils::LOGE(utils::Format("[IO] Failed to read file %s ! reason : %s", fileName.c_str(), e.what()));
-		return false;
-	}
-	return true;
-}
-
-}  // namespace td

src/td/common/VarInt.cpp

@@ -1,52 +0,0 @@
-#include <td/common/VarInt.h>
-
-#include <stdexcept>
-#include <td/common/DataBuffer.h>
-
-namespace td {
-
-static constexpr int SEGMENT_BITS = 0x7F;
-static constexpr int CONTINUE_BIT = 0x80;
-
-std::size_t VarInt::GetSerializedLength() const {
-	DataBuffer buffer;
-	buffer << *this;
-	return buffer.GetSize();
-}
-
-DataBuffer& operator<<(DataBuffer& out, const VarInt& var) {
-	std::uint64_t value = var.m_Value;
-	while (true) {
-		if ((value & ~static_cast<std::uint64_t>(SEGMENT_BITS)) == 0) {
-			out << static_cast<std::uint8_t>(value);
-			return out;
-		}
-
-		out << static_cast<std::uint8_t>((value & SEGMENT_BITS) | CONTINUE_BIT);
-
-		value >>= 7;
-	}
-}
-
-DataBuffer& operator>>(DataBuffer& in, VarInt& var) {
-	var.m_Value = 0;
-	unsigned int position = 0;
-	std::uint8_t currentByte;
-
-	while (true) {
-		in.ReadSome(&currentByte, 1);
-		var.m_Value |= static_cast<std::uint64_t>(currentByte & SEGMENT_BITS) << position;
-
-		if ((currentByte & CONTINUE_BIT) == 0)
-			break;
-
-		position += 7;
-
-		if (position >= 8 * sizeof(var.m_Value))
-			throw std::runtime_error("VarInt is too big");
-	}
-
-	return in;
-}
-
-}  // namespace td

src/td/game/World.cpp

@@ -0,0 +1,59 @@
+#include <td/game/World.h>
+
+namespace td {
+namespace game {
+
+World::World() : m_Teams{Team{TeamColor::Red}, Team{TeamColor::Blue}} {
+	
+}
+
+const Color* World::GetTileColor(TilePtr tile) const {
+	switch (tile->GetType()) {
+		case TileType::Tower: {
+			TowerTile* towerTile = dynamic_cast<TowerTile*>(tile.get());
+			return &m_TowerPlacePalette[towerTile->color_palette_ref];
+		}
+		case TileType::Walk: {
+			return &m_WalkablePalette;
+		}
+		case TileType::Decoration: {
+			DecorationTile* towerTile = dynamic_cast<DecorationTile*>(tile.get());
+			return &m_DecorationPalette[towerTile->color_palette_ref];
+			break;
+		}
+		default: {
+			return nullptr;
+		}
+	}
+	return nullptr;
+}
+
+bool World::LoadMap(const protocol::pdata::WorldHeader& a_WorldHeader) {
+	m_TowerPlacePalette = a_WorldHeader.m_TowerPlacePalette;
+	m_WalkablePalette = a_WorldHeader.m_WalkablePalette;
+	m_DecorationPalette = a_WorldHeader.m_DecorationPalette;
+	m_Background = a_WorldHeader.m_Background;
+
+	GetRedTeam().GetSpawn() = a_WorldHeader.m_RedSpawn;
+	GetBlueTeam().GetSpawn() = a_WorldHeader.m_BlueSpawn;
+
+	m_SpawnColorPalette = a_WorldHeader.m_SpawnColorPalette;
+
+	GetRedTeam().GetCastle() = a_WorldHeader.m_RedCastle;
+	GetRedTeam().GetCastle().SetTeam(&GetRedTeam());
+
+	GetBlueTeam().GetCastle() = a_WorldHeader.m_BlueCastle;
+	GetBlueTeam().GetCastle().SetTeam(&GetBlueTeam());
+
+	m_TilePalette = a_WorldHeader.m_TilePalette;
+
+	return true;
+}
+
+bool World::LoadMap(const protocol::pdata::WorldData& a_WorldData) {
+	m_Chunks = a_WorldData.m_Chunks;
+	return true;
+}
+
+}  // namespace game
+}  // namespace td

src/td/input/Display.cpp

@@ -0,0 +1,156 @@
+#include <td/input/Display.h>
+
+#include <GL/glew.h>
+#include <SDL3/SDL.h>
+#include <imgui.h>
+#include <imgui_impl_opengl3.h>
+#include <imgui_impl_sdl3.h>
+
+#include <td/misc/Format.h>
+#include <td/misc/Log.h>
+
+namespace td {
+
+Display::Display(int a_Width, int a_Height, const std::string& a_Title) :
+	m_LastWidth(0), m_LastHeight(0), m_AspectRatio(1), m_ShouldClose(false) {
+
+	m_Window = SDL_CreateWindow(a_Title.c_str(), a_Width, a_Height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
+
+	m_LastWidth = a_Width;
+	m_LastHeight = a_Height;
+	m_AspectRatio = (float)m_LastWidth / m_LastHeight;
+
+	// Prepare and create context
+#ifdef __ANDROID__
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+#else
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+#endif
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
+
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+
+	m_GLContext = SDL_GL_CreateContext(m_Window);
+
+	if (!m_GLContext) {
+		utils::LOGE(utils::Format("Could not create context! SDL error: %s", SDL_GetError()));
+	}
+
+	int major, minor, mask;
+	int r, g, b, a, depth;
+	SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &mask);
+	SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
+	SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
+
+	SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &r);
+	SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &g);
+	SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &b);
+	SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &a);
+
+	SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &depth);
+
+	const char* mask_desc;
+
+	if (mask & SDL_GL_CONTEXT_PROFILE_CORE) {
+		mask_desc = "core";
+	} else if (mask & SDL_GL_CONTEXT_PROFILE_COMPATIBILITY) {
+		mask_desc = "compatibility";
+	} else if (mask & SDL_GL_CONTEXT_PROFILE_ES) {
+		mask_desc = "es";
+	} else {
+		mask_desc = "?";
+	}
+
+	utils::LOG(utils::Format(
+		"GL Context : %i.%i %s, Color : R:%i G:%i B:%i A:%i, Depth bits : %i", major, minor, mask_desc, r, g, b, a, depth));
+
+	SDL_GL_MakeCurrent(m_Window, m_GLContext);
+
+	GLenum error = glewInit();
+	if (error) {
+		utils::LOGE(utils::Format("Error initializing glew : %s", glewGetErrorString(error)));
+	}
+
+	// WindowResizeEvent(WindowWidth, WindowHeight);
+
+	// Setup Dear ImGui context
+	IMGUI_CHECKVERSION();
+	ImGui::CreateContext();
+	ImGuiIO& io = ImGui::GetIO();
+	(void)io;
+	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;  // Enable Keyboard Controls
+	io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;   // Enable Gamepad Controls
+
+	// Setup Dear ImGui style
+	ImGui::StyleColorsDark();
+	// ImGui::StyleColorsLight();
+
+	// Setup scaling
+	float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
+	ImGuiStyle& style = ImGui::GetStyle();
+	style.ScaleAllSizes(main_scale);  // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this
+									  // requires resetting Style + calling this again)
+	style.FontScaleDpi = main_scale;  // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave
+									  // both here for documentation purpose)
+
+	// Setup Platform/Renderer backends
+	ImGui_ImplSDL3_InitForOpenGL(m_Window, m_GLContext);
+	ImGui_ImplOpenGL3_Init("#version 330");
+}
+
+
+void Display::PollEvents() {
+	SDL_Event event;
+	while (SDL_PollEvent(&event)) {
+		switch (event.type) {
+			case SDL_EVENT_QUIT:
+			case SDL_EVENT_WINDOW_CLOSE_REQUESTED: {
+				m_ShouldClose = true;
+			}
+
+			case SDL_EVENT_WINDOW_RESIZED: {
+				m_LastWidth = event.window.data1;
+				m_LastHeight = event.window.data2;
+				m_AspectRatio = (float)m_LastWidth / m_LastHeight;
+			}
+
+			default:
+				break;
+		}
+		ImGui_ImplSDL3_ProcessEvent(&event);
+	}
+	// Start the Dear ImGui frame
+	ImGui_ImplOpenGL3_NewFrame();
+	ImGui_ImplSDL3_NewFrame();
+	ImGui::NewFrame();
+}
+
+void Display::Update() {
+	ImGui::Render();
+	ImGuiIO& io = ImGui::GetIO();
+	glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
+	// glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
+	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+	SDL_GL_SwapWindow(m_Window);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+
+Display::~Display() {
+	ImGui_ImplOpenGL3_Shutdown();
+	ImGui_ImplSDL3_Shutdown();
+	ImGui::DestroyContext();
+	SDL_GL_DestroyContext(m_GLContext);
+	SDL_DestroyWindow(m_Window);
+	SDL_Quit();
+}
+
+}  // namespace td

src/td/render/Camera.cpp

@@ -0,0 +1,26 @@
+#include <td/render/Camera.h>
+
+#include <cmath>
+
+namespace td {
+namespace render {
+
+void Camera::UpdatePerspective(float a_AspectRatio) {
+	m_ProjectionMatrix = maths::Perspective(80.0f / 180.0f * PI, a_AspectRatio, 0.1f, 160.0f);
+	m_InvProjectionMatrix = maths::Inverse(m_ProjectionMatrix);
+}
+
+void Camera::SetCamPos(const Vec3f& a_NewPos) {
+	Vec3f front = {
+		std::cos(m_Yaw) * std::cos(m_Pitch),
+		std::sin(m_Pitch),
+		std::sin(m_Yaw) * std::cos(m_Pitch)
+	};
+
+	m_CamPos = a_NewPos;
+	m_ViewMatrix = maths::Look(m_CamPos, front, { 0, 1, 0 });
+	m_InvViewMatrix = maths::Transpose(maths::Inverse(m_ViewMatrix));  // why transpose ? I don't know
+}
+
+}  // namespace render
+}  // namespace td

src/td/render/Renderer.cpp

@@ -0,0 +1,26 @@
+#include <td/render/Renderer.h>
+
+#include <td/render/OpenGL.h>
+
+namespace td {
+namespace render {
+
+void Renderer::Render(const GL::VertexArray& a_Vao) {
+	a_Vao.Bind();
+	glDrawArrays(GL_TRIANGLES, 0, a_Vao.GetVertexCount());
+	// glDrawElements(GL_TRIANGLES, a_Vao.GetVertexCount(), GL_UNSIGNED_INT, nullptr);
+	a_Vao.Unbind();
+}
+
+RenderPipeline::RenderPipeline() {
+	glEnable(GL_TEXTURE_2D);
+	glEnable(GL_BLEND);
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glDepthFunc(GL_LESS);
+	glFrontFace(GL_CCW);
+}
+
+}  // namespace render
+}  // namespace td

src/td/render/loader/GLLoader.cpp

@@ -0,0 +1,99 @@
+#include <td/render/loader/GLLoader.h>
+
+#include <td/render/OpenGL.h>
+
+namespace td {
+namespace GL {
+
+VertexArray::~VertexArray() {
+	if (m_ID != 0)
+		glDeleteVertexArrays(1, &m_ID);
+}
+
+VertexArray::VertexArray(ElementBuffer&& indicies) : m_ElementBuffer(std::move(indicies)) {
+	glGenVertexArrays(1, &m_ID);
+	Bind();
+	BindElementArrayBuffer();
+	// Unbind();
+}
+
+void VertexArray::Bind() const {
+	glBindVertexArray(m_ID);
+}
+
+void VertexArray::Unbind() const {
+	glBindVertexArray(0);
+}
+
+void VertexArray::BindVertexBuffer(VertexBuffer&& VertexBuffer) {
+	VertexBuffer.Bind();
+	VertexBuffer.BindVertexAttribs();
+	m_VertexBuffers.push_back(std::move(VertexBuffer));
+}
+
+void VertexArray::BindElementArrayBuffer() {
+	m_ElementBuffer.Bind();
+}
+
+VertexBuffer::~VertexBuffer() {
+	if (m_ID != 0)
+		glDeleteBuffers(1, &m_ID);
+}
+
+VertexBuffer::VertexBuffer(const std::vector<float>& data, unsigned int stride) : m_DataStride(stride) {
+	glGenBuffers(1, &m_ID);
+	Bind();
+	glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(data.size() * sizeof(float)), nullptr, GL_STATIC_DRAW);
+	glBufferSubData(GL_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(data.size() * sizeof(float)), data.data());
+	Unbind();
+}
+
+void VertexBuffer::Bind() const {
+	glBindBuffer(GL_ARRAY_BUFFER, m_ID);
+}
+
+void VertexBuffer::Unbind() const {
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+void VertexBuffer::AddVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset) {
+	VertexAttribPointer pointer {
+		.m_Index = index,
+		.m_Size = coordinateSize,
+		.m_Offset = offset
+	};
+	m_VertexAttribs.push_back(pointer);
+}
+
+void VertexBuffer::BindVertexAttribs() const {
+	for (const VertexAttribPointer& pointer : m_VertexAttribs) {
+		glVertexAttribPointer(pointer.m_Index, static_cast<GLint>(pointer.m_Size), GL_FLOAT, false, m_DataStride * sizeof(float),
+		reinterpret_cast<GLvoid*>(static_cast<std::size_t>(pointer.m_Offset)));
+		glEnableVertexAttribArray(pointer.m_Index);
+	}
+}
+
+ElementBuffer::ElementBuffer(const std::vector<unsigned int>& indicies) {
+	m_TriangleCount = indicies.size();
+	glGenBuffers(1, &m_ID);
+	Bind();
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLsizeiptr>(indicies.size() * sizeof(unsigned int)), nullptr, GL_STATIC_DRAW);
+	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(indicies.size() * sizeof(unsigned int)), indicies.data());
+	Unbind();
+}
+
+ElementBuffer::~ElementBuffer() {
+	if (m_ID != 0)
+		glDeleteBuffers(1, &m_ID);
+}
+
+void ElementBuffer::Bind() const {
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ID);
+}
+
+void ElementBuffer::Unbind() const {
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+}  // namespace GL
+}  // namespace td

src/td/render/loader/WorldLoader.cpp

@@ -0,0 +1,218 @@
+#include <td/render/loader/WorldLoader.h>
+
+#include <iostream>
+#include <string.h>
+
+#include <td/game/World.h>
+
+namespace td {
+namespace render {
+
+namespace WorldLoader {
+
+const static int POSITION_VERTEX_SIZE = 3;
+const static int TEXTURE_VERTEX_SIZE = 2;
+
+GL::VertexArray LoadWorldModel(const td::game::World* world) {
+	std::vector<float> positions;
+	std::vector<float> colors;
+
+	for (const auto& chunkInfo : world->GetChunks()) {
+		const td::game::ChunkCoord& coords = chunkInfo.first;
+		td::game::ChunkPtr chunk = chunkInfo.second;
+
+		std::int32_t chunkX = coords.x * td::game::Chunk::ChunkWidth;
+		std::int32_t chunkY = coords.y * td::game::Chunk::ChunkHeight;
+
+		for (int tileY = 0; tileY < td::game::Chunk::ChunkHeight; tileY++) {
+			for (int tileX = 0; tileX < td::game::Chunk::ChunkWidth; tileX++) {
+				int tileNumber = tileY * td::game::Chunk::ChunkWidth + tileX;
+				td::game::TileIndex tileIndex = chunk->GetTileIndex(tileNumber);
+				td::game::TilePtr tile = world->GetTilePtr(tileIndex);
+
+				if (tile == nullptr)
+					continue;
+
+				positions.insert(
+					positions.end(), {static_cast<float>(chunkX + tileX + 1), 0, static_cast<float>(chunkY + tileY),
+										 static_cast<float>(chunkX + tileX), 0, static_cast<float>(chunkY + tileY),
+										 static_cast<float>(chunkX + tileX), 0, static_cast<float>(chunkY + tileY + 1),
+
+										 static_cast<float>(chunkX + tileX + 1), 0, static_cast<float>(chunkY + tileY),
+										 static_cast<float>(chunkX + tileX), 0, static_cast<float>(chunkY + tileY + 1),
+										 static_cast<float>(chunkX + tileX + 1), 0, static_cast<float>(chunkY + tileY + 1)});
+
+				const td::Color* tileColor = world->GetTileColor(tile);
+
+				for (int i = 0; i < 6; i++) {
+					int color = 255;
+					color |= tileColor->r << 24;
+					color |= tileColor->g << 16;
+					color |= tileColor->b << 8;
+
+					int newColorIndex = colors.size();
+					colors.push_back(0);
+
+					memcpy(colors.data() + newColorIndex, &color, 1 * sizeof(int));
+				}
+			}
+		}
+	}
+
+	for (int spawnColor = 0; spawnColor < 2; spawnColor++) {
+		const game::Spawn& spawn = world->GetTeam(TeamColor(spawnColor)).GetSpawn();
+		float fromX = spawn.GetTopLeft().GetX(), toX = spawn.GetBottomRight().GetX();
+		float fromY = spawn.GetTopLeft().GetY(), toY = spawn.GetBottomRight().GetY();
+
+		positions.insert(positions.end(), {fromX, 0, fromY, fromX, 0, toY, toX, 0, fromY, fromX, 0, toY, toX, 0, toY, toX, 0, fromY});
+
+		for (int i = 0; i < 6; i++) {
+			int color = 255;
+			color |= world->GetSpawnColor(TeamColor(spawnColor)).r << 24;
+			color |= world->GetSpawnColor(TeamColor(spawnColor)).g << 16;
+			color |= world->GetSpawnColor(TeamColor(spawnColor)).b << 8;
+
+			int newColorIndex = colors.size();
+			colors.push_back(0);
+
+			memcpy(colors.data() + newColorIndex, &color, 1 * sizeof(int));
+		}
+	}
+
+	for (int castleColor = 0; castleColor < 2; castleColor++) {
+		const game::TeamCastle& castle = world->GetTeam(TeamColor(castleColor)).GetCastle();
+		float fromX = castle.GetTopLeft().GetX(), toX = castle.GetBottomRight().GetX();
+		float fromY = castle.GetTopLeft().GetY(), toY = castle.GetBottomRight().GetY();
+
+		positions.insert(positions.end(), {fromX, 0, fromY, fromX, 0, toY, toX, 0, fromY, fromX, 0, toY, toX, 0, toY, toX, 0, fromY});
+
+		for (int i = 0; i < 6; i++) {
+			int color = 255;
+			color |= world->GetSpawnColor(TeamColor(castleColor)).r << 24;
+			color |= world->GetSpawnColor(TeamColor(castleColor)).g << 16;
+			color |= world->GetSpawnColor(TeamColor(castleColor)).b << 8;
+
+			int newColorIndex = colors.size();
+			colors.push_back(0);
+
+			memcpy(colors.data() + newColorIndex, &color, 1 * sizeof(int));
+		}
+	}
+
+	GL::VertexBuffer positionVBO(positions, POSITION_VERTEX_SIZE);
+	positionVBO.AddVertexAttribPointer(0, POSITION_VERTEX_SIZE, 0);
+	GL::VertexBuffer colorVBO(colors, 1);
+	colorVBO.AddVertexAttribPointer(1, 1, 0);
+
+	std::vector<unsigned int> indexes(positions.size() / 3, 0);
+	for (size_t i = 0; i < indexes.size(); i++) {
+		indexes[i] = i + 1;
+	}
+
+	GL::ElementBuffer indexVBO(indexes);
+
+	GL::VertexArray worldVao(std::move(indexVBO));	// each pos = 3 vertecies
+	worldVao.Bind();
+	worldVao.BindVertexBuffer(std::move(positionVBO));
+	worldVao.BindVertexBuffer(std::move(colorVBO));
+	worldVao.Unbind();
+	return worldVao;
+}
+
+GL::VertexArray LoadTileSelectModel() {
+	std::vector<float> positions = {
+		-0.5f,
+		-0.5f,
+		-1.0f,
+
+		0.5f,
+		-0.5f,
+		-1.0f,
+
+		0.0f,
+		0.5f,
+		-1.0f,
+
+		1,
+		.01,
+		1,
+
+		0,
+		.01,
+		1,
+		
+		0,
+		1,
+		1,
+	};
+
+	int color = 255 << 24 | 255 << 16 | 255 << 8 | 150;
+	float colorFloat;
+
+	memcpy(reinterpret_cast<std::uint8_t*>(&colorFloat), &color, sizeof(float));
+
+	std::vector<float> colors(6, colorFloat);
+
+	GL::VertexBuffer positionVBO(positions, POSITION_VERTEX_SIZE);
+	positionVBO.AddVertexAttribPointer(0, POSITION_VERTEX_SIZE, 0);
+	GL::VertexBuffer colorVBO(colors, 1);
+	colorVBO.AddVertexAttribPointer(1, 1, 0);
+
+	std::vector<unsigned int> indexes(positions.size() / 3, 0);
+	for (size_t i = 0; i < indexes.size(); i++) {
+		indexes[i] = i + 1;
+	}
+	GL::ElementBuffer indexVBO(indexes);
+
+	GL::VertexArray tileSelectVao(std::move(indexVBO));
+	tileSelectVao.Bind();
+	tileSelectVao.BindVertexBuffer(std::move(positionVBO));
+	tileSelectVao.BindVertexBuffer(std::move(colorVBO));
+	tileSelectVao.Unbind();
+
+	return tileSelectVao;
+}
+
+RenderData LoadTowerModel(game::TowerPtr tower) {
+	RenderData renderData;
+
+	float towerX, towerDX;
+	float towerY, towerDY;
+
+	if (tower->GetSize() == game::TowerSize::Little) {
+		towerX = tower->GetCenterX() - 1.5f;
+		towerDX = tower->GetCenterX() + 1.5f;
+
+		towerY = tower->GetCenterY() - 1.5f;
+		towerDY = tower->GetCenterY() + 1.5f;
+	} else {
+		towerX = tower->GetCenterX() - 2.5f;
+		towerDX = tower->GetCenterX() + 2.5f;
+
+		towerY = tower->GetCenterY() - 2.5f;
+		towerDY = tower->GetCenterY() + 2.5f;
+	}
+	std::vector<float> positions = {towerDX, 0.001, towerY, towerX, 0.001, towerY, towerX, 0.001, towerDY, towerDX, 0.001, towerY,
+		towerX, 0.001, towerDY, towerDX, 0.001, towerDY};
+
+	renderData.positions = positions;
+
+	std::uint8_t towerType = static_cast<std::uint8_t>(tower->GetType());
+	std::uint8_t r = 10 * towerType + 40, g = 5 * towerType + 30, b = 10 * towerType + 20;
+
+	float colorFloat;
+	int color = r << 24 | g << 16 | b << 8 | 255;
+	memcpy(&colorFloat, &color, sizeof(int));
+
+	std::vector<float> colors(6, colorFloat);
+	renderData.colors = colors;
+
+	return renderData;
+}
+
+
+}  // namespace WorldLoader
+
+
+}  // namespace render
+}  // namespace td

src/td/render/renderer/WorldRenderer.cpp

@@ -0,0 +1,26 @@
+#include <td/render/renderer/WorldRenderer.h>
+
+#include <td/render/loader/WorldLoader.h>
+
+#include <imgui.h>
+
+namespace td {
+namespace render {
+
+WorldRenderer::WorldRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera), m_World(a_World){
+	m_WorldVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::LoadWorldModel(&a_World)));
+}
+
+WorldRenderer::~WorldRenderer() {}
+
+void WorldRenderer::Render() {
+	m_Shader.Start();
+	m_Shader.SetProjectionMatrix(m_Camera.GetProjectionMatrix());
+	m_Shader.SetViewMatrix(m_Camera.GetViewMatrix());
+	Renderer::Render(*m_WorldVao);
+	ImGui::ShowDemoWindow();
+}
+
+
+}  // namespace render
+}  // namespace td

src/td/render/shader/EntityShader.cpp

@@ -0,0 +1,123 @@
+#include <td/render/shader/EntityShader.h>
+
+namespace td {
+namespace shader {
+
+// TODO: update ES shaders
+
+#ifdef __ANDROID__
+static const char vertexSource[] =
+R"(#version 300 es
+
+precision mediump float;
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in int color;
+
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+uniform vec3 modelPosition;
+
+flat out int pass_color;
+
+void main(void){
+	pass_color = color;
+	gl_Position = projectionMatrix * viewMatrix * vec4(position + modelPosition, 1.0);
+}
+)";
+
+static const char fragmentSource[] =
+R"(#version 300 es
+
+precision mediump float;
+
+flat in int pass_color;
+
+out vec4 out_color;
+
+uniform vec3 ColorEffect;
+
+void main(void){
+
+    float r = float(pass_color >> 24 & 0xFF) / 255.0;
+    float g = float(pass_color >> 16 & 0xFF) / 255.0;
+    float b = float(pass_color >> 8 & 0xFF) / 255.0;
+    float a = float(pass_color & 0xFF) / 255.0; 
+	vec3 intermediate_color = vec3(r, g, b) * ColorEffect;
+	out_color = vec4(intermediate_color, a);
+
+}
+)";
+#else
+static const char vertexSource[] = R"(
+#version 330
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec2 textureCoords;
+
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+uniform vec3 modelPosition;
+
+out vec2 pass_textureCoords;
+
+void main(void){
+	pass_textureCoords = textureCoords;
+	gl_Position = projectionMatrix * viewMatrix * vec4(position + modelPosition, 1.0);
+}
+)";
+
+static const char fragmentSource[] = R"(
+#version 330
+
+in vec2 pass_textureCoords;
+
+out vec4 out_color;
+
+uniform vec3 ColorEffect;
+uniform sampler2D textureSampler;
+
+void main(void){
+
+	vec4 color = vec4(ColorEffect, 1.0) * texture(textureSampler, pass_textureCoords);
+
+	if (color.a <= 0.1)
+		discard;
+
+	out_color = color;
+
+}
+)";
+#endif
+
+EntityShader::EntityShader() : ShaderProgram() {}
+
+void EntityShader::LoadShader() {
+	ShaderProgram::LoadProgram(vertexSource, fragmentSource);
+}
+
+void EntityShader::GetAllUniformLocation() {
+	m_LocationColorEffect = static_cast<unsigned int>(GetUniformLocation("ColorEffect"));
+	m_LocationViewMatrix = static_cast<unsigned int>(GetUniformLocation("viewMatrix"));
+	m_LocationPosition = static_cast<unsigned int>(GetUniformLocation("modelPosition"));
+	m_LocationProjectionMatrix = static_cast<unsigned int>(GetUniformLocation("projectionMatrix"));
+}
+
+void EntityShader::SetColorEffect(const Vec3f& color) {
+	LoadVector(m_LocationColorEffect, color);
+}
+
+void EntityShader::SetProjectionMatrix(const Mat4f& proj) const {
+	LoadMat4(m_LocationProjectionMatrix, proj);
+}
+
+void EntityShader::SetViewMatrix(const Mat4f& view) const {
+	LoadMat4(m_LocationViewMatrix, view);
+}
+
+void EntityShader::SetModelPos(const Vec3f& pos) const {
+	LoadVector(m_LocationPosition, pos);
+}
+
+} // namespace shader
+} // namespace td

src/td/render/shader/ShaderProgram.cpp

@@ -0,0 +1,145 @@
+/*
+ * ShaderProgram.cpp
+ *
+ *  Created on: 31 janv. 2020
+ *      Author: simon
+ */
+
+#include <td/render/shader/ShaderProgram.h>
+#include <td/misc/Log.h>
+#include <td/misc/Format.h>
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+namespace td {
+namespace shader {
+
+ShaderProgram::ShaderProgram() :
+	m_ProgramID(0), m_VertexShaderID(0), m_FragmentShaderID(0) {
+}
+
+ShaderProgram::~ShaderProgram() {
+	CleanUp();
+}
+
+void ShaderProgram::Start() const {
+	glUseProgram(m_ProgramID);
+}
+
+void ShaderProgram::Stop() const {
+	glUseProgram(0);
+}
+
+int ShaderProgram::GetUniformLocation(const std::string& uniformName) const {
+	const int location = glGetUniformLocation(m_ProgramID, uniformName.c_str());
+	if (location == -1) {
+		utils::LOGD(utils::Format("Warning ! Uniform variable %s not found !", uniformName.c_str()));
+	}
+	return location;
+}
+
+void ShaderProgram::LoadFloat(unsigned int location, float value) const {
+	glUniform1f(static_cast<GLint>(location), value);
+}
+
+void ShaderProgram::LoadInt(unsigned int location, int value) const {
+	glUniform1i(static_cast<GLint>(location), value);
+}
+
+void ShaderProgram::LoadVector(unsigned int location,
+	const Vec2f& vector) const {
+	glUniform2f(static_cast<GLint>(location), vector.x, vector.y);
+}
+
+void ShaderProgram::LoadVector(unsigned int location,
+	const Vec3f& vector) const {
+	glUniform3f(static_cast<GLint>(location), vector.x, vector.y, vector.z);
+}
+
+void ShaderProgram::LoadBoolean(unsigned int location, bool value) const {
+	glUniform1i(static_cast<GLint>(location), value);
+}
+
+void ShaderProgram::LoadMat4(unsigned int location, const Mat4f& mat) const {
+	glUniformMatrix4fv(static_cast<GLint>(location), 1, false, reinterpret_cast<const float*>(&mat));
+}
+
+void ShaderProgram::CleanUp() const {
+	Stop();
+	glDetachShader(m_ProgramID, m_VertexShaderID);
+	glDetachShader(m_ProgramID, m_FragmentShaderID);
+	glDeleteShader(m_VertexShaderID);
+	glDeleteShader(m_FragmentShaderID);
+	glDeleteProgram(m_ProgramID);
+}
+
+void ShaderProgram::LoadProgramFile(const std::string& vertexFile,
+	const std::string& fragmentFile) {
+	m_VertexShaderID = static_cast<unsigned int>(LoadShaderFromFile(vertexFile, GL_VERTEX_SHADER));
+	m_FragmentShaderID = static_cast<unsigned int>(LoadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER));
+	m_ProgramID = glCreateProgram();
+	glAttachShader(m_ProgramID, m_VertexShaderID);
+	glAttachShader(m_ProgramID, m_FragmentShaderID);
+	glLinkProgram(m_ProgramID);
+	glValidateProgram(m_ProgramID);
+	GetAllUniformLocation();
+}
+
+void ShaderProgram::LoadProgram(const std::string& vertexSource,
+	const std::string& fragmentSource) {
+	m_VertexShaderID = static_cast<unsigned int>(LoadShader(vertexSource, GL_VERTEX_SHADER));
+	m_FragmentShaderID = static_cast<unsigned int>(LoadShader(fragmentSource, GL_FRAGMENT_SHADER));
+	m_ProgramID = glCreateProgram();
+	glAttachShader(m_ProgramID, m_VertexShaderID);
+	glAttachShader(m_ProgramID, m_FragmentShaderID);
+	glLinkProgram(m_ProgramID);
+	glValidateProgram(m_ProgramID);
+	GetAllUniformLocation();
+}
+
+unsigned int ShaderProgram::LoadShader(const std::string& source, GLenum type) {
+	unsigned int shaderID = glCreateShader(type);
+
+	const char* c_str = source.c_str();
+	int* null = 0;
+	glShaderSource(shaderID, 1, &c_str, null); // @suppress("Function cannot be resolved")
+	glCompileShader(shaderID);
+	GLint compilesuccessful;
+	glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful);
+	if (compilesuccessful == false) {
+		GLsizei size;
+		glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size);
+		std::vector<char> shaderError(static_cast<std::size_t>(size));
+		glGetShaderInfoLog(shaderID, size, &size, shaderError.data());
+
+		utils::LOGE("Could not compile shader !");
+
+		utils::LOGE(shaderError.data());
+
+		utils::LOGD(utils::Format("\nShader source : \n"
+			"------------------------------------------------------------------------------------------------------------------------------------\n"
+			"%s\n"
+			"------------------------------------------------------------------------------------------------------------------------------------\n"
+		, source.c_str()));
+	}
+	return shaderID;
+}
+
+unsigned int ShaderProgram::LoadShaderFromFile(const std::string& file, GLenum type) {
+	std::stringstream stream;
+	std::ifstream fileStream(file);
+
+	if (fileStream) {
+		stream << fileStream.rdbuf();
+	} else {
+		return 0;
+	}
+
+	return LoadShader(stream.str(), type);
+}
+
+} // namespace shader
+} // namespace td

src/td/render/shader/WorldShader.cpp

@@ -0,0 +1,102 @@
+#include <td/render/shader/WorldShader.h>
+
+namespace td {
+namespace shader {
+
+// TODO: GLES Shaders
+
+#ifdef __ANDROID__
+static const char vertexSource[] =
+R"(#version 300 es
+
+precision mediump float;
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in int color;
+
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+
+flat out int pass_color;
+
+void main(void){
+   	pass_color = color;
+	gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.0);
+}
+)";
+
+static const char fragmentSource[] =
+R"(#version 300 es
+
+precision mediump float;
+
+flat in int pass_color;
+
+out vec4 out_color;
+
+void main(void){
+
+    float r = float(pass_color >> 24 & 0xFF) / 255.0;
+    float g = float(pass_color >> 16 & 0xFF) / 255.0;
+    float b = float(pass_color >> 8 & 0xFF) / 255.0;
+    float a = float(pass_color & 0xFF) / 255.0; 
+	out_color = vec4(r, g, b, a);
+
+}
+)";
+#else
+static const char vertexSource[] = R"(
+#version 330
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in int color;
+
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+
+flat out int pass_color;
+
+void main(void){
+   	pass_color = color;
+	gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.0);
+}
+)";
+
+static const char fragmentSource[] = R"(
+#version 330
+
+flat in int pass_color;
+
+out vec4 out_color;
+
+void main(void){
+
+    float r = float(pass_color >> 24 & 0xFF) / 255.0;
+    float g = float(pass_color >> 16 & 0xFF) / 255.0;
+    float b = float(pass_color >> 8 & 0xFF) / 255.0;
+    float a = float(pass_color & 0xFF) / 255.0; 
+	out_color = vec4(r, g, b, a);
+
+}
+)";
+#endif
+
+WorldShader::WorldShader() : ShaderProgram() {
+	ShaderProgram::LoadProgram(vertexSource, fragmentSource);
+}
+
+void WorldShader::GetAllUniformLocation() {
+	m_LocationProjection = static_cast<unsigned int>(GetUniformLocation("projectionMatrix"));
+	m_LocationView = static_cast<unsigned int>(GetUniformLocation("viewMatrix"));
+}
+
+void WorldShader::SetProjectionMatrix(const Mat4f& proj) const {
+	LoadMat4(m_LocationProjection, proj);
+}
+
+void WorldShader::SetViewMatrix(const Mat4f& view) const {
+	LoadMat4(m_LocationView, view);
+}
+
+} // namespace shader
+} // namespace td