basic

array.hpp

@@ -235,7 +235,7 @@ struct Array {
 };
 
 #ifdef ULE_CONFIG_OPTION_SERIALIZATION
-extern template <typename T>
+template <typename T>
 static void serialize(String* str, Array<T> array) {
     ULE_TYPES_H_FTAG;
     serialize(str, array.length);
@@ -245,7 +245,7 @@ static void serialize(String* str, Array<T> array) {
     }
 }
 
-extern template <typename T>
+template <typename T>
 static void serialize(String* str, Array<T>* array) {
     ULE_TYPES_H_FTAG;
     SERIALIZE_HANDLE_NULL(str, array);
@@ -256,7 +256,7 @@ static void serialize(String* str, Array<T>* array) {
     }
 }
 
-extern template <typename T>
+template <typename T>
 static void deserialize(char** buffer, Array<T>* array) {
     ULE_TYPES_H_FTAG;
     deserialize(buffer, &array->length);
@@ -266,7 +266,7 @@ static void deserialize(char** buffer, Array<T>* array) {
     }
 }
 
-extern template <typename T>
+template <typename T>
 static void deserialize(char** buffer, Array<T>** array) {
     ULE_TYPES_H_FTAG;
     DESERIALIZE_HANDLE_NULL(buffer, array);

config.h

@@ -1,15 +1,23 @@
 
-#pragma once
-#ifndef ULE_CONFIG_H
-#define ULE_CONFIG_H
-
 // define this macro to include the serialization code `serialize.h/.cpp`, as well as serialization
 // for the hashtable(s) and array implementations.
-//#define ULE_CONFIG_OPTION_SERIALIZATION
+#define ULE_CONFIG_OPTION_SERIALIZATION
 
 // all functions in the library will invoke a semicolon-terminated macro as their first line of execution.
 // this is for use by an instrusive profiler, though could be used for whatever purpose.
-//#define ULE_CONFIG_OPTION_FTAG ZoneScoped
+#include <Tracy.hpp>
+#define ULE_CONFIG_OPTION_FTAG ZoneScoped
+
+// use glm for vector and matrix types and operations.
+// if this is defined, you will also need to include 'glm'. make sure the following headers can be found on your system.
+// the way this is done currently hurts compile times. Eventually we will have a glm replacement and this problem goes away.
+// You can also compile ULE into a static lib to avoid this issue.
+#include <glm/glm.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+#define ULE_CONFIG_OPTION_USE_GLM
+
 
-#endif
+#define ULE_CONFIG_OPTION_PRINT_OUTPUT_USE_ANSI_COLOR_CODES
 

print.cpp

@@ -194,6 +194,35 @@ void setCustomDieBehavior(void (*dieBehavior)(const char* string)) {
     customDie = dieBehavior;
 }
 
+#ifdef _WIN32
+#include <Minidumpapiset.h>
+#include <tchar.h>
+static void writeMinidump(EXCEPTION_POINTERS* pep) {
+    // create a file
+    HANDLE hFile = CreateFile(_T("MiniDump.dmp"), GENERIC_READ | GENERIC_WRITE, 0, null, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, null);
+
+    if ((hFile != null) && (hFile != INVALID_HANDLE_VALUE)) {
+        // carry on with creating the minidump
+        MINIDUMP_EXCEPTION_INFORMATION mdei;
+        mdei.ThreadId           = GetCurrentThreadId();
+        mdei.ExceptionPointers  = pep;
+        mdei.ClientPointers     = FALSE;
+
+        MINIDUMP_TYPE mdt       = MiniDumpNormal;
+        BOOL rv = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, mdt, (pep != 0) ? &mdei : 0, 0, 0);
+        if (!rv) {
+            println(_T("MiniDumpWriteDump failed. Error: %u"), GetLastError());
+        } else {
+            println(_T("MiniDump created."));
+        }
+
+        CloseHandle(hFile);
+    } else {
+        println(_T("Failed to CreateFile for MiniDump. Error: %u"), GetLastError());
+    }
+}
+#endif
+
 // for fatal errors which may occur at runtime, even on a release binary.
 // if a fatal error should not occur at runtime on a release binary, consider preferring 'massert'
 // it's unclear when you should use asserts vs. die actually. idk man

serialize.cpp

@@ -1,8 +1,12 @@
 
+#include "config.h"
+
 #ifdef ULE_CONFIG_OPTION_SERIALIZATION
 
+
 #include <fast_float/fast_float.h>
 
+
 #include "types.h"
 #include "serialize.h"
 #include "string.h"
@@ -29,7 +33,7 @@ static inline const char* getFormatStringOut(double v) { ULE_TYPES_H_FTAG; retur
 static inline const char* getFormatStringOut(char*       v) { ULE_TYPES_H_FTAG; return "\"%s\"\n"; }
 static inline const char* getFormatStringOut(const char* v) { ULE_TYPES_H_FTAG; return "\"%s\"\n"; }
 
-#ifdef _USING_GLM_TYPES__
+#ifdef ULE_CONFIG_OPTION_USE_GLM
 static inline const char* getFormatStringOut(glm::vec<2, float, (glm::qualifier) 3> v) { ULE_TYPES_H_FTAG; return "%f %f\n"; }
 static inline const char* getFormatStringOut(glm::vec<3, float, (glm::qualifier) 3> v) { ULE_TYPES_H_FTAG; return "%f %f %f\n"; }
 static inline const char* getFormatStringOut(glm::vec<4, float, (glm::qualifier) 3> v) { ULE_TYPES_H_FTAG; return "%f %f %f %f\n"; }
@@ -37,7 +41,6 @@ static inline const char* getFormatStringOut(glm::vec<4, float, (glm::qualifier)
 static inline const char* getFormatStringOut(glm::mat<2, 2, float, (glm::qualifier) 3> v) { ULE_TYPES_H_FTAG; return "%f %f %f %f\n"; }
 static inline const char* getFormatStringOut(glm::mat<3, 3, float, (glm::qualifier) 3> v) { ULE_TYPES_H_FTAG; return "%f %f %f %f %f %f %f %f %f\n"; }
 static inline const char* getFormatStringOut(glm::mat<4, 4, float, (glm::qualifier) 3> v) { ULE_TYPES_H_FTAG; return "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n"; }
-
 #endif
 
 #define SERIALIZE_H_FUNC_BODY str->appendf(getFormatStringOut(v), v);
@@ -52,7 +55,7 @@ void serialize(String* str, s64    v) { ULE_TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY
 void serialize(String* str, float  v) { ULE_TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
 void serialize(String* str, double v) { ULE_TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
 
-extern template<typename T> // @TODO do not use a template for this.
+template<typename T> // @TODO do not use a template for this.
 static inline void deserializeInteger(char** buffer, T* v) {
     ULE_TYPES_H_FTAG;
     char* _buffer = *buffer;
@@ -227,7 +230,7 @@ void deserialize(char** buffer, const char** v) {
     *v = String::cpy(SERIALIZE_SCRATCH_BUFFER, (u32) i);
 }
 
-#ifdef _USING_GLM_TYPES__
+#ifdef ULE_CONFIG_OPTION_USE_GLM
 // I have no fucking idea why, but the declarations of glm types here resolve to a type,
 // that has a template parameter == 0, but all other instances of those types in my program
 // have that template parameter == 3, so everything below becomes unresolved symbols if 
@@ -310,10 +313,11 @@ void deserialize(char** buffer, glm::mat<4, 4, float, (glm::qualifier) 3>* v) {
         deserialize(buffer, m + i);
     }
 }
+#endif // ULE_CONFIG_OPTION_USE_GLM
 
 #undef SERIALIZE_H_FUNC_BODY
 #undef SERIALIZE_H_DESERIALIZE_FUNC_BODY
 
 #endif
-#endif
+
 

serialize.h

@@ -189,7 +189,7 @@ extern void serialize(String* str, size_t v);
 extern void deserialize(char** buffer, size_t* v);
 #endif
 
-#ifdef _USING_GLM_TYPES__
+#ifdef ULE_CONFIG_OPTION_USE_GLM
 extern void serialize(String* str, glm::vec<2, float, (glm::qualifier) 3> v);
 extern void serialize(String* str, glm::vec<3, float, (glm::qualifier) 3> v);
 extern void serialize(String* str, glm::vec<4, float, (glm::qualifier) 3> v);

string.h

@@ -6,7 +6,7 @@
 #include "types.h"
 #include "alloc.h"
 
-//#include <string.h> // @TODO remove this
+#include <string.h> // @TODO remove this
 
 #define STB_SPRINTF_IMPLEMENTATION
 #define STB_SPRINTF_STATIC

table.hpp

@@ -720,3 +720,4 @@ struct CacheTable {
 };
 
 #endif
+

util.h

@@ -5,6 +5,15 @@
 
 #define STATIC_ARRAY_LENGTH(a) (sizeof(a)/sizeof(a[0]))
 
+// GCC & CLang
+//#define FORCE_INLINE inline __attribute__((__always_inline))
+//#define NEVER_INLINE __attribute__((__noinline__))
+
+
+// VC++
+#define FORCE_INLINE __forceinline
+#define NEVER_INLINE __declspec(noinline)
+
 
 #endif