diff --git a/assets/map/states.map b/assets/map/states.map
index cdec31f..8f40f94 100644
Binary files a/assets/map/states.map and b/assets/map/states.map differ
diff --git a/engine-api/include/ee_engine_api/AssetData.hpp b/engine-api/include/ee_engine_api/AssetData.hpp
index 46c9198..9005eac 100644
--- a/engine-api/include/ee_engine_api/AssetData.hpp
+++ b/engine-api/include/ee_engine_api/AssetData.hpp
@@ -3,29 +3,32 @@
 #include <concepts>
 #include <cstdint>
 
-struct AssetData {};
-template<typename T> concept Asset = std::derived_from<T, AssetData>;
-
-struct AssetBinary : AssetData
+namespace ee_assets
 {
-    uint8_t* content = nullptr;
-    size_t size = 0;
-
-    AssetBinary(uint8_t* &source, const size_t &sourceSize);
-    ~AssetBinary();
-};
-
-struct AssetMapMesh : AssetData
-{
-    MapMesh content;
-
-    AssetMapMesh(uint8_t* &source, const size_t &sourceSize);
-};
-
-#define AssetShader AssetBinary
-
-struct AssetMaterial : AssetData
-{
-    uint32_t vertexShaderAssetID;
-    uint32_t fragmentShaderAssetID;
-};
\ No newline at end of file
+    struct AssetData {};
+    template<typename T> concept Asset = std::derived_from<T, AssetData>;
+    
+    struct AssetBinary : AssetData
+    {
+        uint8_t* content = nullptr;
+        size_t size = 0;
+    
+        AssetBinary(uint8_t* &source, const size_t &sourceSize);
+        ~AssetBinary();
+    };
+    
+    struct AssetMapMesh : AssetData
+    {
+        ee_engine::MapMesh content;
+    
+        AssetMapMesh(uint8_t* &source, const size_t &sourceSize);
+    };
+    
+    #define AssetShader AssetBinary
+    
+    struct AssetMaterial : AssetData
+    {
+        uint32_t vertexShaderAssetID;
+        uint32_t fragmentShaderAssetID;
+    };
+}
\ No newline at end of file
diff --git a/engine-api/include/ee_engine_api/Map.hpp b/engine-api/include/ee_engine_api/Map.hpp
index 786d7cb..03997f3 100644
--- a/engine-api/include/ee_engine_api/Map.hpp
+++ b/engine-api/include/ee_engine_api/Map.hpp
@@ -4,18 +4,21 @@
 #include <unordered_map>
 #include <glm/glm.hpp>
 
-struct MapMesh
+namespace ee_engine
 {
-    struct Province
+    struct MapMesh
     {
-        std::vector<glm::vec2> vertices;
-        std::vector<uint16_t> indices;
+        struct Province
+        {
+            std::vector<glm::vec2> vertices;
+            std::vector<uint16_t> indices;
+        };
+        std::unordered_map<uint32_t, std::vector<Province>> states;
     };
-    std::unordered_map<uint32_t, std::vector<Province>> states;
-};
-
-struct ProvinceSSBO
-{
-    uint32_t stateId;
-    uint32_t color;
-};
\ No newline at end of file
+    
+    struct ProvinceSSBO
+    {
+        uint32_t stateId;
+        uint32_t color;
+    };
+}
\ No newline at end of file
diff --git a/engine-api/include/ee_engine_api/RenderInterface.hpp b/engine-api/include/ee_engine_api/RenderInterface.hpp
index 4a1819f..58f5c68 100644
--- a/engine-api/include/ee_engine_api/RenderInterface.hpp
+++ b/engine-api/include/ee_engine_api/RenderInterface.hpp
@@ -3,59 +3,58 @@
 #include "Map.hpp"
 #include "AssetData.hpp"
 
