yet another memory debugger fix

(cause in some cases random crashes could happen)

CMakeLists.txt

@@ -7,9 +7,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED true)
 
 option(AMY_GOD_DEV "Turn this on if you think you are god" OFF)
 # THis option should be disabled if you use STB_IMAGE in you main project
-set(AMY_BUILD_STB_IMAGE 0)
-set(AMY_BUILD_STB_TRUETYPE 1)
-set(AMY_WITH_MPG123 "Include MP3 Support" CACHE BOOL 1)
+option(AMY_BUILD_STB_IMAGE ON)
+option(AMY_BUILD_STB_TRUETYPE ON)
 
 add_subdirectory(vendor/libpicasso)
 
@@ -38,12 +37,13 @@ target_include_directories(${PROJECT_NAME} PRIVATE
 )
 target_link_libraries(${PROJECT_NAME} PUBLIC pica::pica)
 target_link_libraries(${PROJECT_NAME} PUBLIC m z ctru citro3d mpg123)
-target_compile_definitions(${PROJECT_NAME} PUBLIC
-    AMY_3DS
-    AMY_STB_IMAGE=${AMY_BUILD_STB_IMAGE}
-    AMY_STB_TT=${AMY_BUILD_STB_TRUETYPE}
-    AMY_WITH_MPG123=${AMY_WITH_MPG123}
-)
+if(${AMY_BUILD_STB_IMAGE})
+    target_compile_definitions(${PROJECT_NAME} PUBLIC AMY_STB_IMAGE)
+endif()
+if(${AMY_BUILD_STB_TRUETYPE})
+    target_compile_definitions(${PROJECT_NAME} PUBLIC AMY_STB_TT)
+endif()
+
 target_compile_options(${PROJECT_NAME} PUBLIC -Wno-psabi)
 
 add_subdirectory(example)

include/amethyst.hpp

@@ -10,10 +10,27 @@
 #include <amethyst/renderer.hpp>
 #include <amethyst/texture.hpp>
 #include <amethyst/utils.hpp>
+#include <atomic>
 
 namespace Amy {
 void RegisterCxxExceptionHandler();
-}
+void* Malloc(size_t size);
+void Free(void* ptr);
+namespace Memory {
+struct MemMetrics {
+  std::atomic<ull> Allocated = 0;    ///< Total Allocated Memory
+  std::atomic<ull> Current = 0;      ///< Current Allocated Memory
+  std::atomic<ull> Deleted = 0;      ///< Total Deleted Memory
+  std::atomic<ull> Allocations = 0;  ///< Current Allocations count
+  /// @brief Gets the Currently Allocated Memory
+  ull CurrentlyAllocated() { return Current; }
+};
+ull GetTotalAllocated();
+ull GetTotalFreed();
+ull GetCurrent();
+ull GetAllocationCount();
+}  // namespace Memory
+}  // namespace Amy
 
 using Iron = Amy::Iron;
 using C3D = Amy::C3D;

include/amethyst/iron.hpp

