tobid7/palladium
1
0
Fork 0
Code Issues 7 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Refactor PD::Li Pools system, Upgrade PD::Pool and add better logging

Browse Source 
- Add ResetFast to Pool using c++20 concept
- Add Put function to Pool
- Use Pool Index instead of pointers in Command
- Add accessor to Li Pools to prevent wrong command usage
- Add Command Formatter
- Use ResetFast for all Pools
- Add Reset func to Li::Vertex (for ResetFast)
- Add Pool Expandor and Put funcs to Lithium pools
- Add getters for GfxDriverBase to PD::Li Pools
This commit is contained in:
tobid7
2026-03-21 13:35:16 +01:00
parent 3b0b103eb3
commit a86c13b9a3
16 changed files with 247 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/pd/common.hpp
+42 -2
View File
@@ -23,6 +23,10 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#if defined(__GNUG__) && !defined(_MSC_VER)
#include <cxxabi.h>
#endif
#include <array>
#include <chrono>
#include <cmath>
@@ -39,6 +43,11 @@ SOFTWARE.
#include <vector>
namespace PD {
enum class LogLevel {
Info,
Warning,
Error,
};
[[noreturn]] inline void Throw(const std::string& msg) {
throw std::runtime_error(msg);
}
@@ -47,17 +56,48 @@ using u16 = unsigned short;
using u32 = unsigned int;
using u64 = unsigned long long;
using ptr = uintptr_t;
PD_API void Log(const std::string& txt);
PD_API void Log(const std::string& txt, LogLevel lvl = LogLevel::Info);
template <typename... Args>
void Log(std::format_string<Args...> fmt, Args&&... args) {
std::string msg = std::format(fmt, std::forward<Args>(args)...);
Log(msg);
Log(msg, LogLevel::Info);
}
template <typename... Args>
void Log(LogLevel lvl, std::format_string<Args...> fmt, Args&&... args) {
std::string msg = std::format(fmt, std::forward<Args>(args)...);
Log(msg, lvl);
}
template <typename T>
std::string TypeName() {
#if defined(__GNUG__) && !defined(_MSC_VER)
int res = 0;
std::unique_ptr<char, void (*)(void*)> up{
abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &res), std::free};
return (res == 0) ? up.get() : typeid(T).name();
#else
return typeid(T).name(); // no demangler available :/
#endif
}
} // namespace PD
#if defined(__GNUC__) || defined(__clang__)
#define PDPRETTYFUNC __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
#define PDPRETTYFUNC __FUNCSIG__
#else
#define PDPRETTYFUNC __FUNCTION__
#endif
#ifdef PD_DEBUG
#define PDLOG(fmt, ...) \
PD::Log("[{}:{}]: " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
#define PDWARN(fmt, ...) \
PD::Log(PD::LogLevel::Warning, "[{}:{}]: " fmt, __FILE__, __LINE__, \
##__VA_ARGS__)
#define PDERR(fmt, ...) \
PD::Log(PD::LogLevel::Error, "[{}:{}]: " fmt, __FILE__, __LINE__, \
##__VA_ARGS__)
#else
#define PDLOG(fmt, ...)
#define PDWARN(fmt, ...)
#define PDERR(fmt, ...)
#endif
include/pd/core/pool.hpp
+43 -3
View File
@@ -3,6 +3,11 @@
#include <memory>
#include <pd/common.hpp>
namespace PD {
// lets take use of c++ 20 concepts
// https://en.cppreference.com/w/cpp/language/constraints.html
template <typename T>
concept Resettable = requires(T& v) { v.Reset(); };
template <typename T, typename Alloc = std::allocator<T>>
class Pool {
public:
@@ -13,6 +18,9 @@ class Pool {
Pool() = default;
~Pool() {
if (pData) {
for (size_t i = 0; i < pCap; i++) {
std::allocator_traits<Alloc>::destroy(pAlloc, &pData[i]);
}
pAlloc.deallocate(pData, pCap);
pData = nullptr;
}
@@ -47,6 +55,11 @@ class Pool {
*e = elem;
}
void Put(size_t idx, const T& elem) {
if (idx >= pCap) ExpandIf(idx);
pData[idx] = elem;
}
void ExpandIf(size_t req) {
if ((pPos + req) <= pCap) return;
size_t ncap = std::max(pCap * 2, pPos + req);
@@ -56,11 +69,14 @@ class Pool {
std::allocator_traits<Alloc>::construct(
pAlloc, &nu[i], std::move_if_noexcept(pData[i]));
}
for (size_t i = 0; i < pCap; i++) {
std::allocator_traits<Alloc>::destroy(pAlloc, &pData[i]);
}
pAlloc.deallocate(pData, pCap);
}
for (size_t i = pPos; i < ncap; i++) {
std::allocator_traits<Alloc>::construct(pAlloc, &nu[i]);
}
std::allocator_traits<Alloc>::construct(pAlloc, &nu[i]);
}
PDLOG("Pool::ExpandIf({}): {} -> {}", req, pCap, ncap);
pData = nu;
pCap = ncap;
@@ -76,6 +92,21 @@ class Pool {
}
}
void ResetFast() {
if constexpr (Resettable<T>) {
for (size_t i = 0; i < pPos; i++) {
pData[i].Reset();
}
} else if constexpr (!std::is_trivially_destructible_v<T>) {
PDWARN(
"ResetFast should only be executed with a non destructible type or a "
"class/struct that has a Reset func! {} is not "
"trivially_destructible and has no reset func.",
TypeName<T>());
}
pPos = 0;
}
size_t size() const { return pPos; }
size_t capacity() const { return pCap; }
T& at(size_t idx) { return pData[idx]; }
@@ -89,7 +120,16 @@ class Pool {
const T& operator[](size_t idx) const { return at(idx); }
private:
Pool(size_t size) : pCap(size), pPos(0) { pData = pAlloc.allocate(size); }
Pool(size_t size) : pCap(size), pPos(0) {
pPos = 0;
pCap = size;
pData = pAlloc.allocate(size);
for (size_t i = 0; i < pCap; i++) {
std::allocator_traits<Alloc>::construct(pAlloc, &pData[i]);
}
PDLOG("Pool::Init({})", size);
}
size_t pCap = 0;
size_t pPos = 0;
Alloc pAlloc;
include/pd/drivers/gfx.hpp
+5 -4
View File
@@ -3,6 +3,7 @@
#include <pd/core/mat.hpp>
#include <pd/drivers/interface.hpp>
#include <pd/lithium/command.hpp>
#include <pd/lithium/pools.hpp>
#include <pd/lithium/texture.hpp>
using PDBackendFlags = PD::u32;
@@ -105,12 +106,12 @@ class GfxDriverBase : public GfxDriver {
auto pIdx = pIdxPool.Allocate(c.IndexCount);
auto pVtx = pVtxPool.Allocate(c.VertexCount);
for (size_t i = 0; i < c.IndexCount; i++) {
pIdx[i] = CurrentVertex + c.FirstIndex[i];
pIdx[i] = CurrentVertex + Li::GetIndex(c.FirstIndex + i);
}
CurrentIndex += c.IndexCount;
CurrentVertex += c.VertexCount;
for (size_t i = 0; i < c.VertexCount; i++) {
pVtx[i] = c.FirstVertex[i];
pVtx[i] = Li::GetVertex(c.FirstVertex + i);
}
index++;
}
@@ -124,8 +125,8 @@ class GfxDriverBase : public GfxDriver {
size_t GetVertexPoolSize() const { return pVtxPool.size(); }
size_t GetIndexPoolSize() const { return pIdxPool.size(); }
void ResetPools() override {
pVtxPool.Reset();
pIdxPool.Reset();
pVtxPool.ResetFast();
pIdxPool.ResetFast();
}
private:
include/pd/lithium/command.hpp
+31 -17
View File
@@ -13,44 +13,58 @@ class Command {
~Command() {}
void Reserve(size_t vtx, size_t idx) {
if (!FirstVertex)
FirstVertex = AllocateVertices(vtx);
else
AllocateVertices(vtx);
if (!FirstIndex)
FirstIndex = AllocateIndices(idx);
else
AllocateIndices(idx);
if (!FirstVertex) {
FirstVertex = AllocateVertices(vtx, (PD::ptr)this);
VertexCountMax = vtx;
} else {
ExpandVertices(vtx, (PD::ptr)this);
VertexCountMax += vtx;
}
if (!FirstIndex) {
FirstIndex = AllocateIndices(idx, (PD::ptr)this);
IndexCountMax = idx;
} else {
ExpandVertices(idx, (PD::ptr)this);
IndexCountMax += idx;
}
}
void Reset() {
Layer = 0;
Tex = 0;
FirstIndex = nullptr;
FirstVertex = nullptr;
FirstIndex = 0;
FirstVertex = 0;
IndexCount = 0;
VertexCount = 0;
VertexCountMax = 0;
IndexCountMax = 0;
}
Command& Add(const Vertex& vtx) {
FirstVertex[VertexCount++] = vtx;
if (VertexCount <= VertexCountMax)
PutVertex(FirstVertex + VertexCount++, vtx, (PD::ptr)this);
return *this;
}
Command& Add(u16 idx) {
FirstIndex[IndexCount++] = VertexCount + idx;
if (IndexCount <= IndexCountMax)
PutIndex(FirstIndex + IndexCount++, VertexCount + idx, (PD::ptr)this);
return *this;
}
Command& Add(u16 a, u16 b, u16 c) {
FirstIndex[IndexCount++] = VertexCount + a;
FirstIndex[IndexCount++] = VertexCount + b;
FirstIndex[IndexCount++] = VertexCount + c;
if (IndexCount + 3 <= IndexCountMax) {
size_t idx = FirstIndex + IndexCount;
PutIndex(idx + 0, VertexCount + a, (PD::ptr)this);
PutIndex(idx + 1, VertexCount + b, (PD::ptr)this);
PutIndex(idx + 2, VertexCount + c, (PD::ptr)this);
IndexCount += 3;
}
return *this;
}
int Layer = 0;
ptr Tex = 0;
Vertex* FirstVertex = nullptr;
u16* FirstIndex = nullptr;
size_t FirstVertex = 0;
size_t FirstIndex = 0;
size_t VertexCount = 0;
size_t IndexCount = 0;
// Todo: implement
include/pd/lithium/formatters.hpp
+14 -1
View File
@@ -1,6 +1,7 @@
#pragma once
#include <pd/lithium/atlas.hpp>
#include <pd/lithium/command.hpp>
#include <pd/lithium/rect.hpp>
#include <pd/lithium/texture.hpp>
#include <pd/lithium/vertex.hpp>
@@ -106,4 +107,16 @@ struct std::formatter<PD::Li::AtlasState> : std::formatter<std::string> {
}
return std::format_to(ctx.out(), "{}", ret);
}
};
};
template <>
struct std::formatter<PD::Li::Command> : std::formatter<std::string> {
constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
template <typename FormatContext>
auto format(const PD::Li::Command& value, FormatContext& ctx) const {
return std::format_to(ctx.out(), "[0x{:X}, 0x{:X}] [{}, {}] 0x{:X}",
(PD::ptr)value.FirstVertex, (PD::ptr)value.FirstIndex,
value.VertexCount, value.IndexCount, value.Tex);
}
};
include/pd/lithium/pools.hpp
+16 -2
View File
@@ -5,8 +5,22 @@
namespace PD {
namespace Li {
PD_API Vertex* AllocateVertices(size_t count);
PD_API u16* AllocateIndices(size_t count);
/**
* Allocate an amount of vertices
* returns the index of the first vertex
*/
PD_API size_t AllocateVertices(size_t count, PD::ptr accessor);
/**
* Allocate an amount of indices
* returns the index of the first elem
*/
PD_API size_t AllocateIndices(size_t count, PD::ptr accessor);
PD_API bool ExpandVertices(size_t count, PD::ptr accessor);
PD_API bool EcpandIndices(size_t count, PD::ptr accessor);
PD_API void PutVertex(size_t loc, const Vertex& vtx, PD::ptr accessor);
PD_API void PutIndex(size_t loc, u16 idx, PD::ptr accessor);
PD_API const Vertex& GetVertex(size_t loc);
PD_API const u16& GetIndex(size_t loc);
PD_API void ResetPools();
} // namespace Li
} // namespace PD
include/pd/lithium/vertex.hpp
+6
View File
@@ -11,6 +11,12 @@ class Vertex {
: pos(pos), uv(uv), color(color) {}
~Vertex() {}
void Reset() {
pos = fvec2(0.f);
uv = fvec2(0.f);
color = 0x00000000;
}
fvec2 pos;
fvec2 uv;
u32 color = 0x00000000;