microprofile: Don't memset through std::atomic types

Two of the members of the MicroProfileThreadLog contains two std::atomic
instances. Given these aren't trivially-copyable types, we shouldn't be
memsetting the structure, given implementation details can contain other
members within it.

To avoid potential undefined behavior on platforms, we can use aggregate
initialization to zero out the members while still having well-defined
behavior.

While we're at it we can also silence some sign conversion warnings.

2 files changed, 144 insertions, 125 deletions

diff --git a/externals/microprofile/microprofile.h b/externals/microprofile/microprofile.h
index 0c0d0a4d3..6dae65a66 100644
--- a/externals/microprofile/microprofile.h
+++ b/externals/microprofile/microprofile.h
@@ -152,9 +152,11 @@ typedef uint16_t MicroProfileGroupId;
 
 #include <stdint.h>
 #include <string.h>
-#include <thread>
-#include <mutex>
+#include <algorithm>
+#include <array>
 #include <atomic>
+#include <mutex>
+#include <thread>
 
 #ifndef MICROPROFILE_API
 #define MICROPROFILE_API
@@ -605,28 +607,45 @@ struct MicroProfileFrameState
 
 struct MicroProfileThreadLog
 {
-    MicroProfileLogEntry    Log[MICROPROFILE_BUFFER_SIZE];
+    std::array<MicroProfileLogEntry, MICROPROFILE_BUFFER_SIZE> Log{};
 
-    std::atomic<uint32_t>   nPut;
-    std::atomic<uint32_t>   nGet;
-    uint32_t                nActive;
-    uint32_t                nGpu;
-    ThreadIdType            nThreadId;
+    std::atomic<uint32_t>   nPut{0};
+    std::atomic<uint32_t>   nGet{0};
+    uint32_t                nActive = 0;
+    uint32_t                nGpu = 0;
+    ThreadIdType            nThreadId{};
 
-    uint32_t                nStack[MICROPROFILE_STACK_MAX];
-    int64_t                 nChildTickStack[MICROPROFILE_STACK_MAX];
-    uint32_t                nStackPos;
+    std::array<uint32_t, MICROPROFILE_STACK_MAX> nStack{};
+    std::array<int64_t, MICROPROFILE_STACK_MAX>  nChildTickStack{};
+    uint32_t                                     nStackPos = 0;
 
 
-    uint8_t                 nGroupStackPos[MICROPROFILE_MAX_GROUPS];
-    int64_t                 nGroupTicks[MICROPROFILE_MAX_GROUPS];
-    int64_t                 nAggregateGroupTicks[MICROPROFILE_MAX_GROUPS];
+    std::array<uint8_t, MICROPROFILE_MAX_GROUPS> nGroupStackPos{};
+    std::array<int64_t, MICROPROFILE_MAX_GROUPS> nGroupTicks{};
+    std::array<int64_t, MICROPROFILE_MAX_GROUPS> nAggregateGroupTicks{};
     enum
     {
         THREAD_MAX_LEN = 64,
     };
-    char                    ThreadName[64];
-    int                     nFreeListNext;
+    char                    ThreadName[64]{};
+    int                     nFreeListNext = 0;
+
+    void Reset() {
+        Log.fill({});
+        nPut = 0;
+        nGet = 0;
+        nActive = 0;
+        nGpu = 0;
+        nThreadId = {};
+        nStack.fill(0);
+        nChildTickStack.fill(0);
+        nStackPos = 0;
+        nGroupStackPos.fill(0);
+        nGroupTicks.fill(0);
+        nAggregateGroupTicks.fill(0);
+        std::fill(std::begin(ThreadName), std::end(ThreadName), '\0');
+        nFreeListNext = 0;
+    }
 };
 
 #if MICROPROFILE_GPU_TIMERS_D3D11
@@ -1151,6 +1170,7 @@ MicroProfileThreadLog* MicroProfileCreateThreadLog(const char* pName)
         MP_ASSERT(pLog->nPut.load() == 0);
         MP_ASSERT(pLog->nGet.load() == 0);
         S.nFreeListHead = S.Pool[S.nFreeListHead]->nFreeListNext;
+        pLog->Reset();
     }
     else
     {
@@ -1158,7 +1178,6 @@ MicroProfileThreadLog* MicroProfileCreateThreadLog(const char* pName)
         S.nMemUsage += sizeof(MicroProfileThreadLog);
         S.Pool[S.nNumLogs++] = pLog;
     }
-    memset(pLog, 0, sizeof(*pLog));
     int len = (int)strlen(pName);
     int maxlen = sizeof(pLog->ThreadName)-1;
     len = len < maxlen ? len : maxlen;
@@ -1206,8 +1225,8 @@ void MicroProfileOnThreadExit()
         {
             S.Frames[i].nLogStart[nLogIndex] = 0;
         }
-        memset(pLog->nGroupStackPos, 0, sizeof(pLog->nGroupStackPos));
-        memset(pLog->nGroupTicks, 0, sizeof(pLog->nGroupTicks));
+        pLog->nGroupStackPos.fill(0);
+        pLog->nGroupTicks.fill(0);
     }
 }
 
diff --git a/externals/microprofile/microprofileui.h b/externals/microprofile/microprofileui.h
index fe2410cf4..85fbf2cb9 100644
--- a/externals/microprofile/microprofileui.h
+++ b/externals/microprofile/microprofileui.h
@@ -169,14 +169,13 @@ MICROPROFILEUI_API void MicroProfileCustomGroup(const char* pCustomName, uint32_
 MICROPROFILEUI_API void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup, const char* pTimer);
 
 #ifdef MICROPROFILEUI_IMPL
-#ifdef _WIN32
-#define snprintf _snprintf
-#endif
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <math.h>
 #include <algorithm>
+#include <array>
 
 MICROPROFILE_DEFINE(g_MicroProfileDetailed, "MicroProfile", "Detailed View", 0x8888000);
 MICROPROFILE_DEFINE(g_MicroProfileDrawGraph, "MicroProfile", "Draw Graph", 0xff44ee00);
@@ -227,10 +226,10 @@ struct SOptionDesc
     uint8_t nIndex;
     bool bSelected;
 };
