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

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

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

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

@ -3,10 +3,12 @@
#include "Map.hpp"
#include "AssetData.hpp"
namespace ee_engine
{
struct ShaderRefs
{
AssetShader *vertProvinces;
AssetShader *fragProvinces;
ee_assets::AssetShader *vertProvinces;
ee_assets::AssetShader *fragProvinces;
};
struct CameraTransform
@ -36,14 +38,11 @@ public:
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;
@ -57,5 +56,5 @@ protected:
virtual void DrawUI() = 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;
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);

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

@ -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)
{
@ -66,15 +66,3 @@ void IRenderer::SetCamera(const CameraTransform &camera)
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);
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)
{

2
engine/include/Engine.hpp
View File

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

12
engine/src/AssetManager.cpp
View File

@ -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;

2
engine/src/Engine.cpp
View File

@ -2,7 +2,7 @@
#include <ee_utils/allocator.hpp>
AssetManager* Engine::assetManager;
IRenderer* Engine::renderer;
ee_engine::IRenderer* Engine::renderer;
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");
// 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);

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

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

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

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

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

@ -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);
}

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

@ -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()
{
}

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
#include <cstdint>
namespace ee_utils
{
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 <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)
{