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

- 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

include/pd/lithium/command.hpp

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

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

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

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