1HEADmaster

3 files changed, 2056 insertions, 0 deletions

diff --git a/thirdparty/telemetry/include/radtypes.h b/thirdparty/telemetry/include/radtypes.h
new file mode 100644
index 0000000..c3eae3c
--- /dev/null
+++ b/thirdparty/telemetry/include/radtypes.h
@@ -0,0 +1,693 @@
+/// ========================================================================
+// (C) Copyright 1994- 2014 RAD Game Tools, Inc.  Global types header file
+// ========================================================================
+
+#if !defined(__RADTYPESH__) && !defined(__RADRR_COREH__)
+#define __RADTYPESH__
+#define __RADRR_COREH__ // block old rr_core
+
+#define RADCOPYRIGHT "Copyright (C) 1994-2014, RAD Game Tools, Inc."
+
+#if !defined(__RADRES__) // don't include anything for resource compiles
+
+//  __RAD32__ means at least 32 bit code (always defined)
+//  __RAD64__ means 64 bit code (64-bit OSes only)
+
+//  __RADNT__ means Win32 and Win64 desktop
+//  __RADWINRT__ means Windows Store/Phone App (x86, x64, arm)
+//  __RADWIN__ means win32, win64, windows store/phone, xenon, durango
+//  __RADWINRTAPI__ means Windows RT API (Win Store, Win Phone, Durango)
+//  __RADMAC__ means MacOS (32 or 64-bit)
+//  __RADXENON__ means the Xbox360 console
+//  __RADXBOXONE__ means Xbox One
+//  __RADWIIU__ means the Nintendo Wii U
+//  __RAD3DS__ means the Nintendo 3DS
+//  __RADPS3__ means the Sony PlayStation 3
+//  __RADPS4__ means the Sony PlayStation 4
+//  __RADANDROID__ means Android NDK
+//  __RADNACL__ means Native Client SDK
+//  __RADLINUX__ means Linux (32 or 64-bit)
+//  __RADPSP2__ means PS Vita
+//  __RADQNX__ means QNX
+//  __RADIPHONE__ means iphone
+
+//  __RADARM__ means arm
+//  __RADPPC__ means powerpc
+//  __RADX86__ means x86 or x64
+//  __RADX64__ means x64
+//  __RADX64__ means x64
+
+// __RADNOVARARGMACROS__ means #defines can't use ...
+
+// RADDEFSTART is "extern "C" {" on C++, nothing on C
+// RADDEFEND is "}" on C++, nothing on C
+
+// RADEXPFUNC and RADEXPLINK are used on both the declaration
+//   and definition of exported functions.
+//    RADEXPFUNC int RADEXPLINK exported_func()
+
+// RADDEFFUNC and RADLINK are used on both the declaration
+//   and definition of public functions (but not exported).
+//    RADDEFFUNC int RADLINK public_c_func()
+
+// RADRESTRICT is for non-aliasing pointers/
+
+// RADSTRUCT is defined as "struct" on msvc, and
+//   "struct __attribute__((__packed__))" on gcc/clang
+//   Used to sort of address generic structure packing
+//   (we still require #pragma packs to fix the
+//   packing on windows, though)
+
+
+// ========================================================
+// First off, we detect your platform
+
+#if defined(ANDROID)
+  #define __RADANDROID__ 1
+  #define __RADDETECTED__ __RADANDROID__
+#endif
+
+#if defined(__QNX__)
+  #define __RADQNX__ 2
+  #define __RADDETECTED__ __RADQNX__
+#endif
+
+#if defined(__linux__) && !defined(ANDROID)
+  #define __RADLINUX__ 3
+  #define __RADDETECTED__ __RADLINUX__
+#endif
+
+#if defined(__native_client__)
+  #define __RADNACL__ 4
+  #define __RADDETECTED__ __RADNACL__
+#endif
+
+#if defined(_DURANGO) || defined(_SEKRIT) || defined(_SEKRIT1) || defined(_XBOX_ONE)
+  #define __RADXBOXONE__ 5
+  #define __RADDETECTED__ __RADXBOXONE__
+#endif
+
+#if defined(__ORBIS__)
+  #define __RADPS4__ 6
+  #define __RADDETECTED__ __RADPS4__
+#endif
+
+#if defined(CAFE) 
+  #define __RADWIIU__ 7
+  #define __RADDETECTED__ __RADWIIU__
+#endif
+
+#if defined(NN_PLATFORM_CTR)
+  #define __RAD3DS__ 8
+  #define __RADDETECTED__ __RAD3DS__
+#endif
+
+#if defined(__psp2__)
+  #define __RADPSP2__ 9
+  #define __RADDETECTED__ __RADPSP2__
+#endif
+
+#if defined(__CELLOS_LV2__)
+  #ifdef __SPU__
+    #define __RADSPU__ 10
+    #define __RADDETECTED__ __RADSPU__
+  #else
+    #define __RADPS3__ 11
+    #define __RADDETECTED__ __RADPS3__
+  #endif
+#endif
+
+#if defined(_XENON) || ( defined(_XBOX_VER) && (_XBOX_VER == 200) )
+  #define __RADXENON__ 12
+  #define __RADDETECTED__ __RADXENON__
+#endif
+
+#if !defined(__RADXENON__) && !defined(__RADXBOXONE__) &&( defined(_Windows) || defined(WIN32) || defined(__WINDOWS__) || defined(_WIN32) || defined(_WIN64) || defined(WINAPI_FAMILY) )
+
+  #ifdef WINAPI_FAMILY
+    // If this is #defined, we might be in a Windows Store App. But
+    // VC++ by default #defines this to a symbolic name, not an integer
+    // value, and those names are defined in "winapifamily.h". So if
+    // WINAPI_FAMILY is #defined, #include the header so we can parse it.
+    #include <winapifamily.h>
+    #define RAD_WINAPI_IS_APP (!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP))
+    #if RAD_WINAPI_IS_APP
+      #define __RADWINRTAPI__
+      #define __RADWINRT__ 13
+      #define __RADDETECTED__ __RADWINRT__
+    #endif
+  #else
+    #define RAD_WINAPI_IS_APP 0
+  #endif
+
+  #ifndef __RADWINRT__
+    // if we aren't WinRT, then we are plain old NT
+    #define __RADNT__ 14
+    #define __RADDETECTED__ __RADNT__
+  #endif
+#endif
+
+#if defined(__APPLE__)
+  #include "TargetConditionals.h"
+  #if defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR
+    #define __RADIPHONE__ 15
+    #define __RADIPHONESIM__ 16
+    #define __RADDETECTED__ __RADIPHONESIM__
+  #elif defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+    #define __RADIPHONE__ 15
+    #define __RADDETECTED__ __RADIPHONE__
+  #else
+    #define __RADMAC__ 17
+    #define __RADDETECTED__ __RADMAC__
+  #endif
+#endif
+
+#if !defined(__RADDETECTED__)
+  #error "radtypes.h did not detect your platform."
+#endif
+
+// ========================================================
+// Now detect some architexture stuff
+
+#define __RAD32__ // we have no non-at-least-32-bit cpus any more
+
+#if defined(__arm__) || defined( _M_ARM )
+  #define __RADARM__ 1
+  #define __RADDETECTEDPROC__ __RADARM__
+  #define __RADLITTLEENDIAN__
+#endif
+#if defined(__i386) || defined( __i386__ ) || defined( _M_IX86 ) || defined( _X86_ )
+  #define __RADX86__ 2
+  #if !defined __RADIPHONESIM__
+    // only use mmx on PC, Win, Linux - not iphone sim!
+    #define __RADMMX__
+  #endif
+  #define __RADDETECTEDPROC__ __RADX86__
+  #define __RADLITTLEENDIAN__
+#endif
+#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined( _M_AMD64 )
+  #define __RADX86__ 2
+  #define __RADX64__ 3
+  #define __RADMMX__
+  #define __RADDETECTEDPROC__ __RADX64__
+  #define __RADLITTLEENDIAN__
+#endif
+#if defined(__powerpc) || defined( _M_PPC ) || defined( CAFE ) || defined( _XENON ) || (defined( __CELLOS_LV2__ ) && !defined( __SPU__ ))
+  #define __RADPPC__ 4
+  #if !defined( CAFE ) 
+    #define __RADALTIVEC__
+  #endif
+  #define __RADDETECTEDPROC__ __RADPPC__
+  #define __RADBIGENDIAN__
+#endif
+#if defined( __CELLOS_LV2__ ) && defined( __SPU__ )
+  #define __RADCELLSPU__ 5 
+  #define __RADDETECTEDPROC__ __RADCELLSPU__
+  #define __RADBIGENDIAN__
+#endif
+
+#if !defined(__RADDETECTEDPROC__)
+  #error "radtypes.h did not detect your processor type."
+#endif
+
+#if defined(__ppc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64)
+  #define __RAD64__
+  #define __RAD64REGS__  // need to set this for platforms that aren't 64-bit, but have 64-bit regs (xenon, ps3)
+#endif
+
+
+// ========================================================
+// C++ name demangaling nonsense
+
+#ifdef __cplusplus
+  #define RADDEFFUNC extern "C"
+  #define RADDEFSTART extern "C" {
+  #define RADDEFEND }
+  #define RADDEFAULT( val ) =val
+#else
+  #define RADDEFFUNC
+  #define RADDEFSTART
+  #define RADDEFEND
+  #define RADDEFAULT( val )
+#endif
+
+// ========================================================
+// handle exported function declarations:
+//   in anything with __RADNOEXPORTS__, RADEXPFUNC == nothing (turn off exports with this flag)
+//   in DLL, RADEXPFUNC == DLL export
+//   in EXE, RADEXPFUNC == DLL import
+//   in EXE with RADNOEXEEXPORTS, RADEXPFUNC == nothing (turn off imports in EXE with this flag)
+//   in static lib, RADEXPFUNC == nothing
+#if ( defined(__RADINSTATICLIB__) || defined(__RADNOEXPORTS__ ) || ( defined(__RADNOEXEEXPORTS__) && ( !defined(__RADINDLL__) ) && ( !defined(__RADINSTATICLIB__) ) ) )
+  // if we are in a static lib, or exports are off, or if we are in an EXE we asked for no exe exports (or imports)
+  //   then EXPFUNC is just a normal function
+  #define RADEXPFUNC RADDEFFUNC
+#else
+  // otherwise, we use imprt or export base on the build flag __RADINDLL__
+  #if defined(__RADINDLL__) 
+    #define RADEXPFUNC RADDEFFUNC RADDLLEXPORTDLL
+  #else
+    #define RADEXPFUNC RADDEFFUNC RADDLLIMPORTDLL
+  #endif
+#endif
+
+#if defined(__RADANDROID__)
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADQNX__)
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK RADLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADLINUX__)
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #if defined(__RADX86__) && !defined(__RADX64__)
+    #define RADLINK __attribute__((cdecl))
+    #define RADEXPLINK __attribute__((cdecl))
+  #else
+    #define RADLINK
+    #define RADEXPLINK
+  #endif
+  // for linux, we assume you are building with hidden visibility,
+  //   so for RADEXPFUNC, we turn the vis back on...
+  #define RADDLLEXPORTDLL __attribute__((visibility("default")))
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADNACL__)
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADXBOXONE__)
+  #define __RADDURANGO__  
+  #define __RADWIN__  
+  #define __RADSEKRIT__
+  
+  #define __RADWIN__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct 
+  #define __RADWINRTAPI__
+
+  #define RADLINK __stdcall
+  #define RADEXPLINK __stdcall
+  #define RADDLLEXPORTDLL // we don't use dlls on xbox
+  #define RADDLLIMPORTDLL 
+#endif
+
+#if defined(__RADPS4__)
+  #define __RADSEKRIT2__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADNT__)
+  #define __RADWIN__
+  #if _MSC_VER >= 1400
+    #define RADRESTRICT __restrict
+  #else
+    // vc6 and older
+    #define RADRESTRICT
+    #define __RADNOVARARGMACROS__
+  #endif
+  #define RADSTRUCT struct 
+
+  #define RADLINK __stdcall
+  #define RADEXPLINK __stdcall
+
+  #define RADDLLEXPORTDLL __declspec(dllexport)
+  #ifdef __RADX32__
+    // on weird NT DLLs built to run on Linux and Mac, no imports
+    #define RADDLLIMPORTDLL
+  #else
+    // normal win32 dll import
+    #define RADDLLIMPORTDLL __declspec(dllimport)
+  #endif
+#endif
+
+#if defined(__RADWINRT__)
+  #define __RADWIN__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct 
+
+  #define RADLINK __stdcall
+  #define RADEXPLINK __stdcall
+  #define RADDLLEXPORTDLL __declspec(dllexport)
+  #define RADDLLIMPORTDLL __declspec(dllimport)
+#endif
+      
+#if defined(__RADWIIU__)
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RAD3DS__)
+  #define RADRESTRICT
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADPSP2__)
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADPS3__)
+  #define __RAD64REGS__
+  #define __RADCELL__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADSPU__)
+  #define __RADCELL__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADIPHONE__)
+  #define __RADMACAPI__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  #define RADDLLEXPORTDLL
+  #define RADDLLIMPORTDLL
+#endif
+
+#if defined(__RADMAC__)
+  #define __RADMACH__
+  #define __RADMACAPI__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct __attribute__((__packed__))
+
+  #define RADLINK
+  #define RADEXPLINK
+  // for mac, we assume you are building with hidden visibility,
+  //   so for RADEXPFUNC, we turn the vis back on...
+  #define RADDLLEXPORTDLL __attribute__((visibility("default")))
+  #define RADDLLIMPORTDLL
+
+  #ifdef TARGET_API_MAC_CARBON
+    #if TARGET_API_MAC_CARBON
+      #ifndef __RADCARBON__
+        #define __RADCARBON__
+      #endif
+    #endif
+  #endif
+#endif
+
+#if defined(__RADXENON__)
+  #define __RAD64REGS__
+  #define __RADWIN__
+  #define RADRESTRICT __restrict
+  #define RADSTRUCT struct 
+
+  #define RADLINK __stdcall
+  #define RADEXPLINK __stdcall
+  #define RADDLLEXPORTDLL // we don't use dlls on xbox
+  #define RADDLLIMPORTDLL 
+#endif
+
+#ifndef RADLINK
+  #error RADLINK was not defined.
+#endif
+
+#ifdef _MSC_VER
+  #define RADINLINE __inline
+#else
+  #define RADINLINE inline
+#endif
+
+//===========================================================================
+// RR_STRING_JOIN joins strings in the preprocessor and works with LINESTRING
+#define RR_STRING_JOIN(arg1, arg2)              RR_STRING_JOIN_DELAY(arg1, arg2)
+#define RR_STRING_JOIN_DELAY(arg1, arg2)        RR_STRING_JOIN_IMMEDIATE(arg1, arg2)
+#define RR_STRING_JOIN_IMMEDIATE(arg1, arg2)    arg1 ## arg2
+
+//===========================================================================
+// RR_NUMBERNAME is a macro to make a name unique, so that you can use it to declare
+//    variable names and they won't conflict with each other
+// using __LINE__ is broken in MSVC with /ZI , but __COUNTER__ is an MSVC extension that works
+
+#ifdef _MSC_VER
+  #define RR_NUMBERNAME(name) RR_STRING_JOIN(name,__COUNTER__)
+#else
+  #define RR_NUMBERNAME(name) RR_STRING_JOIN(name,__LINE__)
+#endif
+
+//===================================================================
+// simple compiler assert
+// this happens at declaration time, so if it's inside a function in a C file, drop {} around it
+#ifndef RR_COMPILER_ASSERT
+  #define RR_COMPILER_ASSERT(exp)   typedef char RR_NUMBERNAME(_dummy_array) [ (exp) ? 1 : -1 ]
+#endif
+
+
+//===========================================
+// first, we set defines for each of the types
+
+#define RAD_S8 signed char
+#define RAD_U8 unsigned char
+#define RAD_U16 unsigned short
+#define RAD_S16 signed short
+
+#if defined(__RAD64__) 
+  #define RAD_U32 unsigned int
+  #define RAD_S32 signed int
+
+  // pointers are 64 bits.
+  #if (_MSC_VER >= 1300 && defined(_Wp64) && _Wp64 )
+    #define RAD_SINTa __w64 signed __int64
+    #define RAD_UINTa __w64 unsigned __int64
+  #else 
+    // non-vc.net compiler or /Wp64 turned off
+    #define RAD_UINTa unsigned long long
+    #define RAD_SINTa signed long long
+  #endif
+#endif
+
+#if defined(__RAD32__) && !defined(__RAD64__)
+  #define RAD_U32 unsigned int
+  #define RAD_S32 signed int
+
+  #if ( ( defined(_MSC_VER) && (_MSC_VER >= 1300 ) ) && ( defined(_Wp64) && ( _Wp64 ) ) )
+    #define RAD_SINTa __w64 signed long
+    #define RAD_UINTa __w64 unsigned long
+  #else 
+    // non-vc.net compiler or /Wp64 turned off
+    #ifdef _Wp64
+      #define RAD_SINTa signed long
+      #define RAD_UINTa unsigned long
+    #else
+      #define RAD_SINTa signed int
+      #define RAD_UINTa unsigned int
+    #endif
+  #endif
+#endif
+
+#define RAD_F32 float
+#define RAD_F64 double
+
+#if defined(_MSC_VER)
+  #define RAD_U64 unsigned __int64
+  #define RAD_S64 signed __int64
+#else
+  #define RAD_U64 unsigned long long
+  #define RAD_S64 signed long long
+#endif
+
+
+//================================================================
+// Then, we either typedef or define them based on switch settings
+
+#if !defined(RADNOTYPEDEFS)  // this define will turn off typedefs
+
+  #ifndef S8_DEFINED
+  #define S8_DEFINED
+  typedef RAD_S8 S8;
+  #endif
+
+  #ifndef U8_DEFINED
+  #define U8_DEFINED
+  typedef RAD_U8 U8;
+  #endif
+
+  #ifndef S16_DEFINED
+  #define S16_DEFINED
+  typedef RAD_S16 S16;
+  #endif
+
+  #ifndef U16_DEFINED
+  #define U16_DEFINED
+  typedef RAD_U16 U16;
+  #endif
+
+  #ifndef S32_DEFINED
+  #define S32_DEFINED
+  typedef RAD_S32 S32;
+  #endif
+
+  #ifndef U32_DEFINED
+  #define U32_DEFINED
+  typedef RAD_U32 U32;
+  #endif
+
+  #ifndef S64_DEFINED
+  #define S64_DEFINED
+  typedef RAD_S64 S64;
+  #endif
+
+  #ifndef U64_DEFINED
+  #define U64_DEFINED
+  typedef RAD_U64 U64;
+  #endif
+
+  #ifndef F32_DEFINED
+  #define F32_DEFINED
+  typedef RAD_F32 F32;
+  #endif
+
+  #ifndef F64_DEFINED
+  #define F64_DEFINED
+  typedef RAD_F64 F64;
+  #endif
+
+  #ifndef SINTa_DEFINED
+  #define SINTa_DEFINED
+  typedef RAD_SINTa SINTa;
+  #endif
+
+  #ifndef UINTa_DEFINED
+  #define UINTa_DEFINED
+  typedef RAD_UINTa UINTa;
+  #endif
+
+  #ifndef RRBOOL_DEFINED
+    #define RRBOOL_DEFINED
+    typedef S32 rrbool;
+    typedef S32 RRBOOL;
+  #endif
+
+#elif !defined(RADNOTYPEDEFINES)  // this define will turn off type defines
+
+  #ifndef S8_DEFINED
+  #define S8_DEFINED
+  #define S8 RAD_S8
+  #endif
+
+  #ifndef U8_DEFINED
+  #define U8_DEFINED
+  #define U8 RAD_U8
+  #endif
+
+  #ifndef S16_DEFINED
+  #define S16_DEFINED
+  #define S16 RAD_S16
+  #endif
+
+  #ifndef U16_DEFINED
+  #define U16_DEFINED
+  #define U16 RAD_U16
+  #endif
+
+  #ifndef S32_DEFINED
+  #define S32_DEFINED
+  #define S32 RAD_S32
+  #endif
+
+  #ifndef U32_DEFINED
+  #define U32_DEFINED
+  #define U32 RAD_U32
+  #endif
+
+  #ifndef S64_DEFINED
+  #define S64_DEFINED
+  #define S64 RAD_S64
+  #endif
+
+  #ifndef U64_DEFINED
+  #define U64_DEFINED
+  #define U64 RAD_U64
+  #endif
+
+  #ifndef F32_DEFINED
+  #define F32_DEFINED
+  #define F32 RAD_F32
+  #endif
+
+  #ifndef F64_DEFINED
+  #define F64_DEFINED
+  #define F64 RAD_F64
+  #endif
+
+  #ifndef SINTa_DEFINED
+  #define SINTa_DEFINED
+  #define SINTa RAD_SINTa
+  #endif
+
+  #ifndef UINTa_DEFINED
+  #define UINTa_DEFINED
+  #define UINTa RAD_UINTa
+  #endif
+
+  #ifndef RRBOOL_DEFINED
+    #define RRBOOL_DEFINED
+    #define rrbool S32
+    #define RRBOOL S32
+  #endif
+
+#endif
+
+#endif // __RADRES__
+
+#endif // __RADTYPESH__
diff --git a/thirdparty/telemetry/include/telemetry.h b/thirdparty/telemetry/include/telemetry.h
new file mode 100644
index 0000000..895229b
--- /dev/null
+++ b/thirdparty/telemetry/include/telemetry.h
@@ -0,0 +1,1317 @@
+#ifndef TELEMETRY_H
+#define TELEMETRY_H
+
+//-------------------------------------------------------------------
+// Documentation stuff
+//-------------------------------------------------------------------
+#ifndef EXPAPI
+#define EXPAPI
+#endif
+#ifndef EXPMACRO
+#define EXPMACRO
+#endif
+#ifndef EXPCONST
+#define EXPCONST
+#endif
+#ifndef EXPOUT
+#define EXPOUT
+#endif
+#ifndef EXPGROUP
+#define EXPGROUP(GroupName)
+#endif
+#ifndef EXPTYPEBEGIN
+#define EXPTYPEBEGIN
+#endif
+#ifndef EXPTYPEEND
+#define EXPTYPEEND
+#endif
+#ifndef EXPTYPE
+#define EXPTYPE
+#endif
+
+EXPGROUP(_NullGroup)
+
+#define TelemetryRunTimeVersion   "2.0P"   EXPMACRO
+#define LTelemetryRunTimeVersion L"2.0P"   EXPMACRO
+#define Telemetry2Version   "2.0P"   EXPMACRO
+#define LTelemetry2Version L"2.0P"   EXPMACRO
+
+#define TelemetryMajorVersion    2  EXPMACRO    
+#define TelemetryMinorVersion    0  EXPMACRO    
+#define TelemetryBuildNumber    56  EXPMACRO    
+#define TelemetryCustomization   0  EXPMACRO    
+
+#ifndef TelemetryToolsVersion
+#define TelemetryToolsVersion  TelemetryRunTimeVersion
+#define LTelemetryToolsVersion LTelemetryRunTimeVersion
+#endif
+
+#define TelemetrySalesEMailAddress "[email protected]" EXPMACRO 
+#define TelemetrySalesPhoneNumber "425-893-4300" EXPMACRO             
+#define TelemetryCompanyName "RAD Game Tools, Inc." EXPMACRO
+#define TelemetryCopyright "Copyright (C) 2009-2014, RAD Game Tools, Inc."  EXPMACRO 
+#define TelemetryTrademarks "Telemetry is a registered trademark of RAD Game Tools" EXPMACRO
+#define TelemetrySupportAddress "[email protected]" EXPMACRO 
+#define TelemetrySupportPage "www.radgametools.com/telemetry.htm" EXPMACRO
+#define TelemetryCompanyPage "http://www.radgametools.com" EXPMACRO
+#define TelemetryOnLineChangelogAddress "www.radgametools.com/telemetry/changelog.htm" EXPMACRO
+
+#ifndef __RADRES__
+
+EXPGROUP(TMAPI)
+
+//-------------------------------------------------------------------
+// Important manifest constants:
+//
+// --- The following should _not_ be set by the end user! ---
+//
+// TM_INLINE_FASTTIME - DO NOT CHANGE THIS!!
+// TM_DLL - is set to 1 if building the library as a DLL
+// TM_API_STATIC - functions are statically linked directly and not going through a function pointer table
+// TM_BUILD_LIB - should be set to 1 when building the library
+// TM_HARDLINK  - we're statically linking (not using a DLL)
+//
+// TM_IPC_CLIENT - set to 1 if building the library as an IPC client
+//    * assumes communication is NOT over a network
+//    * assumes single threading
+// TM_IPC_HOST - set to 1 if building the library as an IPC server
+//    * assumes subprocesses use IPC for communication
+//    * IPC mechanism not assumed
+//
+// --- The following can be set by the enduser ---
+//
+// NTELEMETRY - set to 1 if you want to compile away the library
+//
+//-------------------------------------------------------------------
+#define TM_INLINE_FASTTIME 1
+
+#define TM_MAX_OBJECT_PATH 64 EXPMACRO // Maximum length of a path string
+#define TM2_MAX_OBJECT_PATH (1024*8) EXPMACRO // Maximum length of a path string
+#define TM_MAX_STRING   (1024*8) EXPMACRO // Maximum length of a string that you can pass to Telemetry.
+#define TM_MAX_EXTRA_DATA 256 EXPMACRO          // Maximum amount of variable length string data
+#define TM_MAX_EVENT_FILENAME 320 EXPMACRO // Longest length for a filename used with a Telemetry event
+
+#define TM_VA_LIST ((char const *)1) EXPMACRO // Specifies that a va_list is being passed to the function.  See $ug_valist for more information.
+
+#define TM_LOCK_MIN_TIME_BUFSIZE 512 EXPMACRO // Size of buffer necessary for tmSetLockStateMinTime
+
+#ifndef TM_CAT
+#define TM_CAT( s1, s2 ) s1##s2
+#endif 
+
+#ifndef TM_FUNCTION_TYPE
+#define TM_FUNCTION_TYPE(name) TM_CAT(name,type)
+#endif
+
+//-----------------------------------------------------------------------------
+// Base types
+//----------------------------------------------------------------------------- 
+#if defined __RADARM__ || defined __RADWIIU__
+#define TM_SLOW 1 EXPMACRO // If defined then reading timestamps is slow on this platforms, so adjust your markup accordingly
+#endif
+
+#ifdef TM_DLL
+#ifndef __RADINDLL__
+#define __RADINDLL__
+#endif
+#endif
+
+// NOTE: Need to include this before the __RADNT__ check
+//#ifndef NTELEMETRY
+#include "tmtypes.h"
+//#endif
+
+#if !defined __RADQNX__ && !defined __RADSPU__ && !defined __RADNT__ && !defined __RADXENON__ && !defined __RADANDROID__ && !defined __RADSEKRIT__ && !defined __RADPS4__ && !defined __RADPS3__ && !defined __RADIPHONE__ && !defined __RADWIIU__ && !defined __RADLINUX__ && !(defined __RADMAC__ && !defined __RADPPC__) && !defined __RADPSP2__ && !defined NTELEMETRY
+#define NTELEMETRY 1
+#endif
+
+#if defined __RADSPU__ && !defined TM_IPC_CLIENT
+#define TM_IPC_CLIENT 1
+#endif
+
+#if defined __RADPS3__ && !defined TM_IPC_HOST
+#define TM_IPC_HOST 1
+#endif
+
+#if defined __RADSPU__ || defined __RADPS3__
+#define TM_SPU_CONTEXT_SIZE     (2*1024) EXPMACRO // Required size for a Telemetry context on the SPU
+#endif
+
+#ifdef TM_IPC_CLIENT
+#define TM_SINGLE_THREADED 1
+#endif
+
+#if defined __RADXENON__ || defined __RADSEKRIT__ || defined __RADPS4__ || defined __RADIPHONE__ || defined __RADANDROID__ || defined __RADPS3__ || defined __RADWIIU__ || defined __RADPSP2__ || defined __RADQNX__
+#define TM_HARDLINK 1
+#endif
+
+#if !defined RADEXPLINK && !defined NTELEMETRY
+#define RADEXPLINK
+#endif
+
+#ifndef RADDEFSTART
+#define RADDEFEND }
+#define RADDEFSTART extern "C" {
+#endif
+
+#if defined __RADSPU__
+#define TM_API_STATIC 1
+#endif
+
+#ifndef TM_API
+#ifdef TM_API_STATIC
+#define TM_API( ret, name, params ) ret RADEXPLINK name params
+#else
+#define TM_API( ret, name, params ) typedef ret (RADEXPLINK *TM_FUNCTION_TYPE(name))params
+#endif
+#endif
+
+#ifndef TMCHECKCONTEXT
+#ifdef TM_API_STATIC
+#define TMCHECKCONTEXTR(c,n,f,z) ( (c) ? ( n f ) : (z) )
+#define TMCHECKCONTEXTV(c,n,f) { if (c) { n f ; } }
+#else
+#define TMCHECKCONTEXTR(c,n,f,z) ( (c) ? ( ((TM_API_STRUCT*)(c))->n f) : (z) )
+#define TMCHECKCONTEXTV(c,n,f) { if (c) { ( ((TM_API_STRUCT*)(c))->n f); } }
+#endif
+
+#define TMCHECKCONTEXT_VA(c,n,f) { static TmFormatCode tm_fmt; TMCHECKCONTEXTV(c,n,f); }
+#define TMCHECKCONTEXT(c,n,f)  TMCHECKCONTEXTR(c,n,f,TMERR_INVALID_CONTEXT)
+#endif
+
+//-----------------------------------------------------------------------------
+// Call stack
+//-----------------------------------------------------------------------------
+#define TM_MAX_CALLSTACK_DEPTH 32 //This value cannot change without affecting the server protocol!!
+EXPTYPE typedef struct _TmCallStack
+{
+    int    cs_depth;
+    void  *cs_stack[ TM_MAX_CALLSTACK_DEPTH ];
+} TmCallStack;
+
+//-----------------------------------------------------------------------------
+// Error codes
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmErrorCode
+{ 
+    TM_OK                   = 0x0000, // Everything is okay
+    TMERR_DISABLED          = 0x0001, // Telemetry has been compiled away with $NTELEMETRY 
+    TMERR_INVALID_CONTEXT   = 0x0002, // The context passed to Telemetry was invalid
+    TMERR_INVALID_PARAM     = 0x0003, // Out of range, null pointer, etc.
+    TMERR_OUT_OF_RESOURCES  = 0x0004, // Typically out of available memory, string space, etc.
+    TMERR_UNINITIALIZED     = 0x0006, // A Telemetry API was called before $tmStartup
+    TMERR_BAD_HOSTNAME      = 0x0007, // Could not resolve hostname
+    TMERR_COULD_NOT_CONNECT = 0x0008, // Could not connect to the server
+    TMERR_UNKNOWN_NETWORK   = 0x0009, // Unknown error in the networking system 
+    TMERR_ALREADY_SHUTDOWN  = 0x000A, // $tmShutdown called more than once 
+    TMERR_ARENA_TOO_SMALL   = 0x000B, // buffer passed to $tmInitializeContext was too small
+    TMERR_BAD_HANDSHAKE     = 0x000C, // handshake with server failed (protocol error)
+    TMERR_UNALIGNED         = 0x000D, // One more more parameters were not aligned correctly
+    TMERR_NETWORK_NOT_INITIALIZED = 0x000E, // Network startup functions were not called, e.g. WSAStartup
+    TMERR_BAD_VERSION             = 0x000F, // You're using an out of date version of the Telemetry libraries
+    TMERR_BAD_TIMER               = 0x00A0, // The provided user timer is too coarse for Telemetry
+  TMERR_UNKNOWN           = 0xFFFF  // Unknown error occurred
+} TmErrorCode;
+/*
+Standard errors returned by Telemetry.
+
+Standard errors returned by Telemetry.  Most Telemetry functions return void, so the
+standard Telemetry method for checking errors is to call $tmGetLastError.  In some cases, e.g.
+when a context is unavailable or unnecessary, a Telemetry API may return an error code directly.
+$-
+See also $ug_errors
+*/
+
+//-----------------------------------------------------------------------------
+// Printf-style tokens, reserved for Telemetry internal use only
+//-----------------------------------------------------------------------------
+typedef enum TmPrintfToken
+{
+    TMPRINTF_TOKEN_NONE = 0,
+    TMPRINTF_TOKEN_CALLSTACK = 1
+} TmPrintfToken;
+
+//-----------------------------------------------------------------------------
+// Connection status
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmConnectionStatus
+{
+    TMCS_DISCONNECTED = 0, //Not connected to a server
+    TMCS_CONNECTING   = 1, //Attempting a connection to a server
+    TMCS_CONNECTED    = 2  //Connected to a server
+} TmConnectionStatus;
+/*
+Connection status returned by $tmGetConnectionStatus.
+*/
+
+#ifndef NTELEMETRY
+//-----------------------------------------------------------------------------
+// Zone flags
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmZoneFlag
+{
+    TMZF_NONE                      = 0x0000,      // Zone is normal.
+    TMZF_STALL                     = 0x0001,      // Zone is stalling while waiting on a lock, etc.  Implies thread is busy but can't progress.
+    TMZF_IDLE                      = 0x0002,      // Zone is sleeping/idle until something new happens.  Implies thread is idle. 
+    TMZF_PROFILER_ONLY             = 0x0004,      // Telemetry 1 only: Only show this zone in the profiler view, not in the zone view
+
+    TMZF_MEM_REGION_EXPERIMENTAL   = 0x0010,      // Only show this zone in the profiler view, not in the zone view
+
+    TMZF_PLOT_TIME                 = 0x0100,      // Generate plot of the zone's duration on the server
+    TMZF_PLOT_TIME_EXPERIMENTAL = TMZF_PLOT_TIME, // Retained for backward compatibility
+
+    // Everything from here on out is for Telemetry internal use only, do not use!!!!!
+    TMZF_INTERNAL_ACCUMULATOR     = 0x10000, //For Telemetry internal use only
+    TMZF_INTERNAL_LOCK_STALL      = 0x20000, //For Telemetry internal use only
+    TMZF_INTERNAL_OPEN_ENDED      = 0x40000, //For Telemetry internal use only
+    TMZF_INTERNAL_CONTINUATION    = 0x80000, //For Telemetry internal use only
+
+    TMZF_INTERNAL_DISCARD          = 0x100000, //For Telemetry internal use only; this constant is used by the run-time and server for different things
+    TMZF_INTERNAL_DISCARD_SERVER   = 0x100000, //For Telemetry internal use only; this constant is shared but used differently by run time and server
+    TMZF_INTERNAL_NO_INSERT_SERVER = 0x200000, //For Telemetry internal use only (server only)
+    TMZF_INTERNAL_LOD_ZONE         = 0x400000, //For Telemetry internal use only (server only)
+
+    // Not really flags...
+    TMZF_INTERNAL_LOCK_FAILED    = 0x10000000, //For Telemetry internal use only
+    TMZF_INTERNAL_LOCK_SUCCESS   = 0x20000000, //For Telemetry internal use only
+    TMZF_INTERNAL_LOCK_TIMEOUT   = 0x30000000, //For Telemetry internal use only
+
+} TmZoneFlag;
+/*
+Bitmasks that can be ORed together when calling tmZone, tmCoreEnter, tmCoreLeave, tmEnter or tmLeave.
+*/
+#define TMZF_INTERNAL_ANY_MASK ( TMZF_INTERNAL_ACCUMULATOR | TMZF_INTERNAL_LOCK_STALL | TMZF_INTERNAL_OPEN_ENDED | TMZF_INTERNAL_CONTINUATION | TMZF_INTERNAL_LOCK_FAILED | TMZF_INTERNAL_LOCK_TIMEOUT )
+
+//-----------------------------------------------------------------------------
+// Timespan flags
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmTimeSpanFlag
+{
+    TMTSF_NONE  = 0x0000,               // Timespan is normal.
+} TmTimeSpanFlags;
+/*
+Bitmasks that can be ORed together when calling tmBeginTimeSpan and tmEndTimeSpan
+*/
+
+//-----------------------------------------------------------------------------
+// Plot type
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmPlotType
+{
+    TMPT_NONE   = 0,               // Display as raw float data
+    TMPT_MEMORY = 1,               // Display as contextually relevant memory, i.e. bytes, kb, MB, GB, TB, etc.
+    TMPT_HEX    = 2,               // Display as hex value based on range
+    TMPT_INTEGER = 3,              // Display as integer, no decimal points
+    TMPT_UNTYPED = 3,              // Data is untyped and should be displayed as an integer (this is the same as TMPT_INTEGER)
+    TMPT_PERCENTAGE_COMPUTED = 4,  // Display as a percentage of the max, i.e. as (value-min)/(max-min), computed by the client
+    TMPT_PERCENTAGE_DIRECT = 5,    // Display as a percentage (i.e. 0.2187 => 21.87%).  For I32/U32 it expects 0..100
+    TMPT_TIME = 6,                 // Display in timecode format, i.e. hh:mm:dd:ss.xxx 
+    TMPT_TIME_MS = 7,              // Floating point milliseconds
+    TMPT_TIME_US = 8,              // Floating point microseconds
+    TMPT_TIME_CLOCKS = 9,          // I64 clock cycles
+    TMPT_TIME_INTERVAL = 10,       // This plot's value should be the delta between this time and the last call to tmPlot for this plot
+    TMPT_USER = 128,               // Reserved for user types
+    TMPT_MAX = 255
+} TmPlotType;
+/*
+Passed to $(tmPlot) to specify how the Visualizer should present the data.
+*/
+
+//-----------------------------------------------------------------------------
+// Plot flags
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmPlotFlag
+{
+    TMPF_NONE           = 0x0000,       // No additional flags
+    TMPF_MINVAL_ZERO    = 0x0001,       // Set plot's minval to 0 instead of actual minval
+    TMPF_FRAMETIME      = 0x0002,       // This plot is being used to measure frame times
+
+    TMPF_INTERNAL_SYNTHETIC = 0x10000   // Internal use only!
+} TmPlotFlag;
+/*
+Passed to $(tmPlot) to specify how the Visualizer should present the data.  These are available in Telemetry 2 only!
+*/
+
+#endif // NTELEMETRY
+
+
+EXPTYPE typedef struct TmContext*        HTELEMETRY;
+/*
+Opaque handle to a Telemetry context.
+
+Telemetry binds the majority of its state to a context.  This context is allocated and
+passed in by the application, and must be available and valid through the life of the
+Telemetry session.  The context is initialized with $tmInitializeContext and shut down
+with $tmShutdownContext.
+
+An application can have multiple contexts, but each context will open a separate
+connection to the server and create its own individual session.  This should rarely
+be required, but in some instances is unavoidable, for example you are writing a 
+middleware component and need to be able to instrument your code without necessarily
+having access to the code base in which you're embedded (which, in turn, may have its
+own Telemetry context).
+*/
+
+RADDEFSTART
+
+//-----------------------------------------------------------------------------
+// Message flags
+//-----------------------------------------------------------------------------
+#ifndef NTELEMETRY
+EXPTYPE typedef enum TmMessageFlag
+{
+    TMMF_SEVERITY_LOG         = 0x0001,         // Regular log message
+    TMMF_SEVERITY_WARNING     = 0x0002,         // Warning
+    TMMF_SEVERITY_ERROR       = 0x0004,         // Error
+    TMMF_SEVERITY_RESERVED    = 0x0008,         // For future expansion
+    TMMF_SEVERITY_MASK        =    0xF,         // Low 3-bits determine the message type
+
+    TMMF_ZONE_LABEL           = 0x0010,         // Replace zone label with this text
+    TMMF_ZONE_SUBLABEL        = 0x0020,         // Print secondary zone label with text
+    TMMF_ZONE_SHOW_IN_PARENTS = 0x0040,         // Show this not only in the zone's tooltip, but also in the tooltips of any parents
+    TMMF_ZONE_RESERVED01      = 0x0080,
+    TMMF_ZONE_MASK            = 0x00F0,
+
+    // We have up to 15 icon types
+    TMMF_ICON_EXCLAMATION     =  0x1000,         // Show exclamation marker in the zone view for this message
+    TMMF_ICON_NOTE            =  0x2000,         // Show note marker in the zone view for this message
+    TMMF_ICON_WTF             =  0x3000,         // Show "question mark/WTF?" marker in the zone view for this message
+    TMMF_ICON_QUESTION_MARK   = TMMF_ICON_WTF,
+    TMMF_ICON_EXTRA00         =  0x4000,         // These are placeholders for now until we get some nicer icons
+    TMMF_ICON_EXTRA01         =  0x5000,         // 
+    TMMF_ICON_EXTRA02         =  0x6000,         // 
+    TMMF_ICON_EXTRA03         =  0x7000,         // 
+    TMMF_ICON_EXTRA04         =  0x8000,         // 
+    TMMF_ICON_MASK            =  0xF000,
+
+    // Special message tags
+    TMMF_UNUSED00     = 0x10000,
+    TMMF_UNUSED01     = 0x20000,         // Used by tmSetTimelineSectionName
+
+    // Internal use only
+    // We can expand these later and make them either incremental like icons or do
+    // an expansion mask and overflow into another variable...
+    TMMF_INTERNAL_PLOT     = 0x10000000,
+    TMMF_INTERNAL_MEMORY   = 0x20000000,
+    TMMF_INTERNAL_TIMESPAN = 0x30000000,
+    TMMF_INTERNAL_LOCK     = 0x40000000,
+
+    TMMF_INTERNAL_ANY_MASK = 0x70000000
+} TmMessageFlag;
+/*
+Passed to $tmMessage to determine how to present the message to the end user.
+*/
+
+//-----------------------------------------------------------------------------
+// Open flags
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmOpenFlag
+{
+    TMOF_INIT_NETWORKING           = 0x0001,      // Initialize operating system networking layer.  Specify this if you do not already call the platform specific network startup functions (e.g. WSAStartup) prior to $tmOpen.
+    TMOF_DONT_KILL_OTHER_SESSIONS  = 0x0002,      // If set the server should NOT kill any other sessions from this machine with the same app name.
+
+    // This is an enumeration
+    TMOF_DISABLE_CONTEXT_SWITCHES  = 0x0000,      // Disable context switch event tracking entirely.  None are sent to server.  See $ug_cswitches_overview for more information.
+    TMOF_MODERATE_CONTEXT_SWITCHES = 0x0010,      // Send relevant context switches only (e.g. on PS4 it will not send context switches for the two system cores).  See $ug_cswitches_overview for more information.
+    TMOF_MINIMAL_CONTEXT_SWITCHES  = 0x0020,      // Currently the same as "moderate" context switches.
+    TMOF_MAXIMUM_CONTEXT_SWITCHES  = 0x0030,      // Send all context switches. See $ug_cswitches_overview for more information.
+    TMOF_CONTEXT_SWITCH_MASK       = 0x0030,
+
+    TMOF_NO_PDB_LOOKUP             = 0x0040,      // If specified then don't search all loaded DLLs for PDB signatures
+} TmOpenFlag;
+/*
+Passed to $tmOpen.
+*/
+
+#ifdef __RADXENON__
+#define TMOF_DEFAULT TMOF_MODERATE_CONTEXT_SWITCHES  // Default open flags
+#else
+#define TMOF_DEFAULT 0  // Default open flags
+#endif
+
+/*
+Flags passed to $tmOpen
+*/
+
+#define TELEMETRY_DEFAULT_PORT 0 EXPMACRO  //Constant used to specify the default Telemetry port when calling $tmOpen
+//-----------------------------------------------------------------------------
+// Connection type
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmConnectionType
+{
+    TMCT_TCP,           // Connect to Telemetry server over TCP/IP
+    TMCT_IPC,           // Use an IPC connection (not supported on all platforms)
+    TMCT_FILE,          // Store all data to local disk (not supported on all platforms)
+
+    TMCT_USER_PROVIDED, // Use the user defined callbacks for all file i/o
+} TmConnectionType;
+/* 
+Determines how the application will connect to the Telemetry server.
+
+Specified in $tmOpen.  In the future we may support additional communication methods such
+as interprocess communication, USB connections, shared files, etc.
+$-
+For more information on recording-to-disk (instead of recording over a network) see $localfiles.
+$-
+*/
+
+//-----------------------------------------------------------------------------
+// Telemetry options
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmOption
+{
+    TMO_OUTPUT_DEBUG_INFO       = 0x0001,  // Print debug output to the debugger window if possible
+    TMO_RECORD_TELEMETRY_STALLS = 0x0002,  // Record stalls within Telemetry itself
+
+    TMO_RECORD_CALLSTACKS       = 0x0004,  // Record callstacks if requested
+
+    TMO_BOOST_PRIORITY          = 0x0008,  // Temporarily boost priority for Telemetry events to help with priority inversion issues
+
+    TMO_SUPPORT_ZONES       = 0x0100,      // Send zones
+    TMO_SUPPORT_MESSAGES    = 0x0200,      // Send messages
+
+    TMO_SUPPORT_LOCK_STATES = 0x0400,      // Send lock states
+
+    TMO_SUPPORT_MEMORY      = 0x0800,      // Send memory events
+    TMO_SUPPORT_PLOT        = 0x1000,      // Send plots
+    TMO_SUPPORT_BLOB         = 0x2000,     // Send user blobs
+
+    TMO_PPU_SYNCHRONIZE_SPUS     = 0x4000,  // Lockstep PPU-to-SPU communication
+    TMO_SUPPORT_CONTEXT_SWITCHES = 0x8000,  // Support context switch recording on supported platforms
+
+    TMO_NULL_NETWORK        = 0x10000,       // Disable network traffic
+
+    TMO_SUPPORT_TIMESPANS   = 0x20000,       // Disable timespans
+
+} TmOption;
+/*
+Option values that can be toggled during recording using $tmEnable.
+*/
+
+//-----------------------------------------------------------------------------
+// Telemetry variables
+//-----------------------------------------------------------------------------
+EXPAPI typedef void TmDebugPrinter(char const *msg);
+/*
+User defined debug print function.
+*/
+
+typedef int (*TMFNC_USERCB_OPEN)(void* user, char const *fname );
+typedef int (*TMFNC_USERCB_CLOSE)(void* user);
+typedef int (*TMFNC_USERCB_WRITE)(void* user,void const* data,int datasize);
+
+EXPTYPE typedef enum TmParameter
+{
+    TMP_NONE              = 0x0000,
+
+    TMP_LOCK_MIN_TIME    = 1,         // pass in a pointer to TmI32, >= 0 in microseconds  
+    TMP_DEBUG_PRINTER    = 2,         // pass in a pointer to a $TmDebugPrinter
+    TMP_TELEMETRY_PREFERRED_CPU = 3,  // pass in a pointer to a TmI32 with the preferred CPU for Telemetry's background thread
+
+    TMP_USERCB_OPEN = 4,
+    TMP_USERCB_CLOSE = 5,
+    TMP_USERCB_WRITE = 6,
+    TMP_USERCB_DATA = 7,
+
+    TMP_EMULATED_SERVER_VERSION = 8,
+
+    TMP_SOCKET_BUFFER_SIZE = 9,
+
+} TmParameter;
+/*
+Parameter values that can be set using $tmSetParameter
+*/
+
+EXPTYPE typedef enum TmServerConfiguration
+{
+    TMSC_MEM_PLOT_THRESHOLD    = 0,  // Delta memory usage that triggers a plot for memory usage on the server.  Value passed to $tmSetServerConfiguration should be a 64-bit integer.
+} TmServerConfiguration;
+/*
+Parameter values that can be set using $tmSetServerConfiguration
+*/
+
+EXPTYPE typedef enum TmPlatformInformation
+{
+    TMPI_TELEMETRY_THREAD          = 0,  // Thread handle of the telemetry processing background thread.  Windows/360/XB1/PS3/PS4 only.  pIn should be your Telemetry context.  pOut should be a pointer to a HANDLE/sys_ppu_thread_t/ScePthread
+    TMPI_CONTEXT_SWITCH_THREAD     = 1,  // Thread handle of the context switch processing background thread.  Windows Vista/7/360 only.  pIn should be your Telemetry context.  pOut sould be a pointer to a HANDLE.
+    TMPI_START_TIME                = 2,  // Initial start time (in cycles) that Telemetry is basing its relative times from.  pIn should be your Telemetry context.  pOut should be a pointer to a U64.
+} TmPlatformInformation;
+
+/*
+Platform information values that can be passed to $tmGetPlatformInformation
+*/
+
+//-----------------------------------------------------------------------------
+// Lock state
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmLockState
+{
+    TMLS_RELEASED            = 0x00000001,        // Lock was released
+    TMLS_LOCKED              = 0x00000002,        // Lock was acquired
+    TMLS_DESTROYED           = 0x00000004,        // Lock was destroyed
+
+    TMLS_INTERNAL_MASK         = 0xF0000000,
+    TMLS_INTERNAL_TIMESPAN     = 0x10000000,     // This is a timespan, not a lock
+    TMLS_INTERNAL_LOD_LOCK     = 0x20000000,     // Internally generated by Telemetry, DO NOT USE.
+    TMLS_INTERNAL_FAKE         = 0x40000000,     // Internally generated by Telemetry, DO NOT USE.
+    TMLS_INTERNAL_COUNT        = 0x80000000,     // Internally generated by Telemetry, DO NOT USE.
+} TmLockState;
+/*
+Lock state value passed to $tmSetLockState
+
+See also $ug_mutexes
+*/
+
+//-----------------------------------------------------------------------------
+// Lock attempt result
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmLockResult
+{
+    TMLR_SUCCESS  = 0,        // Lock attempt succeeded
+    TMLR_FAILED   = 1,        // Lock attempt failed
+    TMLR_TIMEOUT  = 2,        // Lock attempt timed out
+} TmLockResult;
+/*
+Passed to $tmEndTryLock to specify the result of the lock action.
+
+See also $ug_mutexes
+*/
+
+//-----------------------------------------------------------------------------
+// Telemetry statistics
+//-----------------------------------------------------------------------------
+EXPTYPE typedef enum TmStat
+{
+    TMSTAT_NUM_ALLOCS_DEPRECATED,     // Number of allocs this tick
+    TMSTAT_NUM_FREES_DEPRECATED,      // Number of frees this tick
+
+    TMSTAT_NUM_TICKS_DEPRECATED,      // Number of ticks so far
+} TmStat;
+/*
+Passed to $tmGetStati
+*/
+#endif
+
+#ifndef NTELEMETRY
+
+#if defined __RADPS3__
+#define TM_NUM_SPUS 6
+TM_API( TmErrorCode, tmPPUCoreGetListener, ( HTELEMETRY cx, int const kNdx, TmU32 *pListener ) );
+TM_API( TmErrorCode, tmPPUCoreRegisterSPUProgram, ( HTELEMETRY cx, TmU64 const kGuid, void const *imagebase, unsigned int const kImageSize, int const kRdOnlyOffset ) );
+#endif
+
+#if defined __RADSPU__
+TM_API( TmErrorCode, tmSPUCoreBindContextToListener, ( HTELEMETRY *pcx, void * mem, TmU32 kPPUListener, char const *imagename, ...) );
+TM_API( TmErrorCode, tmSPUCoreUpdateTime, ( HTELEMETRY cx ) );
+TM_API( TmErrorCode, tmSPUCoreFlushImage, ( HTELEMETRY cx ) );
+#endif
+ 
+TM_API( TmU32, tmCoreGetVersion, ( void ) );
+TM_API( TmErrorCode, tmCoreCheckVersion, ( HTELEMETRY cx, TmU32 const major, TmU32 const minor, TmU32 const build, TmU32 const cust ) );
+TM_API( TmErrorCode, tmCoreGetPlatformInformation, ( void* obj, TmPlatformInformation const kInfo, void* dst, TmU32 const kDstSize ) );
+TM_API( TmErrorCode, tmCoreGetLastError, ( HTELEMETRY cx ) );
+TM_API( TmErrorCode, tmCoreGetSessionName, ( HTELEMETRY cx, char *dst, int const kDstSize ) );
+TM_API( TmConnectionStatus, tmCoreGetConnectionStatus, ( HTELEMETRY cx ) );
+
+#ifndef __RADSPU__
+
+RADDEFFUNC typedef TmU64 TMUSERTIMERFNC( void ); // User defined timing function
+
+TM_API( TmErrorCode, tmCoreStartup, ( void ) );
+TM_API( TmErrorCode, tmCoreStartupEx, ( TMUSERTIMERFNC *fnc ) );
+TM_API( TmErrorCode, tmCoreInitializeContext, ( EXPOUT HTELEMETRY * pcx, void * pArena, TmU32 const kArenaSize ) );
+TM_API( void, tmCoreShutdownContext, ( HTELEMETRY cx ) );
+TM_API( void, tmCoreShutdown, ( void ) ); 
+TM_API( TmErrorCode, tmCoreOpen, ( HTELEMETRY cx, char const * kpAppName,  
+       char const * kpBuildInfo,
+       char const * kpServerAddress, 
+       TmConnectionType const kConnection,
+       TmU16 const kServerPort,
+       TmU32 const kFlags,
+       int const kTimeoutMS ) );
+#endif
+
+TM_API( void, tmCoreClose, ( HTELEMETRY cx ) );
+
+TM_API( void , tmCoreSetDebugZoneLevel, ( HTELEMETRY cx, int const v ) );
+TM_API( void , tmCoreCheckDebugZoneLevel, ( HTELEMETRY cx, int const v ) );
+TM_API( void , tmCoreUnwindToDebugZoneLevel, ( HTELEMETRY cx, int const v ) );
+
+TM_API( char const *, tmCoreDynamicString, ( HTELEMETRY cx, char const * s ) );
+TM_API( void, tmCoreClearStaticString, ( HTELEMETRY cx, char const * s ) );
+
+TM_API( void, tmCoreSetVariable, ( HTELEMETRY cx, char const *kpKey, TmFormatCode* pFormatCode, char const *kpValueFmt, ... ) );
+TM_API( void, tmCoreSetTimelineSectionName, ( HTELEMETRY cx, TmFormatCode *pFormatCode, char const * kpFmt, ... ) );
+TM_API( void, tmCoreThreadName, ( HTELEMETRY cx, TmU32 const kThreadID, TmFormatCode *pFormatCode, char const * kpFmt, ... ) ); 
+TM_API( void, tmCoreGetFormatCode, ( TmFormatCode* pCode, char const * kpFmt ) );
+
+TM_API( void, tmCoreEnable, ( HTELEMETRY cx, TmOption const kOption, int const kValue ) );
+TM_API( int , tmCoreIsEnabled, ( HTELEMETRY cx, TmOption const kOption ) );
+
+TM_API( void, tmCoreSetParameter, ( HTELEMETRY cx, TmParameter const kParam, void const *kpValue ) );
+TM_API( void, tmCoreSetServerConfiguration, ( HTELEMETRY cx, TmServerConfiguration const kConfiguration, void const *kpValue ) );
+
+TM_API( void, tmCoreTick, ( HTELEMETRY cx ) );
+TM_API( void, tmCoreFlush, ( HTELEMETRY cx ) );
+TM_API( void, tmCorePause, ( HTELEMETRY cx, int const kPause ) );
+TM_API( int, tmCoreIsPaused, ( HTELEMETRY cx ) );
+TM_API( void, tmCoreEnter, (HTELEMETRY cx, TmU64 *matchid, TmU32 const kThreadId, TmU64 const kThreshold, TmU32 const kFlags, char const *kpLocation, TmU32 const kLine, TmFormatCode* pFmtCode, char const *kpFmt, ... ) );
+TM_API( void, tmCoreLeave, ( HTELEMETRY cx, TmU64 const kMatchID, TmU32 const kThreadId, char const *kpLocation, int const kLine ) ); 
+
+TM_API( void,  tmCoreEmitAccumulationZone, ( HTELEMETRY cx, TmU64 * pAccum, TmU64 const kZoneTotal, TmU32 const kCount, TmU32 const kZoneFlags, char const *kpLocation, TmU32 const kLine, TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+
+TM_API( TmU64, tmCoreGetLastContextSwitchTime, (HTELEMETRY cx) );
+
+TM_API( void, tmCoreLockName, ( HTELEMETRY cx, void const *kpPtr, TmFormatCode* pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCoreSetLockState, ( HTELEMETRY cx, void const *kpPtr, TmLockState const kState, char const * kLocation, TmU32 const kLine, TmFormatCode *pFormatCode, char const *kpFmt, ... ) );
+TM_API( int,  tmCoreSetLockStateMinTime, ( HTELEMETRY cx, void* buf, void const *kpPtr, TmLockState const kState, char const * kLocation, TmU32 const kLine, TmFormatCode *pFormatCode, char const *kpFmt, ... ) );
+
+TM_API( void, tmCoreBeginTimeSpan, ( HTELEMETRY cx, TmU64 const kId, TmU32 const kFlags, TmU64 const kTime, char const *kpLocation, TmU32 const kLine, TmFormatCode *pFmtCode, char const *kpFmt, ... ) );
+TM_API( void, tmCoreEndTimeSpan, ( HTELEMETRY cx, TmU64 const kId, TmU32 const kFlags, TmU64 const kTime, char const *kpLocation, TmU32 const kLine, TmFormatCode *pFmtCode, char const *kpFmt, ... ) );
+
+TM_API( void, tmCoreSignalLockCount, ( HTELEMETRY cx, char const *kpLocation, TmU32 const kLine, void const * kPtr, TmU32 const kCount, TmFormatCode* pFmtCode, char const *kpName, ... ) );
+TM_API( void, tmCoreTryLock,   ( HTELEMETRY cx, TmU64 *matchid, TmU64 const kThreshold, char const *kpLocation, TmU32 const kLine, void const * kPtr, TmFormatCode* pFmtCode, char const *kpFmt, ... ) );
+TM_API( void, tmCoreEndTryLock, ( HTELEMETRY cx, TmU64 const kMatchId, char const *kpLocation, int const kLine, TmFormatCode* pFmt, void const * kPtr, TmLockResult const kResult ) );
+
+TM_API( TmI32, tmCoreGetStati, ( HTELEMETRY cx, TmStat const kStat ) );
+
+TM_API( void, tmCoreMessage, ( HTELEMETRY cx, TmU32 const kThreadId, TmU32 const kFlags, TmFormatCode* pFmtCode, char const * kpFmt, ... ) );
+
+TM_API( void, tmCoreAlloc, ( HTELEMETRY cx, void const * kPtr, TmU64 const kSize, char const *kpLocation, TmU32 const kLine, TmFormatCode *pFmtCode, char const *kpFmt, ... ) );
+TM_API( void, tmCoreFree, ( HTELEMETRY cx, void const * kpPtr, char const *kpLocation, int const kLine, TmFormatCode *pFmtCode ) );
+
+TM_API( void, tmCorePlot, ( HTELEMETRY cx, TmI64 const kTSC, TmPlotType const kType, TmU32 const kFlags, float const kValue,  TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCorePlotI32, ( HTELEMETRY cx, TmI64 const kTSC, TmPlotType const kType, TmU32 const kFlags, TmI32 const kValue,  TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCorePlotU32, ( HTELEMETRY cx, TmI64 const kTSC, TmPlotType const kType, TmU32 const kFlags, TmU32 const kValue,  TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCorePlotI64, ( HTELEMETRY cx, TmI64 const kTSC, TmPlotType const kType, TmU32 const kFlags, TmI64 const kValue,  TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCorePlotU64, ( HTELEMETRY cx, TmI64 const kTSC, TmPlotType const kType, TmU32 const kFlags, TmU64 const kValue,  TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCorePlotF64, ( HTELEMETRY cx, TmI64 const kTSC, TmPlotType const kType, TmU32 const kFlags, double const kValue,  TmFormatCode *pFmtCode, char const * kpFmt, ... ) );
+
+TM_API( void, tmCoreBlob, ( HTELEMETRY cx,   void const * kpData, int const kDataSize, char const *kpPluginIdentifier, TmFormatCode* pFmtCode, char const * kpFmt, ... ) );
+TM_API( void, tmCoreDisjointBlob, ( HTELEMETRY cx, int const kNumPieces, void const ** kpData, int const *kDataSize, char const *kpPluginIdentifier, TmFormatCode* pFmtCode, char const * kpFmt, ... ) );
+
+TM_API( void, tmCoreUpdateSymbolData, ( HTELEMETRY cx ) );
+
+TM_API( int, tmCoreSendCallStack, ( HTELEMETRY cx, TmCallStack const * kpCallStack, int const kSkip ) );
+TM_API( int, tmCoreGetCallStack, ( HTELEMETRY cx, TmCallStack * pCallStack ) );
+
+TM_API( int, tmCoreSendCallStackR, ( HTELEMETRY cx, TmCallStack const * kpCallStack, int const kSkip ) );
+TM_API( int, tmCoreGetCallStackR, ( HTELEMETRY cx, TmCallStack * pCallStack ) );
+
+#ifndef TM_API_STATIC
+typedef struct TM_API_STRUCT
+{
+  // NOTE: Order of this must be preserved, new functions should be added to the end
+  #define TM_API_S(name) TM_FUNCTION_TYPE(name) name
+
+  TM_API_S( tmCoreCheckVersion );
+  TM_API_S( tmCoreUpdateSymbolData );
+  TM_API_S( tmCoreGetLastContextSwitchTime );    
+#ifndef __RADSPU__
+  TM_API_S( tmCoreTick );
+#endif
+  TM_API_S( tmCoreFlush );
+  TM_API_S( tmCoreDynamicString );
+  TM_API_S( tmCoreClearStaticString );
+  TM_API_S( tmCoreSetVariable );
+  TM_API_S( tmCoreGetFormatCode );
+  TM_API_S( tmCoreGetSessionName );
+  TM_API_S( tmCoreGetLastError );
+  TM_API_S( tmCoreShutdownContext );
+  TM_API_S( tmCoreGetConnectionStatus );
+  TM_API_S( tmCoreSetTimelineSectionName );
+  TM_API_S( tmCoreEnable );
+  TM_API_S( tmCoreIsEnabled );
+#ifndef __RADSPU__
+  TM_API_S( tmCoreOpen );
+#endif
+  TM_API_S( tmCoreClose );
+  TM_API_S( tmCorePause );
+  TM_API_S( tmCoreIsPaused );
+  TM_API_S( tmCoreEnter );
+  TM_API_S( tmCoreLeave );
+
+  TM_API_S( tmCoreThreadName );
+  TM_API_S( tmCoreLockName );
+  TM_API_S( tmCoreTryLock );
+  TM_API_S( tmCoreEndTryLock );
+  TM_API_S( tmCoreSignalLockCount );
+  TM_API_S( tmCoreSetLockState );
+
+  TM_API_S( tmCoreAlloc );
+  TM_API_S( tmCoreFree );
+  TM_API_S( tmCoreGetStati );
+
+  TM_API_S( tmCoreBeginTimeSpan );
+  TM_API_S( tmCoreEndTimeSpan );
+
+  TM_API_S( tmCorePlot );
+  TM_API_S( tmCorePlotI32 );
+  TM_API_S( tmCorePlotU32 );
+  TM_API_S( tmCorePlotI64 );
+  TM_API_S( tmCorePlotU64 );
+  TM_API_S( tmCorePlotF64 );
+
+  TM_API_S( tmCoreBlob );
+  TM_API_S( tmCoreDisjointBlob );
+  TM_API_S( tmCoreMessage );
+
+  TM_API_S( tmCoreSendCallStack );
+  TM_API_S( tmCoreGetCallStack );
+
+  TM_API_S( tmCoreSetDebugZoneLevel );
+  TM_API_S( tmCoreCheckDebugZoneLevel );
+  TM_API_S( tmCoreUnwindToDebugZoneLevel );
+
+  TM_API_S( tmCoreEmitAccumulationZone );
+
+  TM_API_S( tmCoreSetLockStateMinTime );
+  TM_API_S( tmCoreSetParameter );
+
+#if defined __RADPS3__ && !defined TM_API_STATIC
+  TM_API_S( tmPPUCoreGetListener );
+  TM_API_S( tmPPUCoreRegisterSPUProgram );
+#endif
+
+  // If adding anything after here make sure to update stubs!
+  TM_API_S( tmCoreSendCallStackR );
+  TM_API_S( tmCoreGetCallStackR );
+  TM_API_S( tmCoreSetServerConfiguration );
+
+
+} TM_API_STRUCT;
+#endif // !TM_API_STATIC
+
+
+#endif //NTELEMETRY
+
+RADDEFEND
+
+#if !defined TM_API_STATIC && !defined NTELEMETRY
+// snag API function
+typedef void (RADEXPLINK *tmGetAPIproc)( void * buffer );
+#endif
+//----------------------------------------------------------------------------
+// If NTELEMETRY is defined then all Telemetry calls are compiled away by
+// the preprocessor.
+//----------------------------------------------------------------------------
+#ifdef NTELEMETRY
+
+#define TM_VAR(x)
+
+#define tmUpdateSymbolData(cx)
+#define tmSetDebugZoneLevel(cx,n)
+#define tmCheckDebugZoneLevel(cx,n)
+#define tmUnwindToDebugZoneLevel(cx,n)
+
+#define tmGetLastError(cx) TM_OK
+#define tmShutdownContext(cx) 
+
+#define tmGetLastContextSwitchTime(cx) 0
+#define tmGetAccumulationStart(cx) 0
+
+#define tmEnterAccumulationZone(cx,z)
+#define tmLeaveAccumulationZone(cx,z)
+
+#define tmGetFormatCode(cx,s,t)
+#define tmDynamicString(cx,s) 0
+
+#define tmTick(cx)
+#define tmFlush(cx)
+#define tmPause(cx,p)
+#define tmIsPaused(cx) 0
+
+#define tmClearStaticString(cx,s)
+
+#define tmEnable(cx,flag,value)
+#define tmIsEnabled(cx,flag) 0
+
+#define tmSetParameter(cx,param,v)
+#define tmSetServerConfiguration(cx,param,v)
+
+#define tmOpen(cx,appname,buildinfo,servername,contype,serverport,flags,timeout) TMERR_DISABLED
+#define tmClose(cx)
+#define tmGetConnectionStatus(cx) TMCS_DISCONNECTED
+
+#define tmFree(cx,ptr)
+#define tmLeave(cx)
+
+#ifndef __RADNOVARARGMACROS__
+
+#define tmGetSessionName(...)
+#define tmEndTryLock(...)
+#define tmEndTryLockEx(...)
+#define tmSetLockState(...)
+#define tmSetLockStateEx(...)
+#define tmSetLockStateMinTime(...) 0
+#define tmSetLockStateMinTimeEx(...) 0
+#define tmSignalLockCount(...)
+
+#define tmCheckVersion(...) 0
+#define tmGetCallStack(...) 0
+#define tmSendCallStack( ... ) TMPRINTF_TOKEN_NONE
+
+#define tmGetVersion(...) 0
+#define tmStartup(...)  TMERR_DISABLED
+#define tmStartupEx(...)  TMERR_DISABLED
+#define tmGetPlatformInformation(...) TMERR_DISABLED
+#define tmInitializeContext(...) TMERR_DISABLED
+#define tmShutdown(...) TMERR_DISABLED
+
+#define tmEnter(...)
+#define tmEnterEx(...)
+#define tmZone(...) 
+#define tmZoneFiltered(...)
+#define tmLeaveEx(...)
+
+#define tmBeginTimeSpan(...)
+#define tmEndTimeSpan(...)
+
+#define tmEmitAccumulationZone(...)
+
+#define tmGetStati(...) 0
+
+#define tmSetVariable(...)
+
+#define tmBlob(...)
+#define tmDisjointBlob(...)
+#define tmSetTimelineSectionName(...)
+#define tmThreadName(...)
+#define tmLockName(...)
+#define tmMessage(...)
+#define tmMessageEx(...)
+#define tmAlloc(...)
+#define tmAllocEx(...)
+
+#define tmTryLock(...)
+#define tmTryLockEx(...)
+    
+#define tmPlot(...)
+#define tmPlotF32(...)
+#define tmPlotF64(...)
+#define tmPlotI32(...)
+#define tmPlotU32(...)
+#define tmPlotS32(...)
+#define tmPlotI64(...)
+#define tmPlotU64(...)
+#define tmPlotS64(...)
+
+#define tmPlotAt(...)
+#define tmPlotF32At(...)
+#define tmPlotF64At(...)
+#define tmPlotI32At(...)
+#define tmPlotU32At(...)
+#define tmPlotS32At(...)
+#define tmPlotI64At(...)
+#define tmPlotU64At(...)
+#define tmPlotS64At(...)
+
+#define tmPPUGetListener(...)
+#define tmPPURegisterSPUProgram(...)
+#define tmSPUBindContextToListener(...)
+#define tmSPUUpdateTime(...)
+#define tmSPUFlushImage(...)
+
+#endif // __RADNOVARARGMACROS__
+
+#else // !NTELEMETRY
+
+//----------------------------------------------------------------------------
+// Variable declaration macro so that if you compile with NTELEMETRY
+// the Telemetry specific variable declarations go away (helps when compiling
+// with warnings-as-errors).
+//----------------------------------------------------------------------------
+#define TM_VAR(x) x 
+
+//----------------------------------------------------------------------------
+// C++ helper for entering/exiting zones
+//----------------------------------------------------------------------------
+#if defined(__cplusplus) && !defined(TM_NO_ZCLASS)
+#define TMLINENAME3(name,line) name##line
+#define TMLINENAME2( name, line ) TMLINENAME3(name,line)
+#define TMLINENAME( name ) TMLINENAME2(name,__LINE__)
+
+#define tmZoneFiltered(cx,mintime,flags,name,...) TmU64 TMLINENAME(tm_id) = 0; \
+    TMCHECKCONTEXT_VA(cx,tmCoreEnter,(cx,&(TMLINENAME(tm_id)),0,mintime,(flags),__FILE__, __LINE__, &tm_fmt, name,##__VA_ARGS__));\
+    Tm_Zone TMLINENAME(tm_ZoneProfiler)(cx,TMLINENAME(tm_id));
+
+#define tmZone(cx,flags,name,...) tmZoneFiltered(cx,0,flags,name,##__VA_ARGS__)
+
+//Zone helper
+class Tm_Zone 
+{
+private:
+    TmU64 z_id;
+    HTELEMETRY z_cx; 
+
+public:
+    inline Tm_Zone(HTELEMETRY cx, TmU64 const kMatchID )
+    {
+        z_cx = cx;
+        z_id = kMatchID;
+    }
+
+    inline ~Tm_Zone()
+    {
+        TMCHECKCONTEXTV(z_cx,tmCoreLeave,(z_cx,z_id,0,0,0));
+    }
+};
+
+#endif //__cplusplus
+
+#if (!(defined(TM_DLL) && (TM_DLL==1)))
+
+// startup and shutdown functions (part of loading lib, not DLL)
+#ifndef __RADINDLL__
+RADDEFSTART
+#endif
+
+#if defined TM_API_STATIC
+#define tmStartup tmCoreStartup
+#define tmStartupEx tmCoreStartupEx
+#define tmShutdown tmCoreShutdown
+#define tmGetVersion tmCoreGetVersion
+#define tmInitializeContext tmCoreInitializeContext
+#define tmGetPlatformInformation tmCoreGetPlatformInformation
+#else
+RADDEFFUNC TmErrorCode RADEXPLINK tmStartup( void );
+RADDEFFUNC TmErrorCode RADEXPLINK tmStartupEx( TMUSERTIMERFNC *fnc );
+RADDEFFUNC TmErrorCode RADEXPLINK tmShutdown( void ); 
+RADDEFFUNC TmU32 RADEXPLINK tmGetVersion( void );
+RADDEFFUNC TmErrorCode RADEXPLINK tmInitializeContext( EXPOUT HTELEMETRY * pcx, void * pArena, TmU32 const kArenaSize );
+RADDEFFUNC TmErrorCode RADEXPLINK tmGetPlatformInformation( void* obj, TmPlatformInformation const kInfo, void *dst, TmU32 const kSize );
+#endif
+
+#ifndef __RADINDLL__
+RADDEFEND
+#endif
+
+#define tmCheckVersion( cx,major,minor,build,cust) TMCHECKCONTEXTR(cx,tmCoreCheckVersion,(cx,major,minor,build,cust),0)
+
+#ifdef __RADPS3__
+#define tmPPUGetListener(cx,n,p) TMCHECKCONTEXTR(cx,tmPPUCoreGetListener,(cx,n,p),TMERR_DISABLED)
+#define tmPPURegisterSPUProgram(cx,guid,address,s,ro_offset) TMCHECKCONTEXTR(cx,tmPPUCoreRegisterSPUProgram,(cx,guid,address,s,ro_offset),TMERR_DISABLED)
+#endif
+
+#ifdef __RADSPU__
+#define tmSPUUpdateTime(cx) TMCHECKCONTEXTV(cx,tmSPUCoreUpdateTime,(cx))
+#define tmSPUFlushImage(cx) TMCHECKCONTEXTV(cx,tmSPUCoreFlushImage,(cx))
+#endif
+
+#define tmUpdateSymbolData(cx) TMCHECKCONTEXTV(cx,tmCoreUpdateSymbolData,(cx))
+
+#define tmGetSessionName(cx,a,b) TMCHECKCONTEXTR(cx,tmCoreGetSessionName,(cx,a,b),TMERR_DISABLED)
+
+#define tmUnwindToDebugZoneLevel(cx,n) TMCHECKCONTEXTV(cx,tmCoreUnwindToDebugZoneLevel,(cx,n))
+#define tmSetDebugZoneLevel(cx,n) TMCHECKCONTEXTV(cx,tmCoreSetDebugZoneLevel,(cx,n))
+#define tmCheckDebugZoneLevel(cx,n) TMCHECKCONTEXTV(cx,tmCoreCheckDebugZoneLevel,(cx,n))
+
+#define tmGetCallStack(cx,p) TMCHECKCONTEXTR(cx,tmCoreGetCallStack,(cx,p),0)
+#define tmSendCallStack(cx,p) TMCHECKCONTEXTR(cx,tmCoreSendCallStack,(cx,p,0),TMPRINTF_TOKEN_NONE)
+#define tmSendCallStackWithSkip(cx,p,s) TMCHECKCONTEXTR(cx,tmCoreSendCallStack,(cx,p,s),TMPRINTF_TOKEN_NONE)
+
+#define tmGetCallStackR(cx,p) TMCHECKCONTEXTR(cx,tmCoreGetCallStackR,(cx,p),0)
+#define tmSendCallStackR(cx,p) TMCHECKCONTEXTR(cx,tmCoreSendCallStackR,(cx,p,0),TMPRINTF_TOKEN_NONE)
+#define tmSendCallStackWithSkipR(cx,p,s) TMCHECKCONTEXTR(cx,tmCoreSendCallStackR,(cx,p,s),TMPRINTF_TOKEN_NONE)
+
+#define tmGetLastError(cx) TMCHECKCONTEXT(cx,tmCoreGetLastError,(cx))
+#define tmShutdownContext(cx) TMCHECKCONTEXTV(cx,tmCoreShutdownContext,(cx))
+
+#define tmGetLastContextSwitchTime(cx) TMCHECKCONTEXTR(cx,tmCoreGetLastContextSwitchTime,(cx),0)
+
+#define tmGetAccumulationStart(cx) ((cx) ? tmFastTime() : 0)
+#define tmEnterAccumulationZone(cx,z) { if (cx) (z) -= tmFastTime(); }
+#define tmLeaveAccumulationZone(cx,z) { if (cx) (z) += tmFastTime(); }
+
+#define tmGetFormatCode(cx,s,t) TMCHECKCONTEXTV(cx,tmCoreGetFormatCode,(s,t))
+#define tmDynamicString(cx,s) TMCHECKCONTEXTR(cx,tmCoreDynamicString,(cx,s),0)
+
+#define tmClearStaticString(cx,s) TMCHECKCONTEXTV(cx,tmCoreClearStaticString,(cx,s))
+
+#define tmEnable(cx,flag,value) TMCHECKCONTEXTV(cx,tmCoreEnable,(cx,flag,value))
+#define tmIsEnabled(cx,flag) TMCHECKCONTEXT(cx,tmCoreIsEnabled,(cx,flag))
+#define tmSetParameter(cx,p,v) TMCHECKCONTEXTV(cx,tmCoreSetParameter,(cx,p,v))
+#define tmSetServerConfiguration(cx,p,v) TMCHECKCONTEXTV(cx,tmCoreSetServerConfiguration,(cx,p,v))
+
+#define tmOpen(cx,appname,buildinfo,servername,contype,serverport,flags,timeout) TMCHECKCONTEXT(cx,tmCoreOpen,(cx,appname,buildinfo,servername,contype,serverport,flags,timeout))
+#define tmClose(cx) TMCHECKCONTEXTV(cx,tmCoreClose,(cx))
+#define tmTick(cx) TMCHECKCONTEXTV(cx,tmCoreTick,(cx))
+
+#define tmFlush(cx) TMCHECKCONTEXTV(cx,tmCoreFlush,(cx))
+#define tmPause(cx,pause) TMCHECKCONTEXTV(cx,tmCorePause,(cx,pause))
+#define tmIsPaused(cx) TMCHECKCONTEXTR(cx,tmCoreIsPaused,(cx),0)
+#define tmGetConnectionStatus(cx) TMCHECKCONTEXTR(cx,tmCoreGetConnectionStatus,(cx),TMCS_DISCONNECTED)
+
+#define tmGetStati( c, stat ) TMCHECKCONTEXT(cx,tmCoreGetStati,( cx, stat ))
+#define tmLeave(cx) TMCHECKCONTEXTV(cx,tmCoreLeave,(cx,0,0,__FILE__,__LINE__))
+#define tmLeaveEx(cx,match,tid,f,l) TMCHECKCONTEXTV(cx,tmCoreLeave,(cx,match,tid,f,l))
+#define tmFree(cx,ptr) TMCHECKCONTEXT_VA(cx,tmCoreFree,(cx,ptr,__FILE__, __LINE__, &tm_fmt))
+
+#ifndef __RADNOVARARGMACROS__
+
+#ifdef __RADSPU__
+#define tmSPUBindContextToListener(pcx,mem,pptr,imagename,...) TMCHECKCONTEXTV(pcx,tmSPUCoreBindContextToListener,(pcx,mem,pptr,imagename,##__VA_ARGS__))
+#endif
+
+#define tmTryLock(cx,ptr,name,...) TMCHECKCONTEXT_VA(cx,tmCoreTryLock,(cx,0,0,__FILE__,__LINE__,ptr,&tm_fmt,name,##__VA_ARGS__))
+#define tmTryLockEx(cx,matchid,threshold,file,line,ptr,name,...) TMCHECKCONTEXT_VA(cx,tmCoreTryLock,(cx,matchid,threshold,file,line,ptr,&tm_fmt,name,##__VA_ARGS__))
+#define tmEndTryLock(cx,m,result)  TMCHECKCONTEXT_VA(cx,tmCoreEndTryLock,(cx,0,__FILE__,__LINE__,&tm_fmt, m,result))
+#define tmEndTryLockEx(cx,matchid,file,line,m,result)  TMCHECKCONTEXT_VA(cx,tmCoreEndTryLock,(cx,matchid,file,line,&tm_fmt,m,result))
+
+#define tmBeginTimeSpan(cx,id,flags,name,...) TMCHECKCONTEXT_VA(cx,tmCoreBeginTimeSpan,(cx,id,flags,0,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__))
+#define tmEndTimeSpan(cx,id,flags,name,...) TMCHECKCONTEXT_VA(cx,tmCoreEndTimeSpan,(cx,id,flags,0,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__))
+#define tmBeginTimeSpanEx(cx,id,flags,t,file,line,name,...) TMCHECKCONTEXT_VA(cx,tmCoreBeginTimeSpan,(cx,id,flags,t,file,line,&tm_fmt,name,##__VA_ARGS__))
+#define tmEndTimeSpanEx(cx,id,flags,t,file,line,name,...) TMCHECKCONTEXT_VA(cx,tmCoreEndTimeSpan,(cx,id,flags,t,file,line,&tm_fmt,name,##__VA_ARGS__))
+#define tmBeginTimeSpanAt(cx,id,flags,t,name,...) TMCHECKCONTEXT_VA(cx,tmCoreBeginTimeSpan,(cx,id,flags,t,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__))
+#define tmEndTimeSpanAt(cx,id,flags,t,name,...) TMCHECKCONTEXT_VA(cx,tmCoreEndTimeSpan,(cx,id,flags,t,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__))
+
+#define tmSignalLockCount(cx,m,cnt,name,...) TMCHECKCONTEXT_VA(cx,tmCoreSignalLockCount,(cx,__FILE__,__LINE__,m,cnt,&tm_fmt,name,##__VA_ARGS__))
+#define tmSetLockState(cx,lockptr,state,name,...)  TMCHECKCONTEXT_VA(cx,tmCoreSetLockState,(cx,lockptr,state,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__ ))
+#define tmSetLockStateEx(cx,file,line,lockptr,state,name,...)  TMCHECKCONTEXT_VA(cx,tmCoreSetLockState,(cx,lockptr,state,file,line,&tm_fmt,name,##__VA_ARGS__ ))
+#define tmSetLockStateMinTime(cx,buf,lockptr,state,name,...)  TMCHECKCONTEXT_VA(cx,tmCoreSetLockStateMinTime,(cx,buf,lockptr,state,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__ ))
+#define tmSetLockStateMinTimeEx(cx,buf,file,line,lockptr,state,name,...)  TMCHECKCONTEXT_VA(cx,tmCoreSetLockStateMinTime,(cx,buf,lockptr,state,file,line,&tm_fmt,name,##__VA_ARGS__ ))
+
+#define tmThreadName(cx,threadid,name,...) TMCHECKCONTEXT_VA(cx,tmCoreThreadName,(cx,threadid,&tm_fmt,name,##__VA_ARGS__))
+#define tmLockName(cx,ptr,name,...) TMCHECKCONTEXT_VA(cx,tmCoreLockName,(cx,ptr,&tm_fmt,name,##__VA_ARGS__))
+
+#define tmEmitAccumulationZone(cx,flags,acc,count,ztotal,name,...) TMCHECKCONTEXT_VA(cx,tmCoreEmitAccumulationZone,(cx,acc,ztotal,count,flags,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__))
+#define tmSetVariable(cx,key,v,...) TMCHECKCONTEXT_VA(cx,tmCoreSetVariable,(cx,key,&tm_fmt,v,##__VA_ARGS__))
+#define tmSetTimelineSectionName(cx,name,...) TMCHECKCONTEXT_VA(cx,tmCoreSetTimelineSectionName,(cx,&tm_fmt,name,##__VA_ARGS__))
+#define tmEnter(cx,flags,name,...) TMCHECKCONTEXT_VA(cx,tmCoreEnter,(cx,0,0,0,flags,__FILE__,__LINE__,&tm_fmt,name,##__VA_ARGS__))
+#define tmEnterEx(cx,matchid,tid,threshold,file,line,flags,name,...) TMCHECKCONTEXT_VA(cx,tmCoreEnter,(cx,matchid,tid,threshold,flags,file,line,&tm_fmt,name,##__VA_ARGS__))
+
+#define tmAlloc(cx,ptr,size,name,...) TMCHECKCONTEXT_VA(cx,tmCoreAlloc,(cx,ptr,size,__FILE__,__LINE__, &tm_fmt, name,##__VA_ARGS__))
+#define tmAllocEx(cx,file,line,ptr,size, name,...) TMCHECKCONTEXT_VA(cx,tmCoreAlloc,(cx,ptr,size,file,line, &tm_fmt,name,##__VA_ARGS__))
+#define tmMessage(cx,flags,s,...) TMCHECKCONTEXT_VA(cx,tmCoreMessage,(cx,0,flags,&tm_fmt,s,##__VA_ARGS__))
+#define tmMessageEx(cx,tid,flags,s,...) TMCHECKCONTEXT_VA(cx,tmCoreMessage,(cx,tid,flags,&tm_fmt,s,##__VA_ARGS__))
+
+#define tmPlot(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlot,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotF32(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlot,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotF64(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotF64,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotI32(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotI32,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotU32(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotU32,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotI64(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotI64,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotU64(cx,type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotU64,(cx,0,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+
+#define tmPlotAt(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlot,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotF32At(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlot,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotF64At(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotF64,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotI32At(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotI32,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotU32At(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotU32,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotI64At(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotI64,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+#define tmPlotU64At(cx,tsc, type,flags,val,name,...) TMCHECKCONTEXT_VA(cx,tmCorePlotU64,(cx,tsc,type,flags,val,&tm_fmt,name,##__VA_ARGS__))
+
+#define tmBlob(cx,chunk,size,pluginid,name,...) TMCHECKCONTEXT_VA(cx,tmCoreBlob,(cx,chunk,size,pluginid,&tm_fmt,name,##__VA_ARGS__))
+#define tmDisjointBlob(cx,num_args,chunks,sizes,plugind,name,...) TMCHECKCONTEXT_VA(cx,tmCoreDisjointBlob,(cx,num_args,chunks,sizes,pluginid,&tm_fmt,name,##__VA_ARGS__))
+
+#endif
+
+#endif
+
+#endif // !NTELEMETRY
+
+
+#if ( defined __RADNT__ || defined __RADLINUX__ || defined __RADMAC__ ) && !defined TM_API_STATIC && !defined __RADDURANGO__
+
+RADDEFSTART
+
+RADDEFFUNC int RADEXPLINK tmLoadTelemetryEx( int const major, int const minor, int const build, int const cust, int const kUseCheckedDLL );
+
+#define TM_LOAD_CHECKED_LIBRARY 1
+#define TM_LOAD_RELEASE_LIBRARY 0
+
+#ifndef NTELEMETRY
+#define tmLoadTelemetry( kUseCheckedDLL ) tmLoadTelemetryEx( TelemetryMajorVersion, TelemetryMinorVersion, TelemetryBuildNumber, TelemetryCustomization, kUseCheckedDLL )
+#else
+#define tmLoadTelemetry(...) 1
+#endif
+
+RADDEFEND
+
+#else
+#define tmLoadTelemetry(...) 1
+#endif
+
+#ifdef EXPGROUP
+#undef EXPGROUP
+#endif
+#define EXPGROUP()
+EXPGROUP() 
+#undef EXPGROUP
+ 
+// ----------------------------------------------------------------------------
+// Define a fast time retrieval macro for this platform
+// ----------------------------------------------------------------------------
+#ifdef NTELEMETRY
+
+#define tmFastTime() 0
+
+#elif defined TM_INLINE_FASTTIME
+
+    // Enable intrinsic RDTSC if available
+    #if defined _MSC_VER  && _MSC_VER >= 1400 && defined __RADX86__ 
+        #pragma warning(disable:4505) 
+        #pragma warning(disable:4995)
+
+        RADDEFFUNC unsigned __int64 __rdtsc(void);
+        #pragma intrinsic(__rdtsc)
+    #endif
+
+    // SPU
+    #if defined __RADSPU__
+        #ifndef _SPU_INTRINSICS_H
+        #include <spu_intrinsics.h>
+        #endif
+
+        #ifdef __cplusplus
+            extern "C" TmU64 tm_spu_ppu_time;
+            extern "C" TmU64 tm_spu_last_time;
+        #else
+            extern TmU64 tm_spu_ppu_time;
+            extern TmU64 tm_spu_last_time;
+        #endif
+
+        static RADINLINE U32 __tmFastTimeSPU()
+        {
+            U32 dec = spu_readch(SPU_RdDec);
+            U32 tsc = - dec;
+            return tsc;
+        }
+
+        static RADINLINE U64 tmFastTime()
+        {
+            U64 const now = __tmFastTimeSPU();
+            U64 t;
+
+            if ( ( now & 0xFFFFFFFF ) < ( tm_spu_ppu_time & 0xFFFFFFFF ) )
+            {
+                t = now | ( ( tm_spu_ppu_time + 0x100000000LL ) & (~0xFFFFFFFFLL) );
+            }
+            else
+            {
+                t = now | ( tm_spu_ppu_time & (~0xFFFFFFFFLL ));
+            }
+
+            // Check to see if our time has wrapped/reversed
+            if ( tm_spu_last_time > t )
+            {
+                t += 0x100000000LL;
+            }
+
+            tm_spu_last_time = t;
+
+            return t;
+        }
+
+    // 32-bit Windows uses RDTSC
+    #elif defined __RADNT__ && !defined __RADX64__
+
+       // If intrinsics are available, use them
+       #if defined _MSC_VER  && _MSC_VER >= 1400
+          #define tmFastTime() __rdtsc() // available as intrinsic on Visual Studio
+       // Otherwise resort to inline assembly
+       #else
+          static __declspec(naked) unsigned __int64 tmFastTime()
+          {
+            __asm rdtsc;
+            __asm ret;
+          }
+       #endif
+    // On 64-bit windows we can use __rdtsc directly
+    #elif defined __RADWIN__ && defined __RADX64__ && defined _MSC_VER
+        #define tmFastTime() __rdtsc() 
+    // Mac and Linux imply GCC inline asm available  
+    #elif defined __RADMAC__ || ( ( defined __RADLINUX__ || defined __RADQNX__ ) && ( defined __RADX86__ || defined __RADX64__) ) || defined __RADPS4__
+        static inline unsigned long long tmFastTime() 
+        {
+            TmU32 lo, hi;
+            asm volatile ("rdtsc" : "=a" (lo), "=d" (hi) );
+            return (TmU64) hi << 32 | lo;
+        } 
+    // On QNX this is the best we can hope for, unfortunately it may not be synced across
+    // processors so we need to watch out for that
+    #elif defined ( __RADQNX__ ) 
+        #include <sys/neutrino.h>
+        #include <inttypes.h>
+        static RADINLINE U64 tmFastTime() 
+        {
+            return ClockCycles();
+        }
+    // On ARM Linux platforms (including Android) we have to hope that clock_gettime
+    // will be of sufficient accuracy
+    #elif defined __RADANDROID__
+        #include <time.h>
+        static inline unsigned long long tmFastTime()
+        {
+            // We're scaling by 1000 to get closer to a nanosecondish scale.  Keep in mind
+            // that clock() is 32-bits and will wrap every ~72 minutes, so if you want higher
+            // precision and/or longer duration you should implement this with user timers
+            return clock() * 1000ULL;
+        }
+
+    #elif ( defined __RADLINUX__  && defined __RADARM__ )
+        #include <time.h>
+        static inline unsigned long long tmFastTime()
+        {
+            struct timespec t;
+
+            clock_gettime( CLOCK_MONOTONIC_RAW, &t );
+            return t.tv_sec * 1000000000ULL + t.tv_nsec;
+        }
+    // Xenon or PS3 we assume __mftb is available  
+    // PowerPC platforms can use MFTB
+    #elif defined __RADPS3__
+        // PS3 we assume __mftb is available  
+        #define tmFastTime() __extension__          \
+          ({ unsigned long long __macro_result;         \
+          __asm__ volatile ("1: mftb %[current_tb]\n"     \
+              "\tcmpwi 7, %[current_tb], 0\n"       \
+              "\tbeq-  7, 1b"           \
+              : [current_tb] "=r" (__macro_result):       \
+              :"cr7");              \
+          __macro_result; })
+
+    #elif defined __RADXENON__ 
+        // Xenon we assume __mftb is available  
+        #if defined __RADXENON__
+            RADDEFFUNC unsigned __int64 __mftb(); //From <PPCIntrinsics.h>
+            #pragma intrinsic(__mftb)
+        #endif
+  
+        // check for weird sample and re-read
+        static RADINLINE U64 tmFastTime()
+        {
+            U64 a;
+            a = __mftb();
+            if ( ( a & 0xffffffff ) < 500 )
+                a = __mftb();
+            return a;
+        }
+
+    #elif defined __RADIPHONE__
+        RADDEFFUNC U64 mach_absolute_time();
+        static RADINLINE U64 tmFastTime()
+        {
+            return mach_absolute_time();
+        }
+    #elif defined __RADWIIU__
+        RADDEFFUNC unsigned int __MFTB(void); // in case aren't previously defined
+        RADDEFFUNC unsigned int __MFTBU(void);
+        static RADINLINE U64 tmFastTime()
+        {
+            U64 a = (U64) __MFTB() | ((U64) __MFTBU() << 32);
+            if ( ( a & 0xffffffff ) < 500 )
+                a = (U64) __MFTB() | ((U64) __MFTBU() << 32);
+            return a;
+        }
+    #elif defined __RADPSP2__
+        #include <libperf.h>
+        #define tmFastTime() scePerfGetTimebaseValue()
+    #else
+        #error tmFastTime not defined for this platform
+    #endif
+#endif // NTELEMETRY
+
+#endif //__RADRES__
+
+#endif //TELEMETRY_H
diff --git a/thirdparty/telemetry/include/tmtypes.h b/thirdparty/telemetry/include/tmtypes.h
new file mode 100644
index 0000000..3cccd85
--- /dev/null
+++ b/thirdparty/telemetry/include/tmtypes.h
@@ -0,0 +1,46 @@
+
+#ifndef TMTYPES_H
+#define TMTYPES_H
+
+#ifdef _MSC_VER 
+#pragma warning(disable:4121)
+#pragma warning(disable:4127)
+#endif
+
+#ifndef __RADTYPESH__
+#include "radtypes.h"
+#endif
+
+// This is documentation stuff
+#undef EXPTYPE
+#define EXPTYPE
+#undef EXPGROUP
+#define EXPGROUP(x)
+EXPGROUP(TMAPI)
+
+EXPTYPE typedef RAD_S8  TmI8;   // Signed 8-bit integer
+EXPTYPE typedef RAD_U8  TmU8;   // Unsigned 8-bit integer
+EXPTYPE typedef RAD_S16 TmI16;  // Signed 16-bit integer
+EXPTYPE typedef RAD_U16 TmU16;  // Unsigned 16-bit integer
+EXPTYPE typedef RAD_S32 TmI32;  // Signed 32-bit integer
+EXPTYPE typedef RAD_U32 TmU32;  // Unsigned 32-bit integer
+EXPTYPE typedef RAD_F32 TmF32;  // IEEE 32-bit float
+EXPTYPE typedef RAD_F64 TmF64;  // IEEE 64-bit float (double)
+EXPTYPE typedef RAD_S64 TmI64;  // Signed 64-bit integer
+EXPTYPE typedef RAD_U64 TmU64;  // Unsigned 64-bit integer
+EXPTYPE typedef RAD_UINTa TmIntPtr; // Minimal size guaranteed to hold a pointer
+
+typedef struct _TmFormatCode
+{
+    TmU32 fc_format;
+    TmU32 fc_fbits;
+    char const *fc_ptr;
+} TmFormatCode;
+
+// This is documentation stuff
+#undef EXPGROUP
+#define EXPGROUP()
+EXPGROUP()
+#undef EXPGROUP
+
+#endif //TMTYPES_H