CMakeLists.txt

@@ -52,6 +52,7 @@ set(PD_SOURCES
     source/lithium/drawlist.cpp
     source/lithium/font.cpp
     source/lithium/math.cpp
+    source/lithium/pools.cpp
 
     # UI7
     source/ui7/io.cpp

include/pd/drivers/gfx.hpp

@@ -2,7 +2,8 @@
 
 #include <pd/core/mat.hpp>
 #include <pd/drivers/interface.hpp>
-#include <pd/lithium/command.hpp>
+#include <pd/lithium/drawlist.hpp>
+#include <pd/lithium/pools.hpp>
 #include <pd/lithium/texture.hpp>
 
 using PDGfxBackendFlags = PD::u32;
@@ -37,7 +38,7 @@ class PD_API GfxDriver : public DriverInterface {
     return Li::Texture();
   }
   virtual void DeleteTexture(const Li::Texture& tex) {}
-  virtual void Draw(const Pool<Li::Command>& commands) {}
+  virtual void Draw(const Li::Drawlist& commands) {}
   Li::Texture::Ptr GetWhiteTexture() { return &pWhite; }
   PDGfxBackendFlags GetFlags() { return Flags; }
 
@@ -110,28 +111,67 @@ class GfxDriverBase : public GfxDriver {
     pWhite = LoadTexture(img, 16, 16);
   }
 
-  void Draw(const Pool<Li::Command>& commands) override {
+  void Draw(const Li::Drawlist& dl) override {
+    const auto& commands = dl.Data();
+    if (commands.size() == 0) return;
     pCountCommands += commands.size();
-    size_t index = 0;
+
+    size_t vtotal = dl.GetNumVertices();
+    size_t itotal = dl.GetNumIndices();
+
+    size_t start_vtx = pVtxPool.size();
+    pVtxPool.Allocate(vtotal);
+    CurrentVertex += vtotal;
+
+    size_t start_idx = pIdxPool.size();
+    pIdxPool.Allocate(itotal);
+    CurrentIndex += itotal;
+
+    size_t current_vtx = start_vtx;
+    size_t current_idx = start_idx;
+
+    const auto& vpool = Li::GetVertexPool();
+    const auto& ipool = Li::GetIndexPool();
+    /** Build Pools */
+    for (size_t i = 0; i < commands.size(); i++) {
+      const auto& cmd = commands[i];
+      if (cmd.VertexCount > 0) {
+        std::memcpy(pVtxPool.begin() + current_vtx,
+                    vpool.begin() + cmd.FirstVertex,
+                    cmd.VertexCount * sizeof(Li::Vertex));
+      }
+      for (size_t idx = 0; idx < cmd.IndexCount; idx++) {
+        u16 local_idx = ipool[cmd.FirstIndex + idx];
+        pIdxPool[current_idx + idx] = static_cast<u16>(current_vtx + local_idx);
+      }
+      current_vtx += cmd.VertexCount;
+      current_idx += cmd.IndexCount;
+    }
+
     UploadPools();
+
+    size_t index = 0;
+    size_t ioff = start_idx;
+
     while (index < commands.size()) {
       CurrentTex = commands[index].Tex;
       CurrentTexIsSDF = commands[index].SDF;
       if (!CurrentTex) {
         CurrentTex = pWhite.GetID();
       }
-      size_t startidx = commands[index].FirstIndex;
       size_t num_indices = 0;
       while (index < commands.size() &&
              CurrentTexIsSDF == commands[index].SDF &&
              (CurrentTex == commands[index].Tex ||
-              (CurrentTex == pWhite.GetID() && commands[index].Tex == 0)) &&
+              (CurrentTex == pWhite.GetID() && commands[index].Tex == 0))) {
-             commands[index].FirstIndex == startidx + num_indices) {
         num_indices += commands[index].IndexCount;
         index++;
       }
-      Submit(num_indices, startidx);
+      if (num_indices > 0) {
-      pCountDrawcalls++;
+        Submit(num_indices, ioff);
+        ioff += num_indices;
+        pCountDrawcalls++;
+      }
     }
   }
 
@@ -211,9 +251,7 @@ class PD_API Gfx {
   static void SetViewPort(const ivec2& vp) { driver->SetViewPort(vp); }
   static void SetViewPort(int w, int h) { driver->SetViewPort(w, h); }
   static void Reset() { driver->Reset(); }
-  static void Draw(const Pool<Li::Command>& commands) {
+  static void Draw(const Li::Drawlist& dl) { driver->Draw(dl); }
-    driver->Draw(commands);
-  }
   static Li::Texture LoadTexture(const std::vector<PD::u8>& pixels, int w,
                                  int h,
                                  TextureFormat type = TextureFormat::RGBA32,

include/pd/lithium/lithium.hpp

@@ -4,4 +4,5 @@
 #include <pd/lithium/drawlist.hpp>
 #include <pd/lithium/font.hpp>
 #include <pd/lithium/math.hpp>
-#include <pd/lithium/vertex.hpp>
+#include <pd/lithium/pools.hpp>
+#include <pd/lithium/vertex.hpp>

include/pd/lithium/pools.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/vertex.hpp>
+
+namespace PD {
+namespace Li {
+PD_API PD::Pool<Vertex>& GetVertexPool();
+PD_API PD::Pool<u16>& GetIndexPool();
+PD_API void ResetPools();
+}  // namespace Li
+}  // namespace PD

source/lithium/command.cpp

@@ -1,23 +1,48 @@
 #include <pd/drivers/gfx.hpp>
 #include <pd/lithium/command.hpp>
+#include <pd/lithium/pools.hpp>
 
 namespace PD {
 namespace Li {
 
 void Command::Reserve(size_t vtx, size_t idx) {
+  auto& vpool = GetVertexPool();
+  auto& ipool = GetIndexPool();
   if (VertexCountMax == 0) {
-    FirstVertex = Gfx::AllocateVertices(vtx, (PD::ptr)this);
+    FirstVertex = vpool.size();
+    vpool.Allocate(vtx);
     VertexCountMax = vtx;
   } else {
-    Gfx::ExpandVertices(vtx, (PD::ptr)this);
+    if (vpool.size() == FirstVertex + VertexCountMax) {
-    VertexCountMax += vtx;
+      vpool.Allocate(vtx);
+      VertexCountMax += vtx;
+    } else {
+      size_t tmp = FirstVertex;
+      FirstVertex = vpool.size();
+      vpool.Allocate(VertexCountMax + vtx);
+      for (size_t i = 0; i < VertexCount; i++) {
+        vpool[FirstVertex + i] = vpool[tmp + i];
+      }
+      VertexCountMax += vtx;
+    }
   }
   if (IndexCountMax == 0) {
-    FirstIndex = Gfx::AllocateIndices(idx, (PD::ptr)this);
+    FirstIndex = ipool.size();
+    ipool.Allocate(idx);
     IndexCountMax = idx;
   } else {
-    Gfx::ExpandIndices(idx, (PD::ptr)this);
+    if (ipool.size() == FirstIndex + IndexCountMax) {
-    IndexCountMax += idx;
+      ipool.Allocate(idx);
+      IndexCountMax += idx;
+    } else {
+      size_t tmp = FirstIndex;
+      FirstIndex = ipool.size();
+      ipool.Allocate(IndexCountMax + idx);
+      for (size_t i = 0; i < IndexCount; i++) {
+        ipool[FirstIndex + i] = ipool[tmp + i];
+      }
+      IndexCountMax += idx;
+    }
   }
 }
 
@@ -34,22 +59,25 @@ void Command::Reset() {
 }
 
 Command& Command::Add(const Vertex& vtx) {
-  if (VertexCount <= VertexCountMax)
+  if (VertexCount < VertexCountMax) {
-    Gfx::PutVertex(FirstVertex + VertexCount++, vtx, (PD::ptr)this);
+    GetVertexPool()[FirstVertex + VertexCount++] = vtx;
+  }
   return *this;
 }
 Command& Command::Add(u16 idx) {
-  if (IndexCount <= IndexCountMax)
+  if (IndexCount < IndexCountMax) {
-    Gfx::PutIndex(FirstIndex + IndexCount++, FirstVertex + VertexCount + idx,
+    GetIndexPool()[FirstIndex + IndexCount++] =
-                  (PD::ptr)this);
+        static_cast<u16>(VertexCount + idx);
+  }
   return *this;
 }
 Command& Command::Add(u16 a, u16 b, u16 c) {
   if (IndexCount + 3 <= IndexCountMax) {
+    auto& ip = GetIndexPool();
     size_t idx = FirstIndex + IndexCount;
-    Gfx::PutIndex(idx + 0, FirstVertex + VertexCount + a, (PD::ptr)this);
+    ip[idx + 0] = static_cast<u16>(VertexCount + a);
-    Gfx::PutIndex(idx + 1, FirstVertex + VertexCount + b, (PD::ptr)this);
+    ip[idx + 1] = static_cast<u16>(VertexCount + b);
-    Gfx::PutIndex(idx + 2, FirstVertex + VertexCount + c, (PD::ptr)this);
+    ip[idx + 2] = static_cast<u16>(VertexCount + c);
     IndexCount += 3;
   }
   return *this;

source/lithium/drawlist.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <iostream>
 #include <pd/drivers/gfx.hpp>
 #include <pd/lithium/drawlist.hpp>
@@ -19,19 +20,26 @@ PD_API void Drawlist::Copy(Drawlist& other) {
   pCommands.AppendCopy(other.pCommands);
 }
 
-PD_API void Drawlist::Optimize() {}
+PD_API void Drawlist::Optimize() {
+  if (pCommands.size() <= 1) return;
+  std::stable_sort(pCommands.begin(), pCommands.end(),
+                   [](const Command& a, const Command& b) {
+                     if (a.Layer != b.Layer) return a.Layer < b.Layer;
+                     if (a.SDF != b.SDF) return a.SDF < b.SDF;
+                     return a.Tex < b.Tex;
+                   });
+}
 
 PD_API void Drawlist::Clear() {
   UnbindTexture();
   pPath.ResetFast();
-  pVertices.ResetFast();
+  pCommands.NoReset();
-  pIndices.ResetFast();
-  pCommands.ResetFast();
 }
 
 /** Command Allocation */
 PD_API Command& Drawlist::NewCommand() {
   auto cmd = pCommands.Allocate(1);
+  cmd->Reset();
   cmd->Tex = pCurrentTexture.GetID();
   return *cmd;
 }

source/lithium/pools.cpp

@@ -0,0 +1,16 @@
+#include <pd/lithium/pools.hpp>
+
+namespace PD {
+namespace Li {
+static PD::Pool<Vertex> gVertexPool;
+static PD::Pool<u16> gIndexPool;
+
+PD_API PD::Pool<Vertex>& GetVertexPool() { return gVertexPool; }
+PD_API PD::Pool<u16>& GetIndexPool() { return gIndexPool; }
+
+PD_API void ResetPools() {
+  gVertexPool.NoReset();
+  gIndexPool.NoReset();
+}
+}  // namespace Li
+}  // namespace PD

tests/gfx/source/main.cpp

@@ -217,6 +217,7 @@ int main(int argc, char** argv) {
     PD::TT::Beg("MainRaw");
     PD::Hid::Update();
     PD::Gfx::NewFrame();
+    PD::Li::ResetPools();
     // app.Update(pOs->GetViewport(), pList);
     pList.SetFontscale(0.7);
     if (PD::Hid::IsEvent(PD::Hid::Event::Down, PD::Hid::Gamepad::CPLeft |
@@ -297,7 +298,6 @@ int main(int argc, char** argv) {
           "#ff00ff");
     }
     pList.SetFont(&font);
-#ifndef __3DS__
     PD::TT::Beg("BuildUI7Menus");
     if (auto m = ui7.BeginMenu("Test")) {
       m->Label("Hello World!");
@@ -318,11 +318,10 @@ int main(int argc, char** argv) {
     PD::TT::Beg("UI7::Context::Update");
     ui7.Update();
     PD::TT::End("UI7::Context::Update");
-#endif
     PD::Gfx::Reset();
     PD::TT::Beg("PD::Gfx::Draw");
-    PD::Gfx::Draw(pList);
     PD::Gfx::Draw(ui7.GetDrawData());
+    PD::Gfx::Draw(pList);
     PD::TT::End("PD::Gfx::Draw");
     pList.Clear();
     PD::TT::End("MainRaw");

tests/gfx/source/os/horizon-ctr.cpp

@@ -33,7 +33,7 @@ void HorizonCtr::Init() {
   romfsInit();
   osSetSpeedupEnable(true);
   gfxInitDefault();
-  consoleInit(GFX_BOTTOM, nullptr);
+  // consoleInit(GFX_BOTTOM, nullptr);
   C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
   impl->Top =
       C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
@@ -63,12 +63,12 @@ bool HorizonCtr::Mainloop() {
   pViewPort = ivec2(400, 240);
   hidScanInput();
   bool _kill = hidKeysUp() & KEY_START;
+  C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
   return aptMainLoop() && !_kill;
 }
 
 void HorizonCtr::ClearViewPort() {
   PD::Gfx::SetViewPort(pViewPort);
-  C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
   C3D_FrameDrawOn(impl->Top);
   C3D_RenderTargetClear(impl->Top, C3D_CLEAR_ALL, PD::Color(25, 25, 25, 25), 0);
 }