Merge pull request #4565 from lioncash/memset

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

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);
     }
 }
 

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++;
 }