Merged main.

14 files changed, 293 insertions, 42 deletions

diff --git a/zencore/include/zencore/blockingqueue.h b/zencore/include/zencore/blockingqueue.h
index 277095689..f92df5a54 100644
--- a/zencore/include/zencore/blockingqueue.h
+++ b/zencore/include/zencore/blockingqueue.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <atomic>
+#include <condition_variable>
 #include <deque>
 #include <mutex>
 
diff --git a/zencore/include/zencore/compactbinary.h b/zencore/include/zencore/compactbinary.h
index 06331c510..66fa3065d 100644
--- a/zencore/include/zencore/compactbinary.h
+++ b/zencore/include/zencore/compactbinary.h
@@ -63,7 +63,7 @@ public:
 
 private:
 	void	 Set(int Year, int Month, int Day, int Hours, int Minutes, int Seconds, int MilliSecond);
-	uint64_t Ticks;
+	uint64_t Ticks;	 // 1 tick == 0.1us == 100ns, epoch == Jan 1st 0001
 };
 
 class TimeSpan
diff --git a/zencore/include/zencore/filesystem.h b/zencore/include/zencore/filesystem.h
index 155291e67..16c16fc07 100644
--- a/zencore/include/zencore/filesystem.h
+++ b/zencore/include/zencore/filesystem.h
@@ -5,6 +5,7 @@
 #include "zencore.h"
 
 #include <zencore/iobuffer.h>
+#include <zencore/string.h>
 
 #include <filesystem>
 #include <functional>
@@ -55,7 +56,74 @@ struct CopyFileOptions
 ZENCORE_API bool CopyFile(std::filesystem::path FromPath, std::filesystem::path ToPath, const CopyFileOptions& Options);
 ZENCORE_API bool SupportsBlockRefCounting(std::filesystem::path Path);
 