-struct ShaderRefs
+namespace ee_engine
 {
-    AssetShader *vertProvinces;
-    AssetShader *fragProvinces;
-};
-
-struct CameraTransform
-{
-    glm::vec2 position {0.0f, 0.0f};
-    float zoom = 1.0f;
-};
-
-struct MeshTransform
-{
-    glm::vec2 position {0.0f, 0.0f};
-    glm::vec2 scale {1.0f, 1.0f};
-    float rotation;
-};
-
-class IRenderer
-{
-public:
-    virtual ~IRenderer();
-
-    void RegisterMaterials(const ShaderRefs &shaders);
-    void RegisterMapMesh(MapMesh *mapMesh);
+    struct ShaderRefs
+    {
+        ee_assets::AssetShader *vertProvinces;
+        ee_assets::AssetShader *fragProvinces;
+    };
     
-    virtual void Init() = 0;
-    virtual void Shutdown() = 0;
-    void Draw();
+    struct CameraTransform
+    {
+        glm::vec2 position {0.0f, 0.0f};
+        float zoom = 1.0f;
+    };
     
-    virtual void ResizeWindow(int width, int height);
-    void SetCamera(const CameraTransform &camera);
-    void SetMapTransform(const MeshTransform &mapTransform);
-
-protected:
-    int screenWidth, screenHeight;
-    float screenAspect;
-    CameraTransform camera;
-    MeshTransform mapTransform;
-    glm::mat4 mapModel;
-    glm::mat4 viewProjection;
-
-    GLFWwindow *window;
-    MapMesh *mapMesh;
-    ShaderRefs shaders;
-
-    explicit IRenderer(GLFWwindow *window);
-
-    virtual void Clear() = 0;
-    virtual void DrawMap() = 0;
-    virtual void DrawUI() = 0;
-
-    virtual void ApplyCamera() = 0;
-    virtual void ApplyMapTransform() = 0;
-};
\ No newline at end of file
+    struct MeshTransform
+    {
+        glm::vec2 position {0.0f, 0.0f};
+        glm::vec2 scale {1.0f, 1.0f};
+        float rotation;
+    };
+    
+    class IRenderer
+    {
+    public:
+        virtual ~IRenderer();
+    
+        void RegisterMaterials(const ShaderRefs &shaders);
+        void RegisterMapMesh(MapMesh *mapMesh);
+        
+        virtual void Init() = 0;
+        virtual void Shutdown() = 0;
+        void Draw();
+        
+        virtual void ResizeWindow(int width, int height);
+        void SetCamera(const CameraTransform &camera);
+    
+    protected:
+        int screenWidth, screenHeight;
+        float screenAspect;
+        CameraTransform camera;
+        glm::mat4 viewProjection;
+    
+        GLFWwindow *window;
+        MapMesh *mapMesh;
+        ShaderRefs shaders;
+    
+        explicit IRenderer(GLFWwindow *window);
+    
+        virtual void Clear() = 0;
+        virtual void DrawMap() = 0;
+        virtual void DrawUI() = 0;
+    
+        virtual void ApplyCamera() = 0;
+    };
+}
\ No newline at end of file
diff --git a/engine-api/src/AssetData.cpp b/engine-api/src/AssetData.cpp
index f0646e5..730842b 100644
--- a/engine-api/src/AssetData.cpp
+++ b/engine-api/src/AssetData.cpp
@@ -11,14 +11,14 @@ IN THIS CASE, YOU MUST SET SOURCE TO NULLPTR AND FREE BUFFER YOURSELF.
 
 */
 
-AssetBinary::AssetBinary(uint8_t* &source, const size_t &sourceSize)
+ee_assets::AssetBinary::AssetBinary(uint8_t* &source, const size_t &sourceSize)
 {
     content = source;
     size = sourceSize;
     source = nullptr;
 }
 
-AssetBinary::~AssetBinary()
+ee_assets::AssetBinary::~AssetBinary()
 {
     if (content != nullptr)
         DeallocateArray(content);
@@ -26,7 +26,7 @@ AssetBinary::~AssetBinary()
 
 
 
-AssetMapMesh::AssetMapMesh(uint8_t* &source, const size_t &sourceSize)
+ee_assets::AssetMapMesh::AssetMapMesh(uint8_t* &source, const size_t &sourceSize)
 {
     uint8_t* buffer = source;
     uint8_t* pointer = source;
@@ -34,48 +34,48 @@ AssetMapMesh::AssetMapMesh(uint8_t* &source, const size_t &sourceSize)
     source = nullptr;
 
     uint32_t statesCount = 0;
-    readNext(&statesCount, pointer, leftoverSize, sizeof(uint32_t));
+    ee_utils::readNext(&statesCount, pointer, leftoverSize, sizeof(uint32_t));
 
     for (uint32_t state = 0; state < statesCount; state++)
     {
         uint32_t id = 0;
         glm::u8vec3 color {};
-        if (!readNext(&color, pointer, leftoverSize, sizeof(glm::u8vec3)))
+        if (!ee_utils::readNext(&color, pointer, leftoverSize, sizeof(glm::u8vec3)))
             break;
         id = static_cast<uint32_t>(color.r) << 16 | 
             static_cast<uint32_t>(color.g) << 8 | 
             static_cast<uint32_t>(color.b);
         
         uint32_t provincesCount = 0;
-        readNext(&provincesCount, pointer, leftoverSize, sizeof(uint32_t));
+        ee_utils::readNext(&provincesCount, pointer, leftoverSize, sizeof(uint32_t));
 
         for (uint32_t pi = 0; pi < provincesCount; pi++)
         {
-            MapMesh::Province prov;
+            ee_engine::MapMesh::Province prov;
 
             uint32_t verticesCount = 0;
-            if (!readNext(&verticesCount, pointer, leftoverSize, sizeof(uint32_t)))
+            if (!ee_utils::readNext(&verticesCount, pointer, leftoverSize, sizeof(uint32_t)))
                 break;
 
             prov.vertices.reserve(verticesCount);
             for (uint32_t vi = 0; vi < verticesCount; vi++)
             {
                 glm::vec2 vertex;
-                if (!readNext(&vertex, pointer, leftoverSize, sizeof(glm::vec2)))
+                if (!ee_utils::readNext(&vertex, pointer, leftoverSize, sizeof(glm::vec2)))
                     break;
                 
                 prov.vertices.push_back(vertex);
             }
 
             uint32_t indicesCount = 0;
-            if (!readNext(&indicesCount, pointer, leftoverSize, sizeof(uint32_t)))
+            if (!ee_utils::readNext(&indicesCount, pointer, leftoverSize, sizeof(uint32_t)))
                 break;
 
             prov.indices.reserve(indicesCount);
             for(uint32_t ii = 0; ii < indicesCount; ii++)
             {
                 uint16_t index = 0;
-                if (!readNext(&index, pointer, leftoverSize, sizeof(uint16_t)))
+                if (!ee_utils::readNext(&index, pointer, leftoverSize, sizeof(uint16_t)))
                     break;
                 
                 prov.indices.push_back(index);
diff --git a/engine-api/src/RenderInterface.cpp b/engine-api/src/RenderInterface.cpp
index 2b3dab2..6fc6c7e 100644
--- a/engine-api/src/RenderInterface.cpp
+++ b/engine-api/src/RenderInterface.cpp
@@ -3,43 +3,43 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include "Logger.h"
 
-IRenderer::IRenderer(GLFWwindow *window)
+ee_engine::IRenderer::IRenderer(GLFWwindow *window)
 {
     this->window = window;
 	glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
 	screenAspect = static_cast<float>(screenWidth) / static_cast<float>(screenHeight);
 }
 
-IRenderer::~IRenderer()
+ee_engine::IRenderer::~IRenderer()
 {
 	
 }
 
-void IRenderer::RegisterMaterials(const ShaderRefs &shaders)
+void ee_engine::IRenderer::RegisterMaterials(const ShaderRefs &shaders)
 {
 	this->shaders = shaders;
 }
 
-void IRenderer::RegisterMapMesh(MapMesh* mapMesh)
+void ee_engine::IRenderer::RegisterMapMesh(MapMesh* mapMesh)
 {
 	this->mapMesh = mapMesh;
 }
 
-void IRenderer::Draw()
+void ee_engine::IRenderer::Draw()
 {
 	Clear();
 	DrawMap();
 	DrawUI();
 }
 
-void IRenderer::ResizeWindow(int width, int height)
+void ee_engine::IRenderer::ResizeWindow(int width, int height)
 {
 	screenWidth = width;
 	screenHeight = height;
 	screenAspect = static_cast<float>(screenWidth) / static_cast<float>(screenHeight);
 }
 
-void IRenderer::SetCamera(const CameraTransform &camera)
+void ee_engine::IRenderer::SetCamera(const CameraTransform &camera)
 {
 	if (camera.zoom <= 0)
 	{
@@ -65,16 +65,4 @@ void IRenderer::SetCamera(const CameraTransform &camera)
 	viewProjection = P * V;
 
 	ApplyCamera();
-}
-
-void IRenderer::SetMapTransform(const MeshTransform &mapTransform)
-{
-	this->mapTransform = mapTransform;
-
-	glm::mat4 M(1.0f);
-	M = glm::translate(M, glm::vec3(mapTransform.position, 0.0f));
-    M = glm::rotate(M, mapTransform.rotation, glm::vec3(0.0f, 0.0f, 1.0f));
-    M = glm::scale(M, glm::vec3(mapTransform.scale, 1.0f));
-
-	ApplyMapTransform();
 }
\ No newline at end of file
diff --git a/engine/include/AssetManager.hpp b/engine/include/AssetManager.hpp
index 6390cd4..e00c722 100644
--- a/engine/include/AssetManager.hpp
+++ b/engine/include/AssetManager.hpp
@@ -92,10 +92,10 @@ public:
     void LoadAsync(AssetInfo::Type type, const std::filesystem::path &path);
     AssetHandle& Find(const std::filesystem::path &path);
     AssetHandle& Find(const uint32_t &id);
-    template <Asset T> T& FindOnce(const std::filesystem::path &path);
-    template <Asset T> T& FindOnce(const uint32_t &id);
+    template <ee_assets::Asset T> T& FindOnce(const std::filesystem::path &path);
+    template <ee_assets::Asset T> T& FindOnce(const uint32_t &id);
     void Redirect(AssetHandle &handle, void *resource);
-    template <Asset T> T& Get(const AssetHandle &handle);
+    template <ee_assets::Asset T> T& Get(const AssetHandle &handle);
     void Free(AssetHandle &handle);
 
 private:
@@ -111,10 +111,10 @@ private:
     std::vector<size_t> freeAssetSlots;
     std::vector<AssetLoadingEntry> loadingEntries;
 
-    std::vector<AssetBinary*> binaryStorage;
-    std::vector<AssetMapMesh*> mapMeshesStorage;
-    std::vector<AssetShader*> shadersStorage;
-    std::vector<AssetMaterial*> materialsStorage;
+    std::vector<ee_assets::AssetBinary*> binaryStorage;
+    std::vector<ee_assets::AssetMapMesh*> mapMeshesStorage;
+    std::vector<ee_assets::AssetShader*> shadersStorage;
+    std::vector<ee_assets::AssetMaterial*> materialsStorage;
 
     void Threading();
     void Request(const AssetStreamCommand &command);
@@ -123,10 +123,10 @@ private:
     void ProcessCommand(AssetStreamCommand &command);
     void Release();
 
-    template<Asset T> void ClearStorage(std::vector<T*> &storage);
+    template<ee_assets::Asset T> void ClearStorage(std::vector<T*> &storage);
 };
 
-template <Asset T> T& AssetManager::Get(const AssetHandle &handle)
+template <ee_assets::Asset T> T& AssetManager::Get(const AssetHandle &handle)
 {
     std::atomic<void*> result;
     AssetStreamCommand command {
@@ -139,17 +139,17 @@ template <Asset T> T& AssetManager::Get(const AssetHandle &handle)
     return *reinterpret_cast<T*>(command.out->load());
 }
 
-template <Asset T> T& AssetManager::FindOnce(const std::filesystem::path &path)
+template <ee_assets::Asset T> T& AssetManager::FindOnce(const std::filesystem::path &path)
 {
     return Get<T>(Find(path));
 }
 
-template <Asset T> T& AssetManager::FindOnce(const uint32_t &id)
+template <ee_assets::Asset T> T& AssetManager::FindOnce(const uint32_t &id)
 {
     return Get<T>(Find(id));
 }
 
-template<Asset T> void AssetManager::ClearStorage(std::vector<T*> &storage)
+template<ee_assets::Asset T> void AssetManager::ClearStorage(std::vector<T*> &storage)
 {
     for (T* &resource : storage)
     {
diff --git a/engine/include/Engine.hpp b/engine/include/Engine.hpp
index 48a0da3..9d7b45b 100644
--- a/engine/include/Engine.hpp
+++ b/engine/include/Engine.hpp
@@ -8,7 +8,7 @@ class Engine
 {
 public:
     static AssetManager *assetManager;
-    static IRenderer *renderer;
+    static ee_engine::IRenderer *renderer;
 
     static void Shutdown();
 
diff --git a/engine/src/AssetManager.cpp b/engine/src/AssetManager.cpp
index 788fe40..821c00c 100644
--- a/engine/src/AssetManager.cpp
+++ b/engine/src/AssetManager.cpp
@@ -177,7 +177,7 @@ void AssetManager::Loop()
                 {
                     case AssetInfo::MAP_MESH:
                     {
-                        AssetMapMesh* mesh = Allocate<AssetMapMesh>(entry.file->data, entry.file->size);
+                        ee_assets::AssetMapMesh* mesh = Allocate<ee_assets::AssetMapMesh>(entry.file->data, entry.file->size);
                         mapMeshesStorage.push_back(mesh);
                         Redirect(entry.handle, mapMeshesStorage.back());
                         break;
@@ -186,7 +186,7 @@ void AssetManager::Loop()
 
                     case AssetInfo::SHADER:
                     {
-                        AssetShader* shader = Allocate<AssetShader>(entry.file->data, entry.file->size);
+                        ee_assets::AssetShader* shader = Allocate<ee_assets::AssetShader>(entry.file->data, entry.file->size);
                         shadersStorage.push_back(shader);
                         Redirect(entry.handle, shadersStorage.back());
                         break;
@@ -194,10 +194,10 @@ void AssetManager::Loop()
 
                     case AssetInfo::MATERIAL:
                     {
-                        AssetMaterial* material = Allocate<AssetMaterial>();
-                        if (entry.file->size < sizeof(AssetMaterial))
+                        ee_assets::AssetMaterial* material = Allocate<ee_assets::AssetMaterial>();
+                        if (entry.file->size < sizeof(ee_assets::AssetMaterial))
                             LOG(CRITICAL, "File size is less than needed for material");
-                        std::memcpy(material, entry.file->data, sizeof(AssetMaterial));
+                        std::memcpy(material, entry.file->data, sizeof(ee_assets::AssetMaterial));
                         materialsStorage.push_back(material);
                         Redirect(entry.handle, materialsStorage.back());
                         break;
@@ -211,7 +211,7 @@ void AssetManager::Loop()
                     case AssetInfo::BINARY:
                     default:
                     {
-                        AssetBinary* data = Allocate<AssetBinary>(entry.file->data, entry.file->size);
+                        ee_assets::AssetBinary* data = Allocate<ee_assets::AssetBinary>(entry.file->data, entry.file->size);
                         binaryStorage.push_back(data);
                         Redirect(entry.handle, binaryStorage.back());
                         break;
diff --git a/engine/src/Engine.cpp b/engine/src/Engine.cpp
index e76487d..683a2c9 100644
--- a/engine/src/Engine.cpp
+++ b/engine/src/Engine.cpp
@@ -2,7 +2,7 @@
 #include <ee_utils/allocator.hpp>
 
 AssetManager* Engine::assetManager;
-IRenderer* Engine::renderer;
+ee_engine::IRenderer* Engine::renderer;
 
 void Engine::Shutdown()
 {
diff --git a/engine/src/main.cpp b/engine/src/main.cpp
index 6e43d76..28f664d 100644
--- a/engine/src/main.cpp
+++ b/engine/src/main.cpp
@@ -44,22 +44,26 @@ int main(int argc, char **argv)
 	Engine::assetManager->LoadAsync(AssetInfo::MAP_MESH, "assets/map/states.map");
 
 	// Setup renderer TODO: builder
-	Engine::renderer = reinterpret_cast<IRenderer*>(Allocate<MagnumRenderer>(window));
+	Engine::renderer = reinterpret_cast<ee_engine::IRenderer*>(Allocate<ee_magnum::MagnumRenderer>(window));
 	
-	AssetMapMesh &states = Engine::assetManager->FindOnce<AssetMapMesh>("assets/map/states.map");
+	ee_assets::AssetMapMesh &states = Engine::assetManager->FindOnce<ee_assets::AssetMapMesh>("assets/map/states.map");
 	Engine::renderer->RegisterMapMesh(&states.content);
 	
 	//TODO: ShaderRefs builder from set of AssetMaterial
-	AssetMaterial &provincesMaterial = Engine::assetManager->FindOnce<AssetMaterial>("assets/materials/provinces.mat");
-	AssetShader &vertProv = Engine::assetManager->FindOnce<AssetShader>(provincesMaterial.vertexShaderAssetID);
-	AssetShader &fragProv = Engine::assetManager->FindOnce<AssetShader>(provincesMaterial.fragmentShaderAssetID);
+	ee_assets::AssetMaterial &provincesMaterial =
+		Engine::assetManager->FindOnce<ee_assets::AssetMaterial>("assets/materials/provinces.mat");
+	ee_assets::AssetShader &vertProv = Engine::assetManager->FindOnce<ee_assets::AssetShader>(provincesMaterial.vertexShaderAssetID);
+	ee_assets::AssetShader &fragProv = Engine::assetManager->FindOnce<ee_assets::AssetShader>(provincesMaterial.fragmentShaderAssetID);
 	Engine::renderer->RegisterMaterials({
 		.vertProvinces = &vertProv,
 		.fragProvinces = &fragProv
 	});
 	
 	Engine::renderer->Init();
-	Engine::renderer->SetCamera({.zoom = 100.0f});
+	Engine::renderer->SetCamera({
+		.position = {1000.0f, 1000.0f},
+		.zoom = 2000.0f
+	});
 	
 	glfwSetFramebufferSizeCallback(window, [](GLFWwindow *window, int width, int height) {
 		Engine::renderer->ResizeWindow(width, height);
diff --git a/renderers/magnum-renderer/include/ee_magnum/Materials.hpp b/renderers/magnum-renderer/include/ee_magnum/Materials.hpp
index 95c37a3..004531c 100644
--- a/renderers/magnum-renderer/include/ee_magnum/Materials.hpp
+++ b/renderers/magnum-renderer/include/ee_magnum/Materials.hpp
@@ -17,19 +17,23 @@
 
 using namespace Magnum;
 
-class BaseMaterial : public GL::AbstractShaderProgram
+namespace ee_magnum
 {
-public:
-    void setModelViewProjection(const Matrix4 &m, const Matrix4 &vp);
-
-protected:
-    explicit BaseMaterial(const std::string &vertSrc, const std::string &fragSrc);
-};
-
-class ProvinceMaterial : public BaseMaterial
-{
-public:
-    explicit ProvinceMaterial(const std::string &vertSrc, const std::string &fragSrc);
+    class BaseMaterial : public GL::AbstractShaderProgram
+    {
+    public:
+        void setModel(const Matrix4 &model);
+        void setViewProjection(const Matrix4 &vewProjection);
     
-    void setId(const uint32_t &id);
-};
\ No newline at end of file
+    protected:
+        explicit BaseMaterial(const std::string &vertSrc, const std::string &fragSrc);
+    };
+    
+    class ProvinceMaterial : public BaseMaterial
+    {
+    public:
+        explicit ProvinceMaterial(const std::string &vertSrc, const std::string &fragSrc);
+        
+        void setId(const uint32_t &id);
+    };
+}
\ No newline at end of file
diff --git a/renderers/magnum-renderer/include/ee_magnum/Renderer.hpp b/renderers/magnum-renderer/include/ee_magnum/Renderer.hpp
index 7597b3a..d48a14f 100644
--- a/renderers/magnum-renderer/include/ee_magnum/Renderer.hpp
+++ b/renderers/magnum-renderer/include/ee_magnum/Renderer.hpp
@@ -13,33 +13,35 @@
 
 using namespace Magnum;
 
-class MagnumRenderer : public IRenderer
+namespace ee_magnum
 {
-public:
-    MagnumRenderer(GLFWwindow *window);
-    ~MagnumRenderer();
+    class MagnumRenderer : public ee_engine::IRenderer
+    {
+    public:
+        MagnumRenderer(GLFWwindow *window);
+        ~MagnumRenderer();
+        
+        void Init() override;
+        void Shutdown() override;
     
-    void Init() override;
-    void Shutdown() override;
-
-protected:
-    void Clear() override;
-    void DrawMap() override;
-    void DrawUI() override;
-
-    void ApplyCamera() override;
-    void ApplyMapTransform() override;
-
-private:
-    Platform::GLContext context;
-
-    std::vector<GL::Mesh> provinceMeshes;
-    GL::Buffer provinceSSBO;
-    ProvinceMaterial *provinceMaterial;
-
-    void ValidateSupport();
-    void LoadShaders();
-    void LoadProvinces();
-
-    void ApplyMapMVP();
-};
\ No newline at end of file
+    protected:
+        void Clear() override;
+        void DrawMap() override;
+        void DrawUI() override;
+    
+        void ApplyCamera() override;
+    
+    private:
+        Platform::GLContext context;
+    
+        std::vector<GL::Mesh> provinceMeshes;
+        GL::Buffer provinceSSBO;
+        ProvinceMaterial *provinceMaterial;
+    
+        void ValidateSupport();
+        void LoadShaders();
+        void LoadProvinces();
+    
+        void ApplyMapMVP();
+    };
+}
\ No newline at end of file
diff --git a/renderers/magnum-renderer/src/Materials.cpp b/renderers/magnum-renderer/src/Materials.cpp
index d5b50b3..b4cb02f 100644
--- a/renderers/magnum-renderer/src/Materials.cpp
+++ b/renderers/magnum-renderer/src/Materials.cpp
@@ -1,7 +1,7 @@
 #include <ee_magnum/Materials.hpp>
 #include "Logger.h"
 
-BaseMaterial::BaseMaterial(const std::string &vertSrc, const std::string &fragSrc)
+ee_magnum::BaseMaterial::BaseMaterial(const std::string &vertSrc, const std::string &fragSrc)
 {
     GL::Shader vert {GL::Version::GL430, GL::Shader::Type::Vertex};
     GL::Shader frag {GL::Version::GL430, GL::Shader::Type::Fragment};
@@ -20,18 +20,22 @@ BaseMaterial::BaseMaterial(const std::string &vertSrc, const std::string &fragSr
     link();
 }
 
-void BaseMaterial::setModelViewProjection(const Matrix4 &m, const Matrix4 &vp)
+void ee_magnum::BaseMaterial::setModel(const Matrix4 &m)
 {
     setUniform(TRANSFORM_UNIFORM, m);
+}
+
+void ee_magnum::BaseMaterial::setViewProjection(const Matrix4 &vp)
+{
     setUniform(CAMERA_UNIFORM, vp);
 }
 
-ProvinceMaterial::ProvinceMaterial(const std::string &vertSrc, const std::string &fragSrc): BaseMaterial(vertSrc, fragSrc)
+ee_magnum::ProvinceMaterial::ProvinceMaterial(const std::string &vertSrc, const std::string &fragSrc): BaseMaterial(vertSrc, fragSrc)
 {
 
 }
 
-void ProvinceMaterial::setId(const uint32_t &id)
+void ee_magnum::ProvinceMaterial::setId(const uint32_t &id)
 {
     setUniform(PROVINCES_ID_UNIFORM, id);
 }
\ No newline at end of file
diff --git a/renderers/magnum-renderer/src/Renderer.cpp b/renderers/magnum-renderer/src/Renderer.cpp
index 61c8f1d..8648b86 100644
--- a/renderers/magnum-renderer/src/Renderer.cpp
+++ b/renderers/magnum-renderer/src/Renderer.cpp
@@ -14,14 +14,14 @@
 
 using namespace Math::Literals;
 
-MagnumRenderer::MagnumRenderer(GLFWwindow *window) : IRenderer(window)
+ee_magnum::MagnumRenderer::MagnumRenderer(GLFWwindow *window) : IRenderer(window)
 {
     ValidateSupport(); 
 
     LOG(INFO, "Renderer created");   
 }
 
-void MagnumRenderer::Init()
+void ee_magnum::MagnumRenderer::Init()
 {
     LOG(INFO, "GLSL version: %d", GL::Context::current().version());
 
@@ -31,12 +31,12 @@ void MagnumRenderer::Init()
     LOG(INFO, "Renderer initialized");
 }
 
-void MagnumRenderer::Clear()
+void ee_magnum::MagnumRenderer::Clear()
 {
     GL::defaultFramebuffer.clear(GL::FramebufferClear::Color);
 }
 
-void MagnumRenderer::DrawMap()
+void ee_magnum::MagnumRenderer::DrawMap()
 {
     ApplyCamera();
     for (uint32_t i = 0; i < provinceMeshes.size(); i++)
@@ -46,39 +46,25 @@ void MagnumRenderer::DrawMap()
     }
 }
 
-void MagnumRenderer::DrawUI()
+void ee_magnum::MagnumRenderer::DrawUI()
 {
     
 }
 
-void MagnumRenderer::ValidateSupport()
+void ee_magnum::MagnumRenderer::ValidateSupport()
 {
     
 }
 
-void MagnumRenderer::ApplyCamera()
-{
-    ApplyMapMVP();
-}
-
-void MagnumRenderer::ApplyMapTransform()
-{
-    ApplyMapMVP();
-}
-
-void MagnumRenderer::ApplyMapMVP()
+void ee_magnum::MagnumRenderer::ApplyCamera()
 {
     Matrix4 viewProjection {Magnum::NoInit};
     std::memcpy(viewProjection.data(), glm::value_ptr(this->viewProjection), sizeof(float) * 16);
 
-    Matrix4 mapModel {Magnum::NoInit};
-    std::memcpy(mapModel.data(), glm::value_ptr(this->mapModel), sizeof(float) * 16);
-
-
-    provinceMaterial->setModelViewProjection(mapModel, viewProjection);
+    provinceMaterial->setViewProjection(viewProjection);
 }
 
-void MagnumRenderer::LoadShaders()
+void ee_magnum::MagnumRenderer::LoadShaders()
 {
     provinceMaterial = Allocate<ProvinceMaterial>(std::string(
         reinterpret_cast<const char*>(shaders.vertProvinces->content), 
@@ -91,12 +77,12 @@ void MagnumRenderer::LoadShaders()
     LOG(INFO, "Shaders loaded");
 }
 
-void MagnumRenderer::LoadProvinces()
+void ee_magnum::MagnumRenderer::LoadProvinces()
 {
-    std::vector<ProvinceSSBO> provincesData;
+    std::vector<ee_engine::ProvinceSSBO> provincesData;
     for (auto& [state, provs]: mapMesh->states)
     {
-        for (MapMesh::Province &province: provs)
+        for (ee_engine::MapMesh::Province &province: provs)
         {
             GL::Mesh stateMesh;
 
@@ -107,7 +93,7 @@ void MagnumRenderer::LoadProvinces()
 
             provinceMeshes.push_back(std::move(stateMesh));
 
-            ProvinceSSBO data {
+            ee_engine::ProvinceSSBO data {
                 .stateId = state,
                 .color = state
             };
@@ -124,7 +110,7 @@ void MagnumRenderer::LoadProvinces()
 
 }
 
-void MagnumRenderer::Shutdown()
+void ee_magnum::MagnumRenderer::Shutdown()
 {
     provinceMeshes.clear();
     provinceSSBO = GL::Buffer{NoCreate};
@@ -133,7 +119,7 @@ void MagnumRenderer::Shutdown()
     provinceMaterial = nullptr;
 }
 
-MagnumRenderer::~MagnumRenderer()
+ee_magnum::MagnumRenderer::~MagnumRenderer()
 {
     
 }
\ No newline at end of file
diff --git a/sdk/map/__states.bmp b/sdk/map/__states.bmp
new file mode 100644
index 0000000..2f210e3
Binary files /dev/null and b/sdk/map/__states.bmp differ
diff --git a/sdk/map/states.bmp b/sdk/map/states.bmp
index 2f210e3..08feca0 100644
Binary files a/sdk/map/states.bmp and b/sdk/map/states.bmp differ
diff --git a/utils/include/ee_utils/buffers.hpp b/utils/include/ee_utils/buffers.hpp
index aead816..3e9dd7a 100644
--- a/utils/include/ee_utils/buffers.hpp
+++ b/utils/include/ee_utils/buffers.hpp
@@ -1,4 +1,7 @@
 #pragma once
 #include <cstdint>
 
-bool readNext(void* dist, uint8_t* &srcPointer, size_t &srcLeftoverSize, const size_t &readSize);
\ No newline at end of file
+namespace ee_utils
+{
+    bool readNext(void* dist, uint8_t* &srcPointer, size_t &srcLeftoverSize, const size_t &readSize);
+}
\ No newline at end of file
diff --git a/utils/src/buffers.cpp b/utils/src/buffers.cpp
index 02beceb..adb564b 100644
--- a/utils/src/buffers.cpp
+++ b/utils/src/buffers.cpp
@@ -1,7 +1,7 @@
 #include <ee_utils/buffers.hpp>
 #include <cstring>
 
-bool readNext(void* dist, uint8_t* &srcPointer, size_t &srcLeftoverSize, const size_t &readSize)
+bool ee_utils::readNext(void* dist, uint8_t* &srcPointer, size_t &srcLeftoverSize, const size_t &readSize)
 {
     if (srcLeftoverSize >= readSize)
     {