-static uint32_t g_MicroProfileAggregatePresets[] = {0, 10, 20, 30, 60, 120};
-static float g_MicroProfileReferenceTimePresets[] = {5.f, 10.f, 15.f,20.f, 33.33f, 66.66f, 100.f, 250.f, 500.f, 1000.f};
-static uint32_t g_MicroProfileOpacityPresets[] = {0x40, 0x80, 0xc0, 0xff};
-static const char* g_MicroProfilePresetNames[] =
+static const std::array<uint32_t, 6> g_MicroProfileAggregatePresets{0, 10, 20, 30, 60, 120};
+static const std::array<float, 10> g_MicroProfileReferenceTimePresets{5.f, 10.f, 15.f,20.f, 33.33f, 66.66f, 100.f, 250.f, 500.f, 1000.f};
+static const std::array<uint32_t, 4> g_MicroProfileOpacityPresets{0x40, 0x80, 0xc0, 0xff};
+static const std::array<const char*, 7> g_MicroProfilePresetNames
 {
     MICROPROFILE_DEFAULT_PRESET,
     "Render",
@@ -243,8 +242,8 @@ static const char* g_MicroProfilePresetNames[] =
 
 enum
 {
-    MICROPROFILE_NUM_REFERENCE_PRESETS = sizeof(g_MicroProfileReferenceTimePresets)/sizeof(g_MicroProfileReferenceTimePresets[0]),
-    MICROPROFILE_NUM_OPACITY_PRESETS = sizeof(g_MicroProfileOpacityPresets)/sizeof(g_MicroProfileOpacityPresets[0]),
+    MICROPROFILE_NUM_REFERENCE_PRESETS = g_MicroProfileReferenceTimePresets.size(),
+    MICROPROFILE_NUM_OPACITY_PRESETS = g_MicroProfileOpacityPresets.size(),
 #if MICROPROFILE_CONTEXT_SWITCH_TRACE
     MICROPROFILE_OPTION_SIZE = MICROPROFILE_NUM_REFERENCE_PRESETS + MICROPROFILE_NUM_OPACITY_PRESETS * 2 + 2 + 7,
 #else
@@ -326,9 +325,9 @@ struct MicroProfileUI
 
 MicroProfileUI g_MicroProfileUI;
 #define UI g_MicroProfileUI
-static uint32_t g_nMicroProfileBackColors[2] = {  0x474747, 0x313131 };
+static const std::array<uint32_t, 2> g_nMicroProfileBackColors{  0x474747, 0x313131 };
 #define MICROPROFILE_NUM_CONTEXT_SWITCH_COLORS 16
-static uint32_t g_nMicroProfileContextSwitchThreadColors[MICROPROFILE_NUM_CONTEXT_SWITCH_COLORS] = //palette generated by http://tools.medialab.sciences-po.fr/iwanthue/index.php
+static const std::array<uint32_t, MICROPROFILE_NUM_CONTEXT_SWITCH_COLORS> g_nMicroProfileContextSwitchThreadColors //palette generated by http://tools.medialab.sciences-po.fr/iwanthue/index.php
 {
     0x63607B,
     0x755E2B,
@@ -356,7 +355,7 @@ void MicroProfileInitUI()
     {
         bInitialized = true;
         memset(&g_MicroProfileUI, 0, sizeof(g_MicroProfileUI));
-        UI.nActiveMenu = (uint32_t)-1;
+        UI.nActiveMenu = UINT32_MAX;
         UI.fDetailedOffsetTarget = UI.fDetailedOffset = 0.f;
         UI.fDetailedRangeTarget = UI.fDetailedRange = 50.f;
 
@@ -368,7 +367,7 @@ void MicroProfileInitUI()
         UI.nWidth = 100;
         UI.nHeight = 100;
 
-        UI.nCustomActive = (uint32_t)-1;
+        UI.nCustomActive = UINT32_MAX;
         UI.nCustomTimerCount = 0;
         UI.nCustomCount = 0;
 
@@ -498,8 +497,8 @@ inline void MicroProfileDrawFloatWindow(uint32_t nX, uint32_t nY, const char** p
         {
             MicroProfileDrawBox(nX-MICROPROFILE_TEXT_WIDTH, nY, nX, nY + MICROPROFILE_TEXT_WIDTH, pColors[i]|0xff000000);
         }
-        MicroProfileDrawText(nX + 1, nY + 1, (uint32_t)-1, ppStrings[i0], (uint32_t)strlen(ppStrings[i0]));
-        MicroProfileDrawText(nX + nWidth - nStringLengths[i0+1] * (MICROPROFILE_TEXT_WIDTH+1), nY + 1, (uint32_t)-1, ppStrings[i0+1], (uint32_t)strlen(ppStrings[i0+1]));
+        MicroProfileDrawText(nX + 1, nY + 1, UINT32_MAX, ppStrings[i0], (uint32_t)strlen(ppStrings[i0]));
+        MicroProfileDrawText(nX + nWidth - nStringLengths[i0+1] * (MICROPROFILE_TEXT_WIDTH+1), nY + 1, UINT32_MAX, ppStrings[i0+1], (uint32_t)strlen(ppStrings[i0+1]));
         nY += (MICROPROFILE_TEXT_HEIGHT+1);
     }
 }
@@ -522,7 +521,7 @@ inline void MicroProfileDrawTextBox(uint32_t nX, uint32_t nY, const char** ppStr
     MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000);
     for(uint32_t i = 0; i < nNumStrings; ++i)
     {
-        MicroProfileDrawText(nX + 1, nY + 1, (uint32_t)-1, ppStrings[i], (uint32_t)strlen(ppStrings[i]));
+        MicroProfileDrawText(nX + 1, nY + 1, UINT32_MAX, ppStrings[i], (uint32_t)strlen(ppStrings[i]));
         nY += (MICROPROFILE_TEXT_HEIGHT+1);
     }
 }
@@ -781,7 +780,7 @@ inline void MicroProfileDrawDetailedContextSwitchBars(uint32_t nY, uint32_t nThr
 {
     MicroProfile& S = *MicroProfileGet();
     int64_t nTickIn = -1;
-    uint32_t nThreadBefore = -1;
+    uint32_t nThreadBefore = UINT32_MAX;
     float fToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
     float fMsToScreen = UI.nWidth / UI.fDetailedRange;
     float fMouseX = (float)UI.nMouseX;
@@ -949,10 +948,10 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
 
     uint32_t nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadAfter;
     uint32_t nContextSwitchHoverThreadBefore = S.nContextSwitchHoverThreadBefore;
-    S.nContextSwitchHoverThread = S.nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadBefore = -1;
+    S.nContextSwitchHoverThread = S.nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadBefore = UINT32_MAX;
 
-    uint32_t nContextSwitchStart = -1;
-    uint32_t nContextSwitchEnd = -1;
+    uint32_t nContextSwitchStart = UINT32_MAX;
+    uint32_t nContextSwitchEnd = UINT32_MAX;
     S.nContextSwitchHoverCpuNext = 0xff;
     S.nContextSwitchHoverTickIn = -1;
     S.nContextSwitchHoverTickOut = -1;
@@ -1005,9 +1004,10 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
             }while(pFrameLogFirst != pFrameFirst);
 
 
-            if(nGet == (uint32_t)-1)
+            if (nGet == UINT32_MAX) {
                 continue;
-            MP_ASSERT(nGet != (uint32_t)-1);
+            }
+            MP_ASSERT(nGet != UINT32_MAX);
 
             nPut = pFrameLogLast->nLogStart[i];
 
@@ -1023,9 +1023,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
             int64_t nBaseTicks = bGpu ? nBaseTicksGpu : nBaseTicksCpu;
             char ThreadName[MicroProfileThreadLog::THREAD_MAX_LEN + 16];
             uint64_t nThreadId = pLog->nThreadId;
-            snprintf(ThreadName, sizeof(ThreadName)-1, "%04llx: %s", nThreadId, &pLog->ThreadName[0] );
+            snprintf(ThreadName, sizeof(ThreadName)-1, "%04" PRIx64 ": %s", nThreadId, &pLog->ThreadName[0] );
             nY += 3;
-            uint32_t nThreadColor = -1;
+            uint32_t nThreadColor = UINT32_MAX;
             if(pLog->nThreadId == nContextSwitchHoverThreadAfter || pLog->nThreadId == nContextSwitchHoverThreadBefore)
                 nThreadColor = UI.nHoverColorShared|0x906060;
             MicroProfileDrawText(0, nY, nThreadColor, &ThreadName[0], (uint32_t)strlen(&ThreadName[0]));
@@ -1048,7 +1048,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                 uint32_t nEnd = nRange[j][1];
                 for(uint32_t k = nStart; k < nEnd; ++k)
                 {
-                    MicroProfileLogEntry* pEntry = pLog->Log + k;
+                    MicroProfileLogEntry* pEntry = &pLog->Log[k];
                     int nType = MicroProfileLogType(*pEntry);
                     if(MP_LOG_ENTER == nType)
                     {
@@ -1066,7 +1066,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                             continue;
                         }
 
-                        MicroProfileLogEntry* pEntryEnter = pLog->Log + nStack[nStackPos-1];
+                        MicroProfileLogEntry* pEntryEnter = &pLog->Log[nStack[nStackPos-1]];
                         if(MicroProfileLogTimerIndex(*pEntryEnter) != MicroProfileLogTimerIndex(*pEntry))
                         {
                             //uprintf("mismatch %llx %llx\n", pEntryEnter->nToken, pEntry->nToken);
@@ -1126,7 +1126,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                         uint32_t nIntegerWidth = (uint32_t)(fXEnd - fXStart);
                         if(nIntegerWidth)
                         {
-                            if(bHover && UI.nActiveMenu == -1)
+                            if(bHover && UI.nActiveMenu == UINT32_MAX)
                             {
                                 nHoverToken = MicroProfileLogTimerIndex(*pEntry);
     #if MICROPROFILE_DEBUG
@@ -1146,7 +1146,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                 int nCharacters = (nTextWidth - 2*MICROPROFILE_TEXT_WIDTH) / MICROPROFILE_TEXT_WIDTH;
                                 if(nCharacters>0)
                                 {
-                                    MicroProfileDrawText(fXStartText+1, fYStart+1, -1, S.TimerInfo[nTimerIndex].pName, MicroProfileMin<uint32_t>(S.TimerInfo[nTimerIndex].nNameLen, nCharacters));
+                                    MicroProfileDrawText(fXStartText + 1, fYStart + 1, UINT32_MAX, S.TimerInfo[nTimerIndex].pName, MicroProfileMin<uint32_t>(S.TimerInfo[nTimerIndex].nNameLen, nCharacters));
                                 }
                             }
 #endif
@@ -1158,7 +1158,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                             int nLineX = (int)floor(fXAvg+0.5f);
                             if(nLineX != (int)nLinesDrawn[nStackPos])
                             {
-                                if(bHover && UI.nActiveMenu == -1)
+                                if(bHover && UI.nActiveMenu == UINT32_MAX)
                                 {
                                     nHoverToken = (uint32_t)MicroProfileLogTimerIndex(*pEntry);
                                     nHoverTime = MicroProfileLogTickDifference(nTickStart, nTickEnd);
@@ -1235,9 +1235,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                 // nThreadId is 32-bit on Windows
                 int nStrLen = snprintf(ThreadName, sizeof(ThreadName)-1, "%04x: %s%s", nThreadId, cLocal, i < nNumThreadsBase ? &S.Pool[i]->ThreadName[0] : MICROPROFILE_THREAD_NAME_FROM_ID(nThreadId) );
 #else
-                int nStrLen = snprintf(ThreadName, sizeof(ThreadName)-1, "%04llx: %s%s", nThreadId, cLocal, i < nNumThreadsBase ? &S.Pool[i]->ThreadName[0] : MICROPROFILE_THREAD_NAME_FROM_ID(nThreadId) );
+                int nStrLen = snprintf(ThreadName, sizeof(ThreadName)-1, "%04" PRIx64 ": %s%s", nThreadId, cLocal, i < nNumThreadsBase ? &S.Pool[i]->ThreadName[0] : MICROPROFILE_THREAD_NAME_FROM_ID(nThreadId) );
 #endif
-                uint32_t nThreadColor = -1;
+                uint32_t nThreadColor = UINT32_MAX;
                 if(nThreadId == nContextSwitchHoverThreadAfter || nThreadId == nContextSwitchHoverThreadBefore)
                     nThreadColor = UI.nHoverColorShared|0x906060;
                 MicroProfileDrawDetailedContextSwitchBars(nY+2, nThreadId, nContextSwitchStart, nContextSwitchEnd, nBaseTicksCpu, nBaseY);
@@ -1249,9 +1249,6 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
 
     S.nContextSwitchHoverCpu = S.nContextSwitchHoverCpuNext;
 
-
-
-
     UI.pDisplayMouseOver = pMouseOverNext;
 
     if(!S.nRunning)
@@ -1286,10 +1283,10 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
             float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart);
             float fStartTextX = fXStart - fStartTextWidth - 2;
             MicroProfileDrawBox(fStartTextX, nBaseY, fStartTextX + fStartTextWidth + 2, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
-            MicroProfileDrawText(fStartTextX+1, nBaseY, (uint32_t)-1, sBuffer, nLenStart);
+            MicroProfileDrawText(fStartTextX+1, nBaseY, UINT32_MAX, sBuffer, nLenStart);
             uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd);
             MicroProfileDrawBox(fXEnd+1, nBaseY, fXEnd+1+(1+MICROPROFILE_TEXT_WIDTH) * nLenEnd + 3, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
-            MicroProfileDrawText(fXEnd+2, nBaseY+1, (uint32_t)-1, sBuffer, nLenEnd);
+            MicroProfileDrawText(fXEnd+2, nBaseY+1, UINT32_MAX, sBuffer, nLenEnd);
 
             if(UI.nMouseRight)
             {
@@ -1316,10 +1313,10 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
             float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart);
             float fStartTextX = fXStart - fStartTextWidth - 2;
             MicroProfileDrawBox(fStartTextX, nBaseY, fStartTextX + fStartTextWidth + 2, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
-            MicroProfileDrawText(fStartTextX+1, nBaseY, (uint32_t)-1, sBuffer, nLenStart);
+            MicroProfileDrawText(fStartTextX+1, nBaseY, UINT32_MAX, sBuffer, nLenStart);
             uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd);
             MicroProfileDrawBox(fXEnd+1, nBaseY, fXEnd+1+(1+MICROPROFILE_TEXT_WIDTH) * nLenEnd + 3, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
-            MicroProfileDrawText(fXEnd+2, nBaseY+1, (uint32_t)-1, sBuffer, nLenEnd);
+            MicroProfileDrawText(fXEnd+2, nBaseY+1, UINT32_MAX, sBuffer, nLenEnd);
         }
     }
 }
@@ -1365,7 +1362,7 @@ inline void MicroProfileDrawDetailedFrameHistory(uint32_t nWidth, uint32_t nHeig
         fBaseX = fXStart;
         uint32_t nColor = MICROPROFILE_FRAME_HISTORY_COLOR_CPU;
         if(nIndex == nSelectedFrame)
-            nColor = (uint32_t)-1;
+            nColor = UINT32_MAX;
         MicroProfileDrawBox(fXStart, nBaseY + fScale * nBarHeight, fXEnd, nBaseY+MICROPROFILE_FRAME_HISTORY_HEIGHT, nColor, MicroProfileBoxTypeBar);
         if(pNext->nFrameStartCpu > nCpuStart)
         {
@@ -1387,7 +1384,7 @@ inline void MicroProfileDrawDetailedView(uint32_t nWidth, uint32_t nHeight)
     uint32_t nBaseY = MICROPROFILE_TEXT_HEIGHT + 1;
 
     int nSelectedFrame = -1;
-    if(UI.nMouseY > nBaseY && UI.nMouseY <= nBaseY + MICROPROFILE_FRAME_HISTORY_HEIGHT && UI.nActiveMenu == -1)
+    if(UI.nMouseY > nBaseY && UI.nMouseY <= nBaseY + MICROPROFILE_FRAME_HISTORY_HEIGHT && UI.nActiveMenu == UINT32_MAX)
     {
 
         nSelectedFrame = ((MICROPROFILE_NUM_FRAMES) * (UI.nWidth-UI.nMouseX) / UI.nWidth);
@@ -1425,7 +1422,7 @@ inline void MicroProfileDrawHeader(int32_t nX, uint32_t nWidth, const char* pNam
     if(pName)
     {
         MicroProfileDrawBox(nX-8, MICROPROFILE_TEXT_HEIGHT + 2, nX + nWidth+5, MICROPROFILE_TEXT_HEIGHT + 2 + (MICROPROFILE_TEXT_HEIGHT+1), 0xff000000|g_nMicroProfileBackColors[1]);
-        MicroProfileDrawText(nX, MICROPROFILE_TEXT_HEIGHT + 2, (uint32_t)-1, pName, (uint32_t)strlen(pName));
+        MicroProfileDrawText(nX, MICROPROFILE_TEXT_HEIGHT + 2, UINT32_MAX, pName, (uint32_t)strlen(pName));
     }
 }
 
@@ -1440,7 +1437,7 @@ inline void MicroProfileLoopActiveGroupsDraw(int32_t nX, int32_t nY, const char*
     uint32_t nCount = 0;
     for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
     {
-        uint64_t nMask = 1ll << j;
+        uint64_t nMask = 1ULL << j;
         if(nMask & nGroup)
         {
             nY += MICROPROFILE_TEXT_HEIGHT + 1;
@@ -1521,7 +1518,7 @@ inline void MicroProfileCalcTimers(float* pTimers, float* pAverage, float* pMax,
                 }
             }
         }
-        nMask <<= 1ll;
+        nMask <<= 1;
     }
 }
 
@@ -1543,7 +1540,7 @@ inline void MicroProfileDrawBarArrayCallback(uint32_t nTimer, uint32_t nIdx, uin
         snprintf(sBuffer, SBUF_MAX-1, "%5.2f", pTimers[nIdx]);
     if (!pTimers2)
         MicroProfileDrawBox(nX + nTextWidth, nY, nX + nTextWidth + fWidth * pTimers[nIdx+1], nY + nHeight, UI.nOpacityForeground|S.TimerInfo[nTimer].nColor, MicroProfileBoxTypeBar);
-    MicroProfileDrawText(nX, nY, (uint32_t)-1, sBuffer, (uint32_t)strlen(sBuffer));
+    MicroProfileDrawText(nX, nY, UINT32_MAX, sBuffer, (uint32_t)strlen(sBuffer));
 }
 
 
@@ -1564,7 +1561,7 @@ inline void MicroProfileDrawBarCallCountCallback(uint32_t nTimer, uint32_t nIdx,
     MicroProfile& S = *MicroProfileGet();
     char sBuffer[SBUF_MAX];
     int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5d", S.Frame[nTimer].nCount);//fix
-    MicroProfileDrawText(nX, nY, (uint32_t)-1, sBuffer, nLen);
+    MicroProfileDrawText(nX, nY, UINT32_MAX, sBuffer, nLen);
 }
 
 inline uint32_t MicroProfileDrawBarCallCount(int32_t nX, int32_t nY, const char* pName)
@@ -1588,7 +1585,7 @@ inline void MicroProfileDrawBarMetaAverageCallback(uint32_t nTimer, uint32_t nId
     float fRcpFrames = pArgs->fRcpFrames;
     char sBuffer[SBUF_MAX];
     int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5.2f", pCounters[nTimer] * fRcpFrames);
-    MicroProfileDrawText(nX - nLen * (MICROPROFILE_TEXT_WIDTH+1), nY, (uint32_t)-1, sBuffer, nLen);
+    MicroProfileDrawText(nX - nLen * (MICROPROFILE_TEXT_WIDTH+1), nY, UINT32_MAX, sBuffer, nLen);
 }
 
 inline uint32_t MicroProfileDrawBarMetaAverage(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
@@ -1609,8 +1606,8 @@ inline void MicroProfileDrawBarMetaCountCallback(uint32_t nTimer, uint32_t nIdx,
 {
     uint64_t* pCounters = (uint64_t*)pExtra;
     char sBuffer[SBUF_MAX];
-    int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5llu", pCounters[nTimer]);
-    MicroProfileDrawText(nX - nLen * (MICROPROFILE_TEXT_WIDTH+1), nY, (uint32_t)-1, sBuffer, nLen);
+    int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5" PRIu64, pCounters[nTimer]);
+    MicroProfileDrawText(nX - nLen * (MICROPROFILE_TEXT_WIDTH+1), nY, UINT32_MAX, sBuffer, nLen);
 }
 
 inline uint32_t MicroProfileDrawBarMetaCount(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
@@ -1667,7 +1664,7 @@ bool MicroProfileDrawGraph(uint32_t nScreenWidth, uint32_t nScreenHeight)
     if(bMouseOver)
     {
         float fXAvg = fMouseXPrc * MICROPROFILE_GRAPH_WIDTH + nX;
-        MicroProfileDrawLineVertical(fXAvg, nY, nY + MICROPROFILE_GRAPH_HEIGHT, (uint32_t)-1);
+        MicroProfileDrawLineVertical(fXAvg, nY, nY + MICROPROFILE_GRAPH_HEIGHT, UINT32_MAX);
     }
 
 
@@ -1706,7 +1703,7 @@ bool MicroProfileDrawGraph(uint32_t nScreenWidth, uint32_t nScreenHeight)
 
         char buf[32];
         int nLen = snprintf(buf, sizeof(buf)-1, "%5.2fms", S.fReferenceTime);
-        MicroProfileDrawText(nX+1, fY1 - (2+MICROPROFILE_TEXT_HEIGHT), (uint32_t)-1, buf, nLen);
+        MicroProfileDrawText(nX+1, fY1 - (2+MICROPROFILE_TEXT_HEIGHT), UINT32_MAX, buf, nLen);
     }
 
 
@@ -1782,7 +1779,7 @@ void MicroProfileDumpTimers()
 
     for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
     {
-        uint64_t nMask = 1ll << j;
+        uint64_t nMask = 1ULL << j;
         if(nMask & nActiveGroup)
         {
             MICROPROFILE_PRINTF("%s\n", S.GroupInfo[j].pName);
@@ -1823,7 +1820,7 @@ inline void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeigh
     uint32_t nNumGroups = 0;
     for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
     {
-        if(nActiveGroup & (1ll << j))
+        if(nActiveGroup & (1ULL << j))
         {
             nNumTimers += S.GroupInfo[j].nNumTimers;
             nNumGroups += 1;
@@ -1878,7 +1875,7 @@ inline void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeigh
         for(uint32_t i = 0; i < nNumTimers+nNumGroups+1; ++i)
         {
             uint32_t nY0 = nY + i * (nHeight + 1);
-            bool bInside = (UI.nActiveMenu == -1) && ((UI.nMouseY >= nY0) && (UI.nMouseY < (nY0 + nHeight + 1)));
+            bool bInside = (UI.nActiveMenu == UINT32_MAX) && ((UI.nMouseY >= nY0) && (UI.nMouseY < (nY0 + nHeight + 1)));
             MicroProfileDrawBox(nX, nY0, nWidth+nX, nY0 + (nHeight+1)+1, UI.nOpacityBackground | (g_nMicroProfileBackColors[nColorIndex++ & 1] + ((bInside) ? 0x002c2c2c : 0)));
         }
         nX += 10;
@@ -1927,22 +1924,22 @@ inline void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeigh
     nY = nHeight + 3 - UI.nOffsetY;
     for(uint32_t i = 0; i < nNumTimers+nNumGroups+1; ++i)
     {
-        uint32_t nY0 = nY + i * (nHeight + 1);
-        bool bInside = (UI.nActiveMenu == -1) && ((UI.nMouseY >= nY0) && (UI.nMouseY < (nY0 + nHeight + 1)));
+        const uint32_t nY0 = nY + i * (nHeight + 1);
+        const bool bInside = (UI.nActiveMenu == UINT32_MAX) && ((UI.nMouseY >= nY0) && (UI.nMouseY < (nY0 + nHeight + 1)));
         MicroProfileDrawBox(nX, nY0, nTimerWidth, nY0 + (nHeight+1)+1, 0xff0000000 | (g_nMicroProfileBackColors[nColorIndex++ & 1] + ((bInside) ? 0x002c2c2c : 0)));
     }
     nX += MicroProfileDrawBarLegend(nX, nY, nTotalHeight, nTimerWidth-5) + 1;
 
     for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
     {
-        if(nActiveGroup & (1ll << j))
+        if(nActiveGroup & (1ULL << j))
         {
-            MicroProfileDrawText(nX, nY + (1+nHeight) * nLegendOffset, (uint32_t)-1, S.GroupInfo[j].pName, S.GroupInfo[j].nNameLen);
+            MicroProfileDrawText(nX, nY + (1+nHeight) * nLegendOffset, UINT32_MAX, S.GroupInfo[j].pName, S.GroupInfo[j].nNameLen);
             nLegendOffset += S.GroupInfo[j].nNumTimers+1;
         }
     }
     MicroProfileDrawHeader(nX, nTimerWidth-5, "Group");
-    MicroProfileDrawTextRight(nTimerWidth-3, MICROPROFILE_TEXT_HEIGHT + 2, (uint32_t)-1, "Timer", 5);
+    MicroProfileDrawTextRight(nTimerWidth-3, MICROPROFILE_TEXT_HEIGHT + 2, UINT32_MAX, "Timer", 5);
     MicroProfileDrawLineVertical(nTimerWidth, 0, nTotalHeight+nY, UI.nOpacityBackground|g_nMicroProfileBackColors[0]|g_nMicroProfileBackColors[1]);
     MicroProfileDrawLineHorizontal(0, nWidth, 2*MICROPROFILE_TEXT_HEIGHT + 3, UI.nOpacityBackground|g_nMicroProfileBackColors[0]|g_nMicroProfileBackColors[1]);
 }
@@ -2003,7 +2000,7 @@ inline const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
             }
             else
             {
-                *bSelected = 0 != (S.nActiveGroupWanted & (1ll << Item.nIndex));
+                *bSelected = 0 != (S.nActiveGroupWanted & (1ULL << Item.nIndex));
                 snprintf(buffer, sizeof(buffer)-1, "   %s", Item.pName);
             }
             return buffer;
@@ -2015,16 +2012,18 @@ inline const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
 inline const char* MicroProfileUIMenuAggregate(int nIndex, bool* bSelected)
 {
     MicroProfile& S = *MicroProfileGet();
-    if(nIndex < sizeof(g_MicroProfileAggregatePresets)/sizeof(g_MicroProfileAggregatePresets[0]))
+    if(static_cast<uint32_t>(nIndex) < g_MicroProfileAggregatePresets.size())
     {
-        int val = g_MicroProfileAggregatePresets[nIndex];
-        *bSelected = (int)S.nAggregateFlip == val;
-        if(0 == val)
+        uint32_t val = g_MicroProfileAggregatePresets[nIndex];
+        *bSelected = S.nAggregateFlip == val;
+        if (0 == val)
+        {
             return "Infinite";
+        }
         else
         {
             static char buf[128];
-            snprintf(buf, sizeof(buf)-1, "%7d", val);
+            snprintf(buf, sizeof(buf)-1, "%7u", val);
             return buf;
         }
     }
@@ -2098,11 +2097,13 @@ inline const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
 {
     static char buf[128];
     *bSelected = false;
-    int nNumPresets = sizeof(g_MicroProfilePresetNames) / sizeof(g_MicroProfilePresetNames[0]);
+    int nNumPresets = static_cast<int>(g_MicroProfilePresetNames.size());
     int nIndexSave = nIndex - nNumPresets - 1;
-    if(nIndex == nNumPresets)
+    if (nIndex == nNumPresets)
+    {
         return "--";
-    else if(nIndexSave >=0 && nIndexSave <nNumPresets)
+    }
+    else if(nIndexSave >=0 && nIndexSave < nNumPresets)
     {
         snprintf(buf, sizeof(buf)-1, "Save '%s'", g_MicroProfilePresetNames[nIndexSave]);
         return buf;
@@ -2120,13 +2121,13 @@ inline const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
 
 inline const char* MicroProfileUIMenuCustom(int nIndex, bool* bSelected)
 {
-    if((uint32_t)-1 == UI.nCustomActive)
+    if(UINT32_MAX == UI.nCustomActive)
     {
         *bSelected = nIndex == 0;
     }
     else
     {
-        *bSelected = nIndex-2 == UI.nCustomActive;
+        *bSelected = nIndex-2 == static_cast<int>(UI.nCustomActive);
     }
     switch(nIndex)
     {
@@ -2202,7 +2203,7 @@ inline void MicroProfileUIClickGroups(int nIndex)
             else
             {
                 MP_ASSERT(Item.nIndex < S.nGroupCount);
-                S.nActiveGroupWanted ^= (1ll << Item.nIndex);
+                S.nActiveGroupWanted ^= (1ULL << Item.nIndex);
             }
         }
     }
@@ -2273,7 +2274,7 @@ inline void MicroProfileUIClickOptions(int nIndex)
 
 inline void MicroProfileUIClickPreset(int nIndex)
 {
-    int nNumPresets = sizeof(g_MicroProfilePresetNames) / sizeof(g_MicroProfilePresetNames[0]);
+    int nNumPresets = static_cast<int>(g_MicroProfilePresetNames.size());
     int nIndexSave = nIndex - nNumPresets - 1;
     if(nIndexSave >= 0 && nIndexSave < nNumPresets)
     {
@@ -2310,7 +2311,7 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
 
     uint32_t nX = 0;
     uint32_t nY = 0;
-    bool bMouseOver = UI.nMouseY < MICROPROFILE_TEXT_HEIGHT + 1;
+
 #define SBUF_SIZE 256
     char buffer[256];
     MicroProfileDrawBox(nX, nY, nX + nWidth, nY + (MICROPROFILE_TEXT_HEIGHT+1)+1, 0xff000000|g_nMicroProfileBackColors[1]);
@@ -2321,7 +2322,7 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
     uint32_t nNumMenuItems = 0;
 
     int nLen = snprintf(buffer, 127, "MicroProfile");
-    MicroProfileDrawText(nX, nY, (uint32_t)-1, buffer, nLen);
+    MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nLen);
     nX += (sizeof("MicroProfile")+2) * (MICROPROFILE_TEXT_WIDTH+1);
     pMenuText[nNumMenuItems++] = "Mode";
     pMenuText[nNumMenuItems++] = "Groups";
@@ -2409,7 +2410,7 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
     };
 
 
-    uint32_t nSelectMenu = (uint32_t)-1;
+    uint32_t nSelectMenu = UINT32_MAX;
     for(uint32_t i = 0; i < nNumMenuItems; ++i)
     {
         nMenuX[i] = nX;
@@ -2419,17 +2420,17 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
         {
             MicroProfileDrawBox(nX-1, nY, nX + nLen * (MICROPROFILE_TEXT_WIDTH+1), nY +(MICROPROFILE_TEXT_HEIGHT+1)+1, 0xff888888);
             nSelectMenu = i;
-            if((UI.nMouseLeft || UI.nMouseRight) && i == (int)nPauseIndex)
+            if((UI.nMouseLeft || UI.nMouseRight) && i == (uint32_t)nPauseIndex)
             {
                 S.nToggleRunning = 1;
             }
         }
-        MicroProfileDrawText(nX, nY, (uint32_t)-1, pMenuText[i], (uint32_t)strlen(pMenuText[i]));
+        MicroProfileDrawText(nX, nY, UINT32_MAX, pMenuText[i], (uint32_t)strlen(pMenuText[i]));
         nX += (nLen+1) * (MICROPROFILE_TEXT_WIDTH+1);
     }
-    uint32_t nMenu = nSelectMenu != (uint32_t)-1 ? nSelectMenu : UI.nActiveMenu;
+    uint32_t nMenu = nSelectMenu != UINT32_MAX ? nSelectMenu : UI.nActiveMenu;
     UI.nActiveMenu = nMenu;
-    if((uint32_t)-1 != nMenu)
+    if(UINT32_MAX != nMenu)
     {
         nX = nMenuX[nMenu];
         nY += MICROPROFILE_TEXT_HEIGHT+1;
@@ -2450,9 +2451,9 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
         {
             UI.nActiveMenu = nMenu;
         }
-        else if(nSelectMenu == (uint32_t)-1)
+        else if(nSelectMenu == UINT32_MAX)
         {
-            UI.nActiveMenu = (uint32_t)-1;
+            UI.nActiveMenu = UINT32_MAX;
         }
         MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000|g_nMicroProfileBackColors[1]);
         for(int i = 0; i < nNumLines; ++i)
@@ -2461,7 +2462,6 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
             const char* pString = CB(i, &bSelected);
             if(UI.nMouseY >= nY && UI.nMouseY < nY + MICROPROFILE_TEXT_HEIGHT + 1)
             {
-                bMouseOver = true;
                 if(UI.nMouseLeft || UI.nMouseRight)
                 {
                     CBClick[nMenu](i);
@@ -2469,7 +2469,7 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
                 MicroProfileDrawBox(nX, nY, nX + nWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888);
             }
             int nLen = snprintf(buffer, SBUF_SIZE-1, "%c %s", bSelected ? '*' : ' ' ,pString);
-            MicroProfileDrawText(nX, nY, (uint32_t)-1, buffer, nLen);
+            MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nLen);
             nY += MICROPROFILE_TEXT_HEIGHT+1;
         }
     }
@@ -2484,7 +2484,7 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
         float fMaxMs = fToMs * S.nFlipMaxDisplay;
         int nLen = snprintf(FrameTimeMessage, sizeof(FrameTimeMessage)-1, "Time[%6.2f] Avg[%6.2f] Max[%6.2f]", fMs, fAverageMs, fMaxMs);
         pMenuText[nNumMenuItems++] = &FrameTimeMessage[0];
-        MicroProfileDrawText(nWidth - nLen * (MICROPROFILE_TEXT_WIDTH+1), 0, -1, FrameTimeMessage, nLen);
+        MicroProfileDrawText(nWidth - nLen * (MICROPROFILE_TEXT_WIDTH+1), 0, UINT32_MAX, FrameTimeMessage, nLen);
     }
 }
 
@@ -2538,7 +2538,7 @@ inline void MicroProfileMoveGraph()
 
 inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
 {
-    if((uint32_t)-1 != UI.nCustomActive)
+    if(UINT32_MAX != UI.nCustomActive)
     {
         MicroProfile& S = *MicroProfileGet();
         MP_ASSERT(UI.nCustomActive < MICROPROFILE_CUSTOM_MAX);
@@ -2571,8 +2571,8 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
             pColors[i] = S.TimerInfo[nTimerIndex].nColor;
         }
 
-        MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING + 3*MICROPROFILE_TEXT_WIDTH, nOffsetY, (uint32_t)-1, "Avg", sizeof("Avg")-1);
-        MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING + 13*MICROPROFILE_TEXT_WIDTH, nOffsetY, (uint32_t)-1, "Max", sizeof("Max")-1);
+        MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING + 3*MICROPROFILE_TEXT_WIDTH, nOffsetY, UINT32_MAX, "Avg", sizeof("Avg")-1);
+        MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING + 13*MICROPROFILE_TEXT_WIDTH, nOffsetY, UINT32_MAX, "Max", sizeof("Max")-1);
         for(uint32_t i = 0; i < nCount; ++i)
         {
             nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
@@ -2582,10 +2582,10 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
             int nSize;
             uint32_t nOffsetX = MICROPROFILE_CUSTOM_PADDING;
             nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2f", pTimeAvg[i]);
-            MicroProfileDrawText(nOffsetX, nOffsetY, (uint32_t)-1, Buffer, nSize);
+            MicroProfileDrawText(nOffsetX, nOffsetY, UINT32_MAX, Buffer, nSize);
             nOffsetX += (nSize+2) * (MICROPROFILE_TEXT_WIDTH+1);
             nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2f", pTimeMax[i]);
-            MicroProfileDrawText(nOffsetX, nOffsetY, (uint32_t)-1, Buffer, nSize);
+            MicroProfileDrawText(nOffsetX, nOffsetY, UINT32_MAX, Buffer, nSize);
             nOffsetX += (nSize+2) * (MICROPROFILE_TEXT_WIDTH+1);
             nSize = snprintf(Buffer, sizeof(Buffer)-1, "%s:%s", S.GroupInfo[nGroupIndex].pName, pTimerInfo->pName);
             MicroProfileDrawText(nOffsetX, nOffsetY, pTimerInfo->nColor, Buffer, nSize);
@@ -2599,9 +2599,9 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
             nOffsetY = nOffsetYBase;
             float* pMs = pCustom->nFlags & MICROPROFILE_CUSTOM_BAR_SOURCE_MAX ? pTimeMax : pTimeAvg;
             const char* pString = pCustom->nFlags & MICROPROFILE_CUSTOM_BAR_SOURCE_MAX ? "Max" : "Avg";
-            MicroProfileDrawText(nMaxOffsetX, nOffsetY, (uint32_t)-1, pString, static_cast<uint32_t>(strlen(pString)));
+            MicroProfileDrawText(nMaxOffsetX, nOffsetY, UINT32_MAX, pString, static_cast<uint32_t>(strlen(pString)));
             int nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2fms", fReference);
-            MicroProfileDrawText(nReducedWidth - (1+nSize) * (MICROPROFILE_TEXT_WIDTH+1), nOffsetY, (uint32_t)-1, Buffer, nSize);
+            MicroProfileDrawText(nReducedWidth - (1+nSize) * (MICROPROFILE_TEXT_WIDTH+1), nOffsetY, UINT32_MAX, Buffer, nSize);
             for(uint32_t i = 0; i < nCount; ++i)
             {
                 nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
@@ -2613,9 +2613,9 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
         {
             nOffsetY += 2*(1+MICROPROFILE_TEXT_HEIGHT);
             const char* pString = pCustom->nFlags & MICROPROFILE_CUSTOM_STACK_SOURCE_MAX ? "Max" : "Avg";
-            MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING, nOffsetY, (uint32_t)-1, pString, static_cast<uint32_t>(strlen(pString)));
+            MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING, nOffsetY, UINT32_MAX, pString, static_cast<uint32_t>(strlen(pString)));
             int nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2fms", fReference);
-            MicroProfileDrawText(nReducedWidth - (1+nSize) * (MICROPROFILE_TEXT_WIDTH+1), nOffsetY, (uint32_t)-1, Buffer, nSize);
+            MicroProfileDrawText(nReducedWidth - (1+nSize) * (MICROPROFILE_TEXT_WIDTH+1), nOffsetY, UINT32_MAX, Buffer, nSize);
             nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
             float fPosX = MICROPROFILE_CUSTOM_PADDING;
             float* pMs = pCustom->nFlags & MICROPROFILE_CUSTOM_STACK_SOURCE_MAX ? pTimeMax : pTimeAvg;
@@ -2668,7 +2668,7 @@ inline void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
         UI.nHoverTime = 0;
         UI.nHoverFrame = -1;
         if(S.nDisplay != MP_DRAW_DETAILED)
-            S.nContextSwitchHoverThread = S.nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadBefore = -1;
+            S.nContextSwitchHoverThread = S.nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadBefore = UINT32_MAX;
         MicroProfileMoveGraph();
 
 
@@ -2798,13 +2798,13 @@ inline void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
 
 
 
-            if(UI.nActiveMenu == -1 && !bMouseOverGraph)
+            if(UI.nActiveMenu == UINT32_MAX && !bMouseOverGraph)
             {
                 if(UI.nHoverToken != MICROPROFILE_INVALID_TOKEN)
                 {
                     MicroProfileDrawFloatTooltip(UI.nMouseX, UI.nMouseY, UI.nHoverToken, UI.nHoverTime);
                 }
-                else if(S.nContextSwitchHoverThreadAfter != -1 && S.nContextSwitchHoverThreadBefore != -1)
+                else if(S.nContextSwitchHoverThreadAfter != UINT32_MAX && S.nContextSwitchHoverThreadBefore != UINT32_MAX)
                 {
                     float fToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
                     MicroProfileStringArray ToolTip;
@@ -2820,7 +2820,7 @@ inline void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
                     MicroProfileStringArrayFormat(&ToolTip, "%6.2fms", fToMs * nDifference );
                     MicroProfileStringArrayAddLiteral(&ToolTip, "CPU");
                     MicroProfileStringArrayFormat(&ToolTip, "%d", S.nContextSwitchHoverCpu);
-                    MicroProfileDrawFloatWindow(UI.nMouseX, UI.nMouseY+20, &ToolTip.ppStrings[0], ToolTip.nNumStrings, -1);
+                    MicroProfileDrawFloatWindow(UI.nMouseX, UI.nMouseY+20, &ToolTip.ppStrings[0], ToolTip.nNumStrings, UINT32_MAX);
 
 
                 }
@@ -2858,7 +2858,7 @@ inline void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
                         }
                     }
                     #endif
-                    MicroProfileDrawFloatWindow(UI.nMouseX, UI.nMouseY+20, &ToolTip.ppStrings[0], ToolTip.nNumStrings, -1);
+                    MicroProfileDrawFloatWindow(UI.nMouseX, UI.nMouseY+20, &ToolTip.ppStrings[0], ToolTip.nNumStrings, UINT32_MAX);
                 }
                 if(UI.nMouseLeft)
                 {
@@ -2883,7 +2883,7 @@ inline void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
 #endif
         m.unlock();
     }
-    else if(UI.nCustomActive != (uint32_t)-1)
+    else if(UI.nCustomActive != UINT32_MAX)
     {
         std::recursive_mutex& m = MicroProfileGetMutex();
         m.lock();
@@ -3179,7 +3179,7 @@ void MicroProfileLoadPreset(const char* pSuffix)
             {
                 if(0 == MP_STRCASECMP(pGroupName, S.GroupInfo[j].pName))
                 {
-                    S.nActiveGroupWanted |= (1ll << j);
+                    S.nActiveGroupWanted |= (1ULL << j);
                 }
             }
         }
@@ -3212,7 +3212,7 @@ void MicroProfileLoadPreset(const char* pSuffix)
                 uint64_t nGroupIndex = S.TimerInfo[j].nGroupIndex;
                 if(0 == MP_STRCASECMP(pGraphName, S.TimerInfo[j].pName) && 0 == MP_STRCASECMP(pGraphGroupName, S.GroupInfo[nGroupIndex].pName))
                 {
-                    MicroProfileToken nToken = MicroProfileMakeToken(1ll << nGroupIndex, (uint16_t)j);
+                    MicroProfileToken nToken = MicroProfileMakeToken(1ULL << nGroupIndex, (uint16_t)j);
                     S.Graph[i].nToken = nToken;         // note: group index is stored here but is checked without in MicroProfileToggleGraph()!
                     S.TimerInfo[j].bGraph = true;
                     if(nToken != nPrevToken)
@@ -3235,7 +3235,7 @@ inline uint32_t MicroProfileCustomGroupFind(const char* pCustomName)
             return i;
         }
     }
-    return (uint32_t)-1;
+    return UINT32_MAX;
 }
 
 inline uint32_t MicroProfileCustomGroup(const char* pCustomName)
@@ -3251,7 +3251,7 @@ inline uint32_t MicroProfileCustomGroup(const char* pCustomName)
     uint32_t nIndex = UI.nCustomCount;
     UI.nCustomCount++;
     memset(&UI.Custom[nIndex], 0, sizeof(UI.Custom[nIndex]));
-    uint32_t nLen = (uint32_t)strlen(pCustomName);
+    size_t nLen = strlen(pCustomName);
     if(nLen > MICROPROFILE_NAME_MAX_LEN-1)
         nLen = MICROPROFILE_NAME_MAX_LEN-1;
     memcpy(&UI.Custom[nIndex].pName[0], pCustomName, nLen);
@@ -3309,7 +3309,7 @@ inline void MicroProfileCustomGroupEnable(uint32_t nIndex)
 void MicroProfileCustomGroupToggle(const char* pCustomName)
 {
     uint32_t nIndex = MicroProfileCustomGroupFind(pCustomName);
-    if(nIndex == (uint32_t)-1 || nIndex == UI.nCustomActive)
+    if(nIndex == UINT32_MAX || nIndex == UI.nCustomActive)
     {
         MicroProfileCustomGroupDisable();
     }
@@ -3328,13 +3328,13 @@ void MicroProfileCustomGroupDisable()
 {
     MicroProfile& S = *MicroProfileGet();
     S.nForceGroupUI = 0;
-    UI.nCustomActive = (uint32_t)-1;
+    UI.nCustomActive = UINT32_MAX;
 }
 
 void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup, const char* pTimer)
 {
     uint32_t nIndex = MicroProfileCustomGroupFind(pCustomName);
-    if((uint32_t)-1 == nIndex)
+    if(UINT32_MAX == nIndex)
     {
         return;
     }
@@ -3344,7 +3344,7 @@ void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup
     MP_ASSERT(nToken != MICROPROFILE_INVALID_TOKEN); //Timer must be registered first.
     UI.Custom[nIndex].pTimers[nTimerIndex] = nToken;
     uint16_t nGroup = MicroProfileGetGroupIndex(nToken);
-    UI.Custom[nIndex].nGroupMask |= (1ll << nGroup);
+    UI.Custom[nIndex].nGroupMask |= (1ULL << nGroup);
     UI.Custom[nIndex].nNumTimers++;
 }