-ZENCORE_API std::string ToUtf8(const std::filesystem::path& Path);
+ZENCORE_API void PathToUtf8(const std::filesystem::path& Path, StringBuilderBase& Out);
+ZENCORE_API std::string PathToUtf8(const std::filesystem::path& Path);
+
+extern template class StringBuilderImpl<std::filesystem::path::value_type>;
+
+/**
+ * Helper class for building paths. Backed by a string builder.
+ *
+ */
+class PathBuilderBase : public StringBuilderImpl<std::filesystem::path::value_type>
+{
+private:
+	using Super = StringBuilderImpl<std::filesystem::path::value_type>;
+
+protected:
+	using CharType = std::filesystem::path::value_type;
+	using ViewType = std::basic_string_view<CharType>;
+
+public:
+	void Append(const std::filesystem::path& Rhs) { Super::Append(Rhs.c_str()); }
+	void operator/=(const std::filesystem::path& Rhs) { this->operator/=(Rhs.c_str()); };
+	void operator/=(const CharType* Rhs)
+	{
+		AppendSeparator();
+		Super::Append(Rhs);
+	}
+									 operator ViewType() const { return ToView(); }
+	std::basic_string_view<CharType> ToView() const { return std::basic_string_view<CharType>(Data(), Size()); }
+	std::filesystem::path			 ToPath() const { return std::filesystem::path(ToView()); }
+
+	std::string ToUtf8() const
+	{
+#if ZEN_PLATFORM_WINDOWS
+		return WideToUtf8(ToView());
+#else
+		return std::string(ToView());
+#endif
+	}
+
+	void AppendSeparator()
+	{
+		if (ToView().ends_with(std::filesystem::path::preferred_separator)
+#if ZEN_PLATFORM_WINDOWS
+			|| ToView().ends_with('/')
+#endif
+		)
+			return;
+
+		Super::Append(std::filesystem::path::preferred_separator);
+	}
+};
+
+template<size_t N>
+class PathBuilder : public PathBuilderBase
+{
+public:
+	PathBuilder() { Init(m_Buffer, N); }
+
+private:
+	PathBuilderBase::CharType m_Buffer[N];
+};
+
+template<size_t N>
+class ExtendablePathBuilder : public PathBuilder<N>
+{
+public:
+	ExtendablePathBuilder() { this->m_IsExtendable = true; }
+};
 
 struct DiskSpace
 {
@@ -85,7 +153,8 @@ class FileSystemTraversal
 public:
 	struct TreeVisitor
 	{
-		using path_view = std::basic_string_view<std::filesystem::path::value_type>;
+		using path_view	  = std::basic_string_view<std::filesystem::path::value_type>;
+		using path_string = std::filesystem::path::string_type;
 
 		virtual void VisitFile(const std::filesystem::path& Parent, const path_view& File, uint64_t FileSize) = 0;
 
diff --git a/zencore/include/zencore/intmath.h b/zencore/include/zencore/intmath.h
index 7619e1950..0d0ceff16 100644
--- a/zencore/include/zencore/intmath.h
+++ b/zencore/include/zencore/intmath.h
@@ -107,7 +107,7 @@ FloorLog2(uint32_t Value)
 static inline uint32_t
 CountLeadingZeros(uint32_t Value)
 {
-	unsigned long Log2;
+	unsigned long Log2 = 0;
 	_BitScanReverse64(&Log2, (uint64_t(Value) << 1) | 1);
 	return 32 - Log2;
 }
@@ -115,7 +115,7 @@ CountLeadingZeros(uint32_t Value)
 static inline uint64_t
 FloorLog2_64(uint64_t Value)
 {
-	unsigned long Log2;
+	unsigned long Log2 = 0;
 	long		  Mask = -long(_BitScanReverse64(&Log2, Value) != 0);
 	return Log2 & Mask;
 }
@@ -123,7 +123,7 @@ FloorLog2_64(uint64_t Value)
 static inline uint64_t
 CountLeadingZeros64(uint64_t Value)
 {
-	unsigned long Log2;
+	unsigned long Log2 = 0;
 	long		  Mask = -long(_BitScanReverse64(&Log2, Value) != 0);
 	return ((63 - Log2) & Mask) | (64 & ~Mask);
 }
diff --git a/zencore/include/zencore/iobuffer.h b/zencore/include/zencore/iobuffer.h
index 012e9a9df..816179a0a 100644
--- a/zencore/include/zencore/iobuffer.h
+++ b/zencore/include/zencore/iobuffer.h
@@ -383,10 +383,8 @@ private:
 
 class IoBufferBuilder
 {
-	using path_char_t = std::filesystem::path::value_type;
-
 public:
-	ZENCORE_API static IoBuffer MakeFromFile(const path_char_t* FileName, uint64_t Offset = 0, uint64_t Size = ~0ull);
+	ZENCORE_API static IoBuffer MakeFromFile(const std::filesystem::path& FileName, uint64_t Offset = 0, uint64_t Size = ~0ull);
 	ZENCORE_API static IoBuffer MakeFromTemporaryFile(const std::filesystem::path& FileName);
 	ZENCORE_API static IoBuffer MakeFromFileHandle(void* FileHandle, uint64_t Offset = 0, uint64_t Size = ~0ull);
 	ZENCORE_API static IoBuffer ReadFromFileMaybe(IoBuffer& InBuffer);
diff --git a/zencore/include/zencore/logging.h b/zencore/include/zencore/logging.h
index 0b080cb9d..468e5d6e2 100644
--- a/zencore/include/zencore/logging.h
+++ b/zencore/include/zencore/logging.h
@@ -82,9 +82,9 @@ using zen::Log;
 		Log().critical(fmtstr##sv, ##__VA_ARGS__); \
 	} while (false)
 
-#define ZEN_CONSOLE(fmtstr, ...)                    \
-	do                                              \
-	{                                               \
-		using namespace std::literals;              \
-		ConsoleLog().info(fmtstr##sv, __VA_ARGS__); \
+#define ZEN_CONSOLE(fmtstr, ...)                      \
+	do                                                \
+	{                                                 \
+		using namespace std::literals;                \
+		ConsoleLog().info(fmtstr##sv, ##__VA_ARGS__); \
 	} while (false)
diff --git a/zencore/include/zencore/refcount.h b/zencore/include/zencore/refcount.h
index 7167ab3b5..92ebebcfe 100644
--- a/zencore/include/zencore/refcount.h
+++ b/zencore/include/zencore/refcount.h
@@ -159,7 +159,7 @@ public:
 private:
 	T* m_Ref = nullptr;
 
-	template<class T>
+	template<class U>
 	friend class Ref;
 };
 
diff --git a/zencore/include/zencore/string.h b/zencore/include/zencore/string.h
index 031ea2c1d..848310aa3 100644
--- a/zencore/include/zencore/string.h
+++ b/zencore/include/zencore/string.h
@@ -219,6 +219,19 @@ public:
 		return AppendRange(String.data(), String.data() + String.size());
 	}
 
+	inline StringBuilderImpl& AppendBool(bool v)
+	{
+		// This is a method instead of a << operator overload as the latter can
+		// easily get called with non-bool types like pointers. It is a very
+		// subtle behaviour that can cause bugs.
+		using namespace std::literals;
+		if (v)
+		{
+			return AppendAscii("true"sv);
+		}
+		return AppendAscii("false"sv);
+	}
+
 	inline void RemoveSuffix(uint32_t Count)
 	{
 		ZEN_ASSERT(Count <= Size());
@@ -291,15 +304,6 @@ public:
 	inline StringBuilderImpl& operator<<(const char* str) { return AppendAscii(str); }
 	inline StringBuilderImpl& operator<<(const std::string_view str) { return AppendAscii(str); }
 	inline StringBuilderImpl& operator<<(const std::u8string_view str) { return AppendAscii(str); }
-	inline StringBuilderImpl& operator<<(bool v)
-	{
-		using namespace std::literals;
-		if (v)
-		{
-			return AppendAscii("true"sv);
-		}
-		return AppendAscii("false"sv);
-	}
 
 protected:
 	inline void Init(C* Base, size_t Capacity)
@@ -424,7 +428,7 @@ public:
 	inline std::wstring_view ToView() const { return std::wstring_view{Data(), Size()}; }
 	inline std::wstring		 ToString() const { return std::wstring{Data(), Size()}; }
 
-	inline StringBuilderImpl& operator<<(const std::u16string_view str) { return Append((const wchar_t*)str.data(), str.size()); }
+	inline StringBuilderImpl& operator<<(const std::wstring_view str) { return Append((const wchar_t*)str.data(), str.size()); }
 	inline StringBuilderImpl& operator<<(const wchar_t* str) { return Append(str); }
 	using StringBuilderImpl:: operator<<;
 };
@@ -460,7 +464,6 @@ std::wstring Utf8ToWide(const std::string_view& wstr);
 
 void		WideToUtf8(const wchar_t* wstr, StringBuilderBase& out);
 std::string WideToUtf8(const wchar_t* wstr);
-void		WideToUtf8(const std::u16string_view& wstr, StringBuilderBase& out);
 void		WideToUtf8(const std::wstring_view& wstr, StringBuilderBase& out);
 std::string WideToUtf8(const std::wstring_view Wstr);
 
@@ -697,6 +700,19 @@ ForEachStrTok(const std::string_view& Str, char Delim, Fn&& Func)
 
 //////////////////////////////////////////////////////////////////////////
 
+inline int32_t
+StrCaseCompare(const char* Lhs, const char* Rhs, int64_t Length = -1)
+{
+	// A helper for cross-platform case-insensitive string comparison.
+#if ZEN_PLATFORM_WINDOWS
+	return (Length < 0) ? _stricmp(Lhs, Rhs) : _strnicmp(Lhs, Rhs, size_t(Length));
+#else
+	return (Length < 0) ? strcasecmp(Lhs, Rhs) : strncasecmp(Lhs, Rhs, size_t(Length));
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////
+
 /**
  * ASCII character bitset useful for fast and readable parsing
  *
diff --git a/zencore/include/zencore/thread.h b/zencore/include/zencore/thread.h
index 9fc4c87a2..16d0e9dee 100644
--- a/zencore/include/zencore/thread.h
+++ b/zencore/include/zencore/thread.h
@@ -6,6 +6,7 @@
 
 #include <shared_mutex>
 
+#include <filesystem>
 #include <string_view>
 #include <vector>
 
@@ -102,11 +103,30 @@ protected:
 
 /** Basic abstraction of an IPC mechanism (aka 'binary semaphore')
  */
-class NamedEvent : public Event
+class NamedEvent
 {
 public:
+	NamedEvent() = default;
 	ZENCORE_API explicit NamedEvent(std::string_view EventName);
-	ZENCORE_API explicit NamedEvent(std::u8string_view EventName);
+	ZENCORE_API ~NamedEvent();
+	ZENCORE_API void Close();
+	ZENCORE_API void Set();
+	ZENCORE_API bool Wait(int TimeoutMs = -1);
+
+	NamedEvent(NamedEvent&& Rhs) noexcept : m_EventHandle(Rhs.m_EventHandle) { Rhs.m_EventHandle = nullptr; }
+
+	inline NamedEvent& operator=(NamedEvent&& Rhs) noexcept
+	{
+		std::swap(m_EventHandle, Rhs.m_EventHandle);
+		return *this;
+	}
+
+protected:
+	void* m_EventHandle = nullptr;
+
+private:
+	NamedEvent(const NamedEvent& Rhs) = delete;
+	NamedEvent& operator=(const NamedEvent& Rhs) = delete;
 };
 
 /** Basic abstraction of a named (system wide) mutex primitive
@@ -143,13 +163,38 @@ public:
 	ZENCORE_API bool			   Wait(int TimeoutMs = -1);
 	ZENCORE_API void			   Terminate(int ExitCode);
 	ZENCORE_API void			   Reset();
-	inline [[nodiscard]] int	   Pid() const { return m_Pid; }
+	[[nodiscard]] inline int	   Pid() const { return m_Pid; }
 
 private:
 	void* m_ProcessHandle = nullptr;
 	int	  m_Pid			  = 0;
 };
 
+/** Basic process creation
+ */
+struct CreateProcOptions
+{
+	enum
+	{
+		Flag_NewConsole = 1 << 0,
+		Flag_Elevated	= 1 << 1,
+		Flag_Unelevated = 1 << 2,
+	};
+
+	const std::filesystem::path* WorkingDirectory = nullptr;
+	uint32_t					 Flags			  = 0;
+};
+
+#if ZEN_PLATFORM_WINDOWS
+using CreateProcResult = void*;	 // handle to the process
+#else
+using CreateProcResult = int32_t;  // pid
+#endif
+
+ZENCORE_API CreateProcResult CreateProc(const std::filesystem::path& Executable,
+										std::string_view			 CommandLine,  // should also include arg[0] (executable name)
+										const CreateProcOptions&	 Options = {});
+
 /** Process monitor - monitors a list of running processes via polling
 
 	Intended to be used to monitor a set of "sponsor" processes, where
@@ -168,12 +213,15 @@ public:
 	ZENCORE_API bool IsActive() const;
 
 private:
-	mutable RwLock	   m_Lock;
-	std::vector<void*> m_ProcessHandles;
+	using HandleType = void*;
+
+	mutable RwLock			m_Lock;
+	std::vector<HandleType> m_ProcessHandles;
 };
 
 ZENCORE_API bool IsProcessRunning(int pid);
 ZENCORE_API int	 GetCurrentProcessId();
+ZENCORE_API int	 GetCurrentThreadId();
 
 ZENCORE_API void Sleep(int ms);
 
diff --git a/zencore/include/zencore/trace.h b/zencore/include/zencore/trace.h
new file mode 100644
index 000000000..a2e69a145
--- /dev/null
+++ b/zencore/include/zencore/trace.h
@@ -0,0 +1,51 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/zencore.h>
+
+#if ZEN_WITH_TRACE
+
+#	define __UNREAL__		  0
+#	define IS_MONOLITHIC	  1
+#	define PLATFORM_WINDOWS  ZEN_PLATFORM_WINDOWS
+#	define PLATFORM_UNIX	  ZEN_PLATFORM_LINUX
+#	define PLATFORM_APPLE	  ZEN_PLATFORM_MAC
+#	define PLATFORM_ANDROID  0
+#	define PLATFORM_HOLOLENS 0
+#	define UE_BUILD_TEST	  0
+#	define UE_BUILD_SHIPPING 0
+
+ZEN_THIRD_PARTY_INCLUDES_START
+#	if !defined(TRACE_IMPLEMENT)
+#		define TRACE_IMPLEMENT 0
+#	endif
+#	include <trace.h>
+#	undef TRACE_IMPLEMENT
+
+ZEN_THIRD_PARTY_INCLUDES_END
+#	undef __UNREAL__
+#	undef IS_MONOLITHIC
+#	undef PLATFORM_WINDOWS
+#	undef PLATFORM_UNIX
+#	undef PLATFORM_APPLE
+#	undef PLATFORM_ANDROID
+#	undef PLATFORM_HOLOLENS
+#	undef UE_BUILD_TEST
+#	undef UE_BUILD_SHIPPING
+
+#	define ZEN_TRACE_CPU(x) TRACE_CPU_SCOPE(x)
+
+enum class TraceType
+{
+	File,
+	Network,
+};
+
+void TraceInit(const char* HostOrPath, TraceType Type);
+
+#else
+
+#	define ZEN_TRACE_CPU(x)
+
+#endif	// ZEN_WITH_TRACE
diff --git a/zencore/include/zencore/uid.h b/zencore/include/zencore/uid.h
index f4e9ab65a..d25aa8059 100644
--- a/zencore/include/zencore/uid.h
+++ b/zencore/include/zencore/uid.h
@@ -74,7 +74,7 @@ struct Oid
 		size_t operator()(const Oid& id) const
 		{
 			const size_t seed = id.OidBits[0];
-			return (seed << 6) + (seed >> 2) + 0x9e3779b9 + uint64_t(id.OidBits[1]) | (uint64_t(id.OidBits[2]) << 32);
+			return ((seed << 6) + (seed >> 2) + 0x9e3779b9 + uint64_t(id.OidBits[1])) | (uint64_t(id.OidBits[2]) << 32);
 		}
 	};
 
diff --git a/zencore/include/zencore/varint.h b/zencore/include/zencore/varint.h
index 0c40dd66b..d7f2ebfb7 100644
--- a/zencore/include/zencore/varint.h
+++ b/zencore/include/zencore/varint.h
@@ -2,6 +2,8 @@
 
 #include "intmath.h"
 
+#include <algorithm>
+
 namespace zen {
 
 // Variable-Length Integer Encoding
diff --git a/zencore/include/zencore/windows.h b/zencore/include/zencore/windows.h
index 68138566b..117c5eff1 100644
--- a/zencore/include/zencore/windows.h
+++ b/zencore/include/zencore/windows.h
@@ -10,7 +10,12 @@ struct IUnknown;  // Workaround for "combaseapi.h(229): error C2187: syntax erro
 #ifndef NOMINMAX
 #	define NOMINMAX  // We don't want your min/max macros
 #endif
-#define WIN32_LEAN_AND_MEAN
+#ifndef NOGDI
+#	define NOGDI  // We don't want your GetObject define
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#	define WIN32_LEAN_AND_MEAN
+#endif
 #include <windows.h>
 #undef GetObject
 
diff --git a/zencore/include/zencore/zencore.h b/zencore/include/zencore/zencore.h
index 6b9a0f658..3352af5d2 100644
--- a/zencore/include/zencore/zencore.h
+++ b/zencore/include/zencore/zencore.h
@@ -16,7 +16,7 @@
 
 #define ZEN_PLATFORM_WINDOWS 0
 #define ZEN_PLATFORM_LINUX	 0
-#define ZEN_PLATFORM_MACOS	 0
+#define ZEN_PLATFORM_MAC	 0
 
 #ifdef _WIN32
 #	undef ZEN_PLATFORM_WINDOWS
@@ -25,8 +25,20 @@
 #	undef ZEN_PLATFORM_LINUX
 #	define ZEN_PLATFORM_LINUX 1
 #elif defined(__APPLE__)
-#	undef ZEN_PLATFORM_MACOS
-#	define ZEN_PLATFORM_MACOS 1
+#	undef ZEN_PLATFORM_MAC
+#	define ZEN_PLATFORM_MAC 1
+#endif
+
+#if ZEN_PLATFORM_WINDOWS
+#	if !defined(NOMINMAX)
+#		define NOMINMAX  // stops Windows.h from defining 'min/max' macros
+#	endif
+#	if !defined(NOGDI)
+#		define NOGDI
+#	endif
+#	if !defined(WIN32_LEAN_AND_MEAN)
+#		define WIN32_LEAN_AND_MEAN	 // cut-down what Windows.h defines
+#	endif
 #endif
 
 //////////////////////////////////////////////////////////////////////////
@@ -68,20 +80,45 @@
 
 #ifndef ZEN_THIRD_PARTY_INCLUDES_START
 #	if ZEN_COMPILER_MSC
-#		define ZEN_THIRD_PARTY_INCLUDES_START __pragma(warning(push)) __pragma(warning(disable : 4668 4127))
-#	else
-#		define ZEN_THIRD_PARTY_INCLUDES_START
+#		define ZEN_THIRD_PARTY_INCLUDES_START                                                                    \
+			__pragma(warning(push)) __pragma(warning(disable : 4668)) /* use of undefined preprocessor macro */   \
+				__pragma(warning(disable : 4267))					  /* '=': conversion from 'size_t' to 'US' */ \
+				__pragma(warning(disable : 4127))
+#	elif ZEN_COMPILER_CLANG
+#		define ZEN_THIRD_PARTY_INCLUDES_START                                               \
+			_Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wundef\"") \
+				_Pragma("clang diagnostic ignored \"-Wunused-parameter\"") _Pragma("clang diagnostic ignored \"-Wunused-variable\"")
+#	elif ZEN_COMPILER_GCC
+#		define ZEN_THIRD_PARTY_INCLUDES_START                                              \
+			_Pragma("GCC diagnostic push") /* NB. ignoring -Wundef doesn't work with GCC */ \
+				_Pragma("GCC diagnostic ignored \"-Wunused-parameter\"") _Pragma("GCC diagnostic ignored \"-Wunused-variable\"")
 #	endif
 #endif
 
 #ifndef ZEN_THIRD_PARTY_INCLUDES_END
 #	if ZEN_COMPILER_MSC
 #		define ZEN_THIRD_PARTY_INCLUDES_END __pragma(warning(pop))
-#	else
-#		define ZEN_THIRD_PARTY_INCLUDES_END
+#	elif ZEN_COMPILER_CLANG
+#		define ZEN_THIRD_PARTY_INCLUDES_END _Pragma("clang diagnostic pop")
+#	elif ZEN_COMPILER_GCC
+#		define ZEN_THIRD_PARTY_INCLUDES_END _Pragma("GCC diagnostic pop")
 #	endif
 #endif
 
+#if ZEN_COMPILER_MSC
+#	define ZEN_DEBUG_BREAK() \
+		do                    \
+		{                     \
+			__debugbreak();   \
+		} while (0)
+#else
+#	define ZEN_DEBUG_BREAK() \
+		do                    \
+		{                     \
+			__builtin_trap(); \
+		} while (0)
+#endif
+
 //////////////////////////////////////////////////////////////////////////
 // Architecture
 //
@@ -112,6 +149,13 @@
 
 #define ZEN_PLATFORM_SUPPORTS_UNALIGNED_LOADS 1
 
+#if defined(__SIZEOF_WCHAR_T__) && __SIZEOF_WCHAR_T__ == 4
+#	define ZEN_SIZEOF_WCHAR_T 4
+#else
+static_assert(sizeof(wchar_t) == 2, "wchar_t is expected to be two bytes in size");
+#	define ZEN_SIZEOF_WCHAR_T 2
+#endif
+
 //////////////////////////////////////////////////////////////////////////
 // Assert
 //
@@ -206,6 +250,12 @@ char (&ZenArrayCountHelper(const T (&)[N]))[N + 1];
 #	define ZEN_NOINLINE __attribute__((noinline))
 #endif
 
+#if ZEN_PLATFORM_WINDOWS
+#	define ZEN_EXE_SUFFIX_LITERAL ".exe"
+#else
+#	define ZEN_EXE_SUFFIX_LITERAL
+#endif
+
 #define ZEN_UNUSED(...)			 ((void)__VA_ARGS__)
 #define ZEN_NOT_IMPLEMENTED(...) ZEN_ASSERT(false, __VA_ARGS__)
 #define ZENCORE_API	 // Placeholder to allow DLL configs in the future (maybe)
@@ -233,7 +283,12 @@ ZENCORE_API void zencore_forcelinktests();
 #if ZEN_COMPILER_MSC
 #	define ZEN_DISABLE_OPTIMIZATION_ACTUAL __pragma(optimize("", off))
 #	define ZEN_ENABLE_OPTIMIZATION_ACTUAL	__pragma(optimize("", on))
-#else
+#elif ZEN_COMPILER_GCC
+#	define ZEN_DISABLE_OPTIMIZATION_ACTUAL _Pragma("GCC push_options") _Pragma("GCC optimize (\"O0\")")
+#	define ZEN_ENABLE_OPTIMIZATION_ACTUAL	_Pragma("GCC pop_options")
+#elif ZEN_COMPILER_CLANG
+#	define ZEN_DISABLE_OPTIMIZATION_ACTUAL _Pragma("clang optimize off")
+#	define ZEN_ENABLE_OPTIMIZATION_ACTUAL	_Pragma("clang optimize on")
 #endif
 
 // Set up optimization control macros, now that we have both the build settings and the platform macros
@@ -249,4 +304,10 @@ ZENCORE_API void zencore_forcelinktests();
 
 //////////////////////////////////////////////////////////////////////////
 
+#ifndef ZEN_WITH_TRACE
+#	define ZEN_WITH_TRACE 0
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+
 using ThreadId_t = uint32_t;