@@ -122,12 +122,12 @@ class Iron {
 
     void DrawSolid();
     void DrawTex(Texture::Ref tex) { pTex = tex; }
-    void DrawCutTex(fvec2 pos, fvec2 size, fvec4 cut_rect,
+    void DrawFromAtlas(fvec2 pos, fvec2 size, fvec4 cut_rect,
                        ui color = 0xffffffff);
-    void DrawCutTex(fvec2 pos, fvec2 size, fvec4 cut_rect, Texture::Ref tex,
+    void DrawFromAtlas(fvec2 pos, fvec2 size, fvec4 cut_rect, Texture::Ref tex,
                        ui color = 0xffffffff) {
       DrawTex(tex);
-      DrawCutTex(pos, size, cut_rect, color);
+      DrawFromAtlas(pos, size, cut_rect, color);
       DrawSolid();
     }
     void SetFont(Font::Ref fnt) { pCurrentFont = fnt; }

source/amethyst.cpp

@@ -1,6 +1,10 @@
 #include <amethyst.hpp>
 #include <exception>
 #include <iostream>
+#include <map>
+#include <vector>
+
+#define TRACK_NEW_DELETE
 
 #ifdef AMY_3DS
 #include <3ds.h>
@@ -26,6 +30,103 @@ void NpiD7CxxExceptionHandler() {
 }
 #endif
 
+static Amy::Memory::MemMetrics metrics;
+
+#ifdef TRACK_NEW_DELETE
+
+constexpr uint32_t MemDBGMagic = 0x774733d7;
+
+struct MemDBGHeader {
+  MemDBGHeader(size_t s) {
+    Magic = MemDBGMagic;
+    Size = s;
+  }
+  uint32_t Magic = MemDBGMagic;
+  size_t Size = 0;
+};
+
+void *MemDBGAllocate(size_t size) {
+  void *ptr = malloc(size + sizeof(MemDBGHeader));
+  if (!ptr) return reinterpret_cast<void *>(ptr);
+  MemDBGHeader *hdr = reinterpret_cast<MemDBGHeader *>(ptr);
+  hdr->Magic = MemDBGMagic;
+  hdr->Size = size;
+  metrics.Allocated.fetch_add(hdr->Size, std::memory_order_relaxed);
+  metrics.Current.fetch_add(hdr->Size, std::memory_order_relaxed);
+  metrics.Allocations.fetch_add(1, std::memory_order_relaxed);
+  return reinterpret_cast<void *>(hdr + 1);
+}
+
+void MemDBGFree(void *ptr) {
+  if (!ptr) return;
+  MemDBGHeader *hdr = reinterpret_cast<MemDBGHeader *>(ptr) - 1;
+  if (hdr->Magic == MemDBGMagic) {
+    hdr->Magic = 0;
+    size_t szs = hdr->Size;
+    metrics.Deleted.fetch_add(szs, std::memory_order_relaxed);
+    metrics.Current.fetch_sub(szs, std::memory_order_relaxed);
+    metrics.Allocations.fetch_sub(1, std::memory_order_relaxed);
+    free(reinterpret_cast<void *>(hdr));
+  } else {
+    std::abort();
+  }
+}
+
+void *operator new(size_t size) { return MemDBGAllocate(size); }
+void *operator new[](size_t size) { return MemDBGAllocate(size); }
+void operator delete(void *ptr) noexcept { MemDBGFree(ptr); }
+void operator delete(void *ptr, size_t) noexcept { MemDBGFree(ptr); }
+void operator delete[](void *ptr) noexcept { MemDBGFree(ptr); }
+void operator delete[](void *ptr, size_t) noexcept { MemDBGFree(ptr); }
+void *operator new(size_t size, const std::nothrow_t &) noexcept {
+  return MemDBGAllocate(size);
+}
+void *operator new[](size_t size, const std::nothrow_t &) noexcept {
+  return MemDBGAllocate(size);
+}
+void operator delete(void *ptr, const std::nothrow_t &) noexcept {
+  MemDBGFree(ptr);
+}
+void operator delete[](void *ptr, const std::nothrow_t &) noexcept {
+  MemDBGFree(ptr);
+}
+void *operator new(size_t size, std::align_val_t) {
+  return MemDBGAllocate(size);
+}
+void *operator new[](size_t size, std::align_val_t) {
+  return MemDBGAllocate(size);
+}
+
+void operator delete(void *ptr, std::align_val_t) noexcept { MemDBGFree(ptr); }
+void operator delete[](void *ptr, std::align_val_t) noexcept {
+  MemDBGFree(ptr);
+}
+void *operator new(size_t size, std::align_val_t,
+                   const std::nothrow_t &) noexcept {
+  return MemDBGAllocate(size);
+}
+void *operator new[](size_t size, std::align_val_t,
+                     const std::nothrow_t &) noexcept {
+  return MemDBGAllocate(size);
+}
+void operator delete(void *ptr, size_t, std::align_val_t) noexcept {
+  MemDBGFree(ptr);
+}
+
+void operator delete[](void *ptr, size_t, std::align_val_t) noexcept {
+  MemDBGFree(ptr);
+}
+void operator delete(void *ptr, size_t, std::align_val_t,
+                     const std::nothrow_t &) noexcept {
+  MemDBGFree(ptr);
+}
+
+void operator delete[](void *ptr, size_t, std::align_val_t,
+                       const std::nothrow_t &) noexcept {
+  MemDBGFree(ptr);
+}
+#endif
+
 namespace Amy {
 
 void RegisterCxxExceptionHandler() {
@@ -33,4 +134,22 @@ void RegisterCxxExceptionHandler() {
   std::set_terminate(NpiD7CxxExceptionHandler);
 #endif
 }
+void *Malloc(size_t size) {
+#ifdef TRACK_NEW_DELETE
+  return MemDBGAllocate(size);
+#else
+  return malloc(size);
+#endif
+}
+void Free(void *ptr) {
+#ifdef TRACK_NEW_DELETE
+  MemDBGFree(ptr);
+#else
+  free(ptr);
+#endif
+}
+ull Memory::GetTotalAllocated() { return metrics.Allocated; }
+ull Memory::GetTotalFreed() { return metrics.Deleted; }
+ull Memory::GetCurrent() { return metrics.CurrentlyAllocated(); }
+ull Memory::GetAllocationCount() { return metrics.Allocations; }
 }  // namespace Amy

source/image.cpp

@@ -4,7 +4,7 @@
 
 // Only include stb Code if we need it
 // Otherwise we just build the header
-#if AMY_STB_IMAGE == 1
+#ifdef AMY_STB_IMAGE
 #define STB_IMAGE_IMPLEMENTATION
 #endif
 #include <stb_image.h>

source/iron/drawlist.cpp

@@ -209,7 +209,7 @@ void Iron::Drawlist::DrawCircleFilled(const fvec2& center, float rad, ui color,
   PathFill(color);
 }
 
-void Iron::Drawlist::DrawCutTex(fvec2 pos, fvec2 size, fvec4 cut_rect,
+void Iron::Drawlist::DrawFromAtlas(fvec2 pos, fvec2 size, fvec4 cut_rect,
                                    ui color) {
   auto r = Iron::PrimRect(pos, size);
   auto cmd = NewCommand();

source/iron/font.cpp

@@ -3,9 +3,9 @@
 #include <filesystem>
 #include <fstream>
 
-#if AMY_STB_TT == 1
+//#ifdef AMY_STB_TT
 #define STB_TRUETYPE_IMPLEMENTATION
-#endif
+//#endif
 #include <stb_truetype.h>
 
 namespace Amy {