NDT/EtrediaEmpires
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

namespaces refactor

Browse Source
This commit is contained in:
legatt 2026-01-24 19:22:19 +03:00
parent 6bcea3087a
commit 83f947ce1f
19 changed files with 219 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
assets/map/states.map
View File

Binary file not shown.

5
engine-api/include/ee_engine_api/AssetData.hpp
View File

@ -3,6 +3,8 @@
#include <concepts> #include <concepts>
#include <cstdint> #include <cstdint>
namespace ee_assets
{
struct AssetData {}; struct AssetData {};
template<typename T> concept Asset = std::derived_from<T, AssetData>; template<typename T> concept Asset = std::derived_from<T, AssetData>;
@ -17,7 +19,7 @@ struct AssetBinary : AssetData
struct AssetMapMesh : AssetData struct AssetMapMesh : AssetData
{ {
MapMesh content; ee_engine::MapMesh content;
AssetMapMesh(uint8_t* &source, const size_t &sourceSize); AssetMapMesh(uint8_t* &source, const size_t &sourceSize);
}; };
@ -29,3 +31,4 @@ struct AssetMaterial : AssetData
uint32_t vertexShaderAssetID; uint32_t vertexShaderAssetID;
uint32_t fragmentShaderAssetID; uint32_t fragmentShaderAssetID;
}; };
}

3
engine-api/include/ee_engine_api/Map.hpp
View File

@ -4,6 +4,8 @@
#include <unordered_map> #include <unordered_map>
#include <glm/glm.hpp> #include <glm/glm.hpp>
namespace ee_engine
{
struct MapMesh struct MapMesh
{ {
struct Province struct Province
@ -19,3 +21,4 @@ struct ProvinceSSBO
uint32_t stateId; uint32_t stateId;
uint32_t color; uint32_t color;
}; };
}

11
engine-api/include/ee_engine_api/RenderInterface.hpp
View File

@ -3,10 +3,12 @@
#include "Map.hpp" #include "Map.hpp"
#include "AssetData.hpp" #include "AssetData.hpp"
namespace ee_engine
{
struct ShaderRefs struct ShaderRefs
{ {
AssetShader *vertProvinces; ee_assets::AssetShader *vertProvinces;
AssetShader *fragProvinces; ee_assets::AssetShader *fragProvinces;
}; };
struct CameraTransform struct CameraTransform
@ -36,14 +38,11 @@ public:
virtual void ResizeWindow(int width, int height); virtual void ResizeWindow(int width, int height);
void SetCamera(const CameraTransform &camera); void SetCamera(const CameraTransform &camera);
void SetMapTransform(const MeshTransform &mapTransform);
protected: protected:
int screenWidth, screenHeight; int screenWidth, screenHeight;
float screenAspect; float screenAspect;
CameraTransform camera; CameraTransform camera;
MeshTransform mapTransform;
glm::mat4 mapModel;
glm::mat4 viewProjection; glm::mat4 viewProjection;
GLFWwindow *window; GLFWwindow *window;
@ -57,5 +56,5 @@ protected:
virtual void DrawUI() = 0; virtual void DrawUI() = 0;
virtual void ApplyCamera() = 0; virtual void ApplyCamera() = 0;
virtual void ApplyMapTransform() = 0;
}; };
}

22
engine-api/src/AssetData.cpp
View File

@ -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; content = source;
size = sourceSize; size = sourceSize;
source = nullptr; source = nullptr;
} }
AssetBinary::~AssetBinary() ee_assets::AssetBinary::~AssetBinary()
{ {
if (content != nullptr) if (content != nullptr)
DeallocateArray(content); 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* buffer = source;
uint8_t* pointer = source; uint8_t* pointer = source;
@ -34,48 +34,48 @@ AssetMapMesh::AssetMapMesh(uint8_t* &source, const size_t &sourceSize)
source = nullptr; source = nullptr;
uint32_t statesCount = 0; 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++) for (uint32_t state = 0; state < statesCount; state++)
{ {
uint32_t id = 0; uint32_t id = 0;
glm::u8vec3 color {}; glm::u8vec3 color {};
if (!readNext(&color, pointer, leftoverSize, sizeof(glm::u8vec3))) if (!ee_utils::readNext(&color, pointer, leftoverSize, sizeof(glm::u8vec3)))
break; break;
id = static_cast<uint32_t>(color.r) << 16 | id = static_cast<uint32_t>(color.r) << 16 |
static_cast<uint32_t>(color.g) << 8 | static_cast<uint32_t>(color.g) << 8 |
static_cast<uint32_t>(color.b); static_cast<uint32_t>(color.b);
uint32_t provincesCount = 0; 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++) for (uint32_t pi = 0; pi < provincesCount; pi++)
{ {
MapMesh::Province prov; ee_engine::MapMesh::Province prov;
uint32_t verticesCount = 0; uint32_t verticesCount = 0;
if (!readNext(&verticesCount, pointer, leftoverSize, sizeof(uint32_t))) if (!ee_utils::readNext(&verticesCount, pointer, leftoverSize, sizeof(uint32_t)))
break; break;
prov.vertices.reserve(verticesCount); prov.vertices.reserve(verticesCount);
for (uint32_t vi = 0; vi < verticesCount; vi++) for (uint32_t vi = 0; vi < verticesCount; vi++)
{ {
glm::vec2 vertex; glm::vec2 vertex;
if (!readNext(&vertex, pointer, leftoverSize, sizeof(glm::vec2))) if (!ee_utils::readNext(&vertex, pointer, leftoverSize, sizeof(glm::vec2)))
break; break;
prov.vertices.push_back(vertex); prov.vertices.push_back(vertex);
} }
uint32_t indicesCount = 0; uint32_t indicesCount = 0;
if (!readNext(&indicesCount, pointer, leftoverSize, sizeof(uint32_t))) if (!ee_utils::readNext(&indicesCount, pointer, leftoverSize, sizeof(uint32_t)))
break; break;
prov.indices.reserve(indicesCount); prov.indices.reserve(indicesCount);
for(uint32_t ii = 0; ii < indicesCount; ii++) for(uint32_t ii = 0; ii < indicesCount; ii++)
{ {
uint16_t index = 0; uint16_t index = 0;
if (!readNext(&index, pointer, leftoverSize, sizeof(uint16_t))) if (!ee_utils::readNext(&index, pointer, leftoverSize, sizeof(uint16_t)))
break; break;
prov.indices.push_back(index); prov.indices.push_back(index);

26
engine-api/src/RenderInterface.cpp
View File

@ -3,43 +3,43 @@
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include "Logger.h" #include "Logger.h"
IRenderer::IRenderer(GLFWwindow *window) ee_engine::IRenderer::IRenderer(GLFWwindow *window)
{ {
this->window = window; this->window = window;
glfwGetFramebufferSize(window, &screenWidth, &screenHeight); glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
screenAspect = static_cast<float>(screenWidth) / static_cast<float>(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; this->shaders = shaders;
} }
void IRenderer::RegisterMapMesh(MapMesh* mapMesh) void ee_engine::IRenderer::RegisterMapMesh(MapMesh* mapMesh)
{ {
this->mapMesh = mapMesh; this->mapMesh = mapMesh;
} }
void IRenderer::Draw() void ee_engine::IRenderer::Draw()
{ {
Clear(); Clear();
DrawMap(); DrawMap();
DrawUI(); DrawUI();
} }
void IRenderer::ResizeWindow(int width, int height) void ee_engine::IRenderer::ResizeWindow(int width, int height)
{ {
screenWidth = width; screenWidth = width;
screenHeight = height; screenHeight = height;
screenAspect = static_cast<float>(screenWidth) / static_cast<float>(screenHeight); 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) if (camera.zoom <= 0)
{ {
@ -66,15 +66,3 @@ void IRenderer::SetCamera(const CameraTransform &camera)
ApplyCamera(); 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();
}

24
engine/include/AssetManager.hpp
View File

@ -92,10 +92,10 @@ public:
void LoadAsync(AssetInfo::Type type, const std::filesystem::path &path); void LoadAsync(AssetInfo::Type type, const std::filesystem::path &path);
AssetHandle& Find(const std::filesystem::path &path); AssetHandle& Find(const std::filesystem::path &path);
AssetHandle& Find(const uint32_t &id); AssetHandle& Find(const uint32_t &id);
template <Asset T> T& FindOnce(const std::filesystem::path &path); template <ee_assets::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 uint32_t &id);
void Redirect(AssetHandle &handle, void *resource); 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); void Free(AssetHandle &handle);
private: private:
@ -111,10 +111,10 @@ private:
std::vector<size_t> freeAssetSlots; std::vector<size_t> freeAssetSlots;
std::vector<AssetLoadingEntry> loadingEntries; std::vector<AssetLoadingEntry> loadingEntries;
std::vector<AssetBinary*> binaryStorage; std::vector<ee_assets::AssetBinary*> binaryStorage;
std::vector<AssetMapMesh*> mapMeshesStorage; std::vector<ee_assets::AssetMapMesh*> mapMeshesStorage;
std::vector<AssetShader*> shadersStorage; std::vector<ee_assets::AssetShader*> shadersStorage;
std::vector<AssetMaterial*> materialsStorage; std::vector<ee_assets::AssetMaterial*> materialsStorage;
void Threading(); void Threading();
void Request(const AssetStreamCommand &command); void Request(const AssetStreamCommand &command);
@ -123,10 +123,10 @@ private:
void ProcessCommand(AssetStreamCommand &command); void ProcessCommand(AssetStreamCommand &command);
void Release(); 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; std::atomic<void*> result;
AssetStreamCommand command { AssetStreamCommand command {
@ -139,17 +139,17 @@ template <Asset T> T& AssetManager::Get(const AssetHandle &handle)
return *reinterpret_cast<T*>(command.out->load()); 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)); 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)); 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) for (T* &resource : storage)
{ {

2
engine/include/Engine.hpp
View File

@ -8,7 +8,7 @@ class Engine
{ {
public: public:
static AssetManager *assetManager; static AssetManager *assetManager;
static IRenderer *renderer; static ee_engine::IRenderer *renderer;
static void Shutdown(); static void Shutdown();

12
engine/src/AssetManager.cpp
View File

@ -177,7 +177,7 @@ void AssetManager::Loop()
{ {
case AssetInfo::MAP_MESH: 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); mapMeshesStorage.push_back(mesh);
Redirect(entry.handle, mapMeshesStorage.back()); Redirect(entry.handle, mapMeshesStorage.back());
break; break;
@ -186,7 +186,7 @@ void AssetManager::Loop()
case AssetInfo::SHADER: 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); shadersStorage.push_back(shader);
Redirect(entry.handle, shadersStorage.back()); Redirect(entry.handle, shadersStorage.back());
break; break;
@ -194,10 +194,10 @@ void AssetManager::Loop()
case AssetInfo::MATERIAL: case AssetInfo::MATERIAL:
{ {
AssetMaterial* material = Allocate<AssetMaterial>(); ee_assets::AssetMaterial* material = Allocate<ee_assets::AssetMaterial>();
if (entry.file->size < sizeof(AssetMaterial)) if (entry.file->size < sizeof(ee_assets::AssetMaterial))
LOG(CRITICAL, "File size is less than needed for material"); 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); materialsStorage.push_back(material);
Redirect(entry.handle, materialsStorage.back()); Redirect(entry.handle, materialsStorage.back());
break; break;
@ -211,7 +211,7 @@ void AssetManager::Loop()
case AssetInfo::BINARY: case AssetInfo::BINARY:
default: 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); binaryStorage.push_back(data);
Redirect(entry.handle, binaryStorage.back()); Redirect(entry.handle, binaryStorage.back());
break; break;

2
engine/src/Engine.cpp
View File

@ -2,7 +2,7 @@
#include <ee_utils/allocator.hpp> #include <ee_utils/allocator.hpp>
AssetManager* Engine::assetManager; AssetManager* Engine::assetManager;
IRenderer* Engine::renderer; ee_engine::IRenderer* Engine::renderer;
void Engine::Shutdown() void Engine::Shutdown()
{ {

16
engine/src/main.cpp
View File

@ -44,22 +44,26 @@ int main(int argc, char **argv)
Engine::assetManager->LoadAsync(AssetInfo::MAP_MESH, "assets/map/states.map"); Engine::assetManager->LoadAsync(AssetInfo::MAP_MESH, "assets/map/states.map");
// Setup renderer TODO: builder // 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); Engine::renderer->RegisterMapMesh(&states.content);
//TODO: ShaderRefs builder from set of AssetMaterial //TODO: ShaderRefs builder from set of AssetMaterial
AssetMaterial &provincesMaterial = Engine::assetManager->FindOnce<AssetMaterial>("assets/materials/provinces.mat"); ee_assets::AssetMaterial &provincesMaterial =
AssetShader &vertProv = Engine::assetManager->FindOnce<AssetShader>(provincesMaterial.vertexShaderAssetID); Engine::assetManager->FindOnce<ee_assets::AssetMaterial>("assets/materials/provinces.mat");
AssetShader &fragProv = Engine::assetManager->FindOnce<AssetShader>(provincesMaterial.fragmentShaderAssetID); 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({ Engine::renderer->RegisterMaterials({
.vertProvinces = &vertProv, .vertProvinces = &vertProv,
.fragProvinces = &fragProv .fragProvinces = &fragProv
}); });
Engine::renderer->Init(); 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) { glfwSetFramebufferSizeCallback(window, [](GLFWwindow *window, int width, int height) {
Engine::renderer->ResizeWindow(width, height); Engine::renderer->ResizeWindow(width, height);

6
renderers/magnum-renderer/include/ee_magnum/Materials.hpp
View File

@ -17,10 +17,13 @@
using namespace Magnum; using namespace Magnum;
namespace ee_magnum
{
class BaseMaterial : public GL::AbstractShaderProgram class BaseMaterial : public GL::AbstractShaderProgram
{ {
public: public:
void setModelViewProjection(const Matrix4 &m, const Matrix4 &vp); void setModel(const Matrix4 &model);
void setViewProjection(const Matrix4 &vewProjection);
protected: protected:
explicit BaseMaterial(const std::string &vertSrc, const std::string &fragSrc); explicit BaseMaterial(const std::string &vertSrc, const std::string &fragSrc);
@ -33,3 +36,4 @@ public:
void setId(const uint32_t &id); void setId(const uint32_t &id);
}; };
}

6
renderers/magnum-renderer/include/ee_magnum/Renderer.hpp
View File

@ -13,7 +13,9 @@
using namespace Magnum; using namespace Magnum;
class MagnumRenderer : public IRenderer namespace ee_magnum
{
class MagnumRenderer : public ee_engine::IRenderer
{ {
public: public:
MagnumRenderer(GLFWwindow *window); MagnumRenderer(GLFWwindow *window);
@ -28,7 +30,6 @@ protected:
void DrawUI() override; void DrawUI() override;
void ApplyCamera() override; void ApplyCamera() override;
void ApplyMapTransform() override;
private: private:
Platform::GLContext context; Platform::GLContext context;
@ -43,3 +44,4 @@ private:
void ApplyMapMVP(); void ApplyMapMVP();
}; };
}

12
renderers/magnum-renderer/src/Materials.cpp
View File

@ -1,7 +1,7 @@
#include <ee_magnum/Materials.hpp> #include <ee_magnum/Materials.hpp>
#include "Logger.h" #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 vert {GL::Version::GL430, GL::Shader::Type::Vertex};
GL::Shader frag {GL::Version::GL430, GL::Shader::Type::Fragment}; 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(); link();
} }
void BaseMaterial::setModelViewProjection(const Matrix4 &m, const Matrix4 &vp) void ee_magnum::BaseMaterial::setModel(const Matrix4 &m)
{ {
setUniform(TRANSFORM_UNIFORM, m); setUniform(TRANSFORM_UNIFORM, m);
}
void ee_magnum::BaseMaterial::setViewProjection(const Matrix4 &vp)
{
setUniform(CAMERA_UNIFORM, 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); setUniform(PROVINCES_ID_UNIFORM, id);
} }

44
renderers/magnum-renderer/src/Renderer.cpp
View File

@ -14,14 +14,14 @@
using namespace Math::Literals; using namespace Math::Literals;
MagnumRenderer::MagnumRenderer(GLFWwindow *window) : IRenderer(window) ee_magnum::MagnumRenderer::MagnumRenderer(GLFWwindow *window) : IRenderer(window)
{ {
ValidateSupport(); ValidateSupport();
LOG(INFO, "Renderer created"); LOG(INFO, "Renderer created");
} }
void MagnumRenderer::Init() void ee_magnum::MagnumRenderer::Init()
{ {
LOG(INFO, "GLSL version: %d", GL::Context::current().version()); LOG(INFO, "GLSL version: %d", GL::Context::current().version());
@ -31,12 +31,12 @@ void MagnumRenderer::Init()
LOG(INFO, "Renderer initialized"); LOG(INFO, "Renderer initialized");
} }
void MagnumRenderer::Clear() void ee_magnum::MagnumRenderer::Clear()
{ {
GL::defaultFramebuffer.clear(GL::FramebufferClear::Color); GL::defaultFramebuffer.clear(GL::FramebufferClear::Color);
} }
void MagnumRenderer::DrawMap() void ee_magnum::MagnumRenderer::DrawMap()
{ {
ApplyCamera(); ApplyCamera();
for (uint32_t i = 0; i < provinceMeshes.size(); i++) 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() void ee_magnum::MagnumRenderer::ApplyCamera()
{
ApplyMapMVP();
}
void MagnumRenderer::ApplyMapTransform()
{
ApplyMapMVP();
}
void MagnumRenderer::ApplyMapMVP()
{ {
Matrix4 viewProjection {Magnum::NoInit}; Matrix4 viewProjection {Magnum::NoInit};
std::memcpy(viewProjection.data(), glm::value_ptr(this->viewProjection), sizeof(float) * 16); std::memcpy(viewProjection.data(), glm::value_ptr(this->viewProjection), sizeof(float) * 16);
Matrix4 mapModel {Magnum::NoInit}; provinceMaterial->setViewProjection(viewProjection);
std::memcpy(mapModel.data(), glm::value_ptr(this->mapModel), sizeof(float) * 16);
provinceMaterial->setModelViewProjection(mapModel, viewProjection);
} }
void MagnumRenderer::LoadShaders() void ee_magnum::MagnumRenderer::LoadShaders()
{ {
provinceMaterial = Allocate<ProvinceMaterial>(std::string( provinceMaterial = Allocate<ProvinceMaterial>(std::string(
reinterpret_cast<const char*>(shaders.vertProvinces->content), reinterpret_cast<const char*>(shaders.vertProvinces->content),
@ -91,12 +77,12 @@ void MagnumRenderer::LoadShaders()
LOG(INFO, "Shaders loaded"); 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 (auto& [state, provs]: mapMesh->states)
{ {
for (MapMesh::Province &province: provs) for (ee_engine::MapMesh::Province &province: provs)
{ {
GL::Mesh stateMesh; GL::Mesh stateMesh;
@ -107,7 +93,7 @@ void MagnumRenderer::LoadProvinces()
provinceMeshes.push_back(std::move(stateMesh)); provinceMeshes.push_back(std::move(stateMesh));
ProvinceSSBO data { ee_engine::ProvinceSSBO data {
.stateId = state, .stateId = state,
.color = state .color = state
}; };
@ -124,7 +110,7 @@ void MagnumRenderer::LoadProvinces()
} }
void MagnumRenderer::Shutdown() void ee_magnum::MagnumRenderer::Shutdown()
{ {
provinceMeshes.clear(); provinceMeshes.clear();
provinceSSBO = GL::Buffer{NoCreate}; provinceSSBO = GL::Buffer{NoCreate};
@ -133,7 +119,7 @@ void MagnumRenderer::Shutdown()
provinceMaterial = nullptr; provinceMaterial = nullptr;
} }
MagnumRenderer::~MagnumRenderer() ee_magnum::MagnumRenderer::~MagnumRenderer()
{ {
} }

BIN
sdk/map/__states.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 29 KiB

BIN
sdk/map/states.bmp
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 29 KiB

After

Width:  |  Height:  |  Size: 33 MiB

3
utils/include/ee_utils/buffers.hpp
View File

@ -1,4 +1,7 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
namespace ee_utils
{
bool readNext(void* dist, uint8_t* &srcPointer, size_t &srcLeftoverSize, const size_t &readSize); bool readNext(void* dist, uint8_t* &srcPointer, size_t &srcLeftoverSize, const size_t &readSize);
}

2
utils/src/buffers.cpp
View File

@ -1,7 +1,7 @@
#include <ee_utils/buffers.hpp> #include <ee_utils/buffers.hpp>
#include <cstring> #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) if (srcLeftoverSize >= readSize)
{ {