The-Homebrew-Cloud/Lime3DS
2
0
Fork 0
mirror of https://github.com/Lime3DS/Lime3DS.git synced 2024-12-25 17:21:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

microprofile: Don't memset through std::atomic types (#5528)

Browse Source 
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.

Co-authored-by: Lioncash <mathew1800@gmail.com>
This commit is contained in:
Tobias 2020-12-07 16:04:31 +01:00 committed by GitHub
parent 4888a14c12
commit c557b290af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 144 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
externals/microprofile/microprofile.h vendored
View File

@ -152,9 +152,11 @@ typedef uint16_t MicroProfileGroupId;
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <thread> #include <algorithm>
#include <mutex> #include <array>
#include <atomic> #include <atomic>
#include <mutex>
#include <thread>
#ifndef MICROPROFILE_API #ifndef MICROPROFILE_API
#define MICROPROFILE_API #define MICROPROFILE_API
@ -605,28 +607,45 @@ struct MicroProfileFrameState
struct MicroProfileThreadLog struct MicroProfileThreadLog
{ {
MicroProfileLogEntry Log[MICROPROFILE_BUFFER_SIZE]; std::array<MicroProfileLogEntry, MICROPROFILE_BUFFER_SIZE> Log{};
std::atomic<uint32_t> nPut; std::atomic<uint32_t> nPut{0};
std::atomic<uint32_t> nGet; std::atomic<uint32_t> nGet{0};
uint32_t nActive; uint32_t nActive = 0;
uint32_t nGpu; uint32_t nGpu = 0;
ThreadIdType nThreadId; ThreadIdType nThreadId{};
uint32_t nStack[MICROPROFILE_STACK_MAX]; std::array<uint32_t, MICROPROFILE_STACK_MAX> nStack{};
int64_t nChildTickStack[MICROPROFILE_STACK_MAX]; std::array<int64_t, MICROPROFILE_STACK_MAX> nChildTickStack{};
uint32_t nStackPos; uint32_t nStackPos = 0;
uint8_t nGroupStackPos[MICROPROFILE_MAX_GROUPS]; std::array<uint8_t, MICROPROFILE_MAX_GROUPS> nGroupStackPos{};
int64_t nGroupTicks[MICROPROFILE_MAX_GROUPS]; std::array<int64_t, MICROPROFILE_MAX_GROUPS> nGroupTicks{};
int64_t nAggregateGroupTicks[MICROPROFILE_MAX_GROUPS]; std::array<int64_t, MICROPROFILE_MAX_GROUPS> nAggregateGroupTicks{};
enum enum
{ {
THREAD_MAX_LEN = 64, THREAD_MAX_LEN = 64,
}; };
char ThreadName[64]; char ThreadName[64]{};
int nFreeListNext; 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 #if MICROPROFILE_GPU_TIMERS_D3D11
@ -1155,6 +1174,7 @@ MicroProfileThreadLog* MicroProfileCreateThreadLog(const char* pName)
MP_ASSERT(pLog->nPut.load() == 0); MP_ASSERT(pLog->nPut.load() == 0);
MP_ASSERT(pLog->nGet.load() == 0); MP_ASSERT(pLog->nGet.load() == 0);
S.nFreeListHead = S.Pool[S.nFreeListHead]->nFreeListNext; S.nFreeListHead = S.Pool[S.nFreeListHead]->nFreeListNext;
pLog->Reset();
} }
else else
{ {
@ -1162,7 +1182,6 @@ MicroProfileThreadLog* MicroProfileCreateThreadLog(const char* pName)
S.nMemUsage += sizeof(MicroProfileThreadLog); S.nMemUsage += sizeof(MicroProfileThreadLog);
S.Pool[S.nNumLogs++] = pLog; S.Pool[S.nNumLogs++] = pLog;
} }
memset(pLog, 0, sizeof(*pLog));
int len = (int)strlen(pName); int len = (int)strlen(pName);
int maxlen = sizeof(pLog->ThreadName)-1; int maxlen = sizeof(pLog->ThreadName)-1;
len = len < maxlen ? len : maxlen; len = len < maxlen ? len : maxlen;
@ -1210,8 +1229,8 @@ void MicroProfileOnThreadExit()
{ {
S.Frames[i].nLogStart[nLogIndex] = 0; S.Frames[i].nLogStart[nLogIndex] = 0;
} }
memset(pLog->nGroupStackPos, 0, sizeof(pLog->nGroupStackPos)); pLog->nGroupStackPos.fill(0);
memset(pLog->nGroupTicks, 0, sizeof(pLog->nGroupTicks)); pLog->nGroupTicks.fill(0);
} }
} }

206
externals/microprofile/microprofileui.h vendored
View File

@ -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); MICROPROFILEUI_API void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup, const char* pTimer);
#ifdef MICROPROFILEUI_IMPL #ifdef MICROPROFILEUI_IMPL
#ifdef _WIN32 #include <inttypes.h>
#define snprintf _snprintf
#endif
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdarg.h> #include <stdarg.h>
#include <math.h> #include <math.h>
#include <algorithm> #include <algorithm>
#include <array>
MICROPROFILE_DEFINE(g_MicroProfileDetailed, "MicroProfile", "Detailed View", 0x8888000); MICROPROFILE_DEFINE(g_MicroProfileDetailed, "MicroProfile", "Detailed View", 0x8888000);
MICROPROFILE_DEFINE(g_MicroProfileDrawGraph, "MicroProfile", "Draw Graph", 0xff44ee00); MICROPROFILE_DEFINE(g_MicroProfileDrawGraph, "MicroProfile", "Draw Graph", 0xff44ee00);
@ -227,10 +226,10 @@ struct SOptionDesc
uint8_t nIndex; uint8_t nIndex;
bool bSelected; bool bSelected;
}; };
static uint32_t g_MicroProfileAggregatePresets[] = {0, 10, 20, 30, 60, 120}; static const std::array<uint32_t, 6> 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 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 uint32_t g_MicroProfileOpacityPresets[] = {0x40, 0x80, 0xc0, 0xff}; static const std::array<uint32_t, 4> g_MicroProfileOpacityPresets{0x40, 0x80, 0xc0, 0xff};
static const char* g_MicroProfilePresetNames[] = static const std::array<const char*, 7> g_MicroProfilePresetNames
{ {
MICROPROFILE_DEFAULT_PRESET, MICROPROFILE_DEFAULT_PRESET,
"Render", "Render",
@ -243,8 +242,8 @@ static const char* g_MicroProfilePresetNames[] =
enum enum
{ {
MICROPROFILE_NUM_REFERENCE_PRESETS = sizeof(g_MicroProfileReferenceTimePresets)/sizeof(g_MicroProfileReferenceTimePresets[0]), MICROPROFILE_NUM_REFERENCE_PRESETS = g_MicroProfileReferenceTimePresets.size(),
MICROPROFILE_NUM_OPACITY_PRESETS = sizeof(g_MicroProfileOpacityPresets)/sizeof(g_MicroProfileOpacityPresets[0]), MICROPROFILE_NUM_OPACITY_PRESETS = g_MicroProfileOpacityPresets.size(),
#if MICROPROFILE_CONTEXT_SWITCH_TRACE #if MICROPROFILE_CONTEXT_SWITCH_TRACE
MICROPROFILE_OPTION_SIZE = MICROPROFILE_NUM_REFERENCE_PRESETS + MICROPROFILE_NUM_OPACITY_PRESETS * 2 + 2 + 7, MICROPROFILE_OPTION_SIZE = MICROPROFILE_NUM_REFERENCE_PRESETS + MICROPROFILE_NUM_OPACITY_PRESETS * 2 + 2 + 7,
#else #else
@ -326,9 +325,9 @@ struct MicroProfileUI
MicroProfileUI g_MicroProfileUI; MicroProfileUI g_MicroProfileUI;
#define UI 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 #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, 0x63607B,
0x755E2B, 0x755E2B,
@ -356,7 +355,7 @@ void MicroProfileInitUI()
{ {
bInitialized = true; bInitialized = true;
memset(&g_MicroProfileUI, 0, sizeof(g_MicroProfileUI)); memset(&g_MicroProfileUI, 0, sizeof(g_MicroProfileUI));
UI.nActiveMenu = (uint32_t)-1; UI.nActiveMenu = UINT32_MAX;
UI.fDetailedOffsetTarget = UI.fDetailedOffset = 0.f; UI.fDetailedOffsetTarget = UI.fDetailedOffset = 0.f;
UI.fDetailedRangeTarget = UI.fDetailedRange = 50.f; UI.fDetailedRangeTarget = UI.fDetailedRange = 50.f;
@ -368,7 +367,7 @@ void MicroProfileInitUI()
UI.nWidth = 100; UI.nWidth = 100;
UI.nHeight = 100; UI.nHeight = 100;
UI.nCustomActive = (uint32_t)-1; UI.nCustomActive = UINT32_MAX;
UI.nCustomTimerCount = 0; UI.nCustomTimerCount = 0;
UI.nCustomCount = 0; UI.nCustomCount = 0;
@ -498,8 +497,8 @@ void MicroProfileDrawFloatWindow(uint32_t nX, uint32_t nY, const char** ppString
{ {
MicroProfileDrawBox(nX-MICROPROFILE_TEXT_WIDTH, nY, nX, nY + MICROPROFILE_TEXT_WIDTH, pColors[i]|0xff000000); 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 + 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_t)-1, ppStrings[i0+1], (uint32_t)strlen(ppStrings[i0+1])); 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); nY += (MICROPROFILE_TEXT_HEIGHT+1);
} }
} }
@ -522,7 +521,7 @@ void MicroProfileDrawTextBox(uint32_t nX, uint32_t nY, const char** ppStrings, u
MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000); MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000);
for(uint32_t i = 0; i < nNumStrings; ++i) 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); nY += (MICROPROFILE_TEXT_HEIGHT+1);
} }
} }
@ -781,7 +780,7 @@ void MicroProfileDrawDetailedContextSwitchBars(uint32_t nY, uint32_t nThreadId,
{ {
MicroProfile& S = *MicroProfileGet(); MicroProfile& S = *MicroProfileGet();
int64_t nTickIn = -1; int64_t nTickIn = -1;
uint32_t nThreadBefore = -1; uint32_t nThreadBefore = UINT32_MAX;
float fToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu()); float fToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fMsToScreen = UI.nWidth / UI.fDetailedRange; float fMsToScreen = UI.nWidth / UI.fDetailedRange;
float fMouseX = (float)UI.nMouseX; float fMouseX = (float)UI.nMouseX;
@ -949,10 +948,10 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
uint32_t nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadAfter; uint32_t nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadAfter;
uint32_t nContextSwitchHoverThreadBefore = S.nContextSwitchHoverThreadBefore; 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 nContextSwitchStart = UINT32_MAX;
uint32_t nContextSwitchEnd = -1; uint32_t nContextSwitchEnd = UINT32_MAX;
S.nContextSwitchHoverCpuNext = 0xff; S.nContextSwitchHoverCpuNext = 0xff;
S.nContextSwitchHoverTickIn = -1; S.nContextSwitchHoverTickIn = -1;
S.nContextSwitchHoverTickOut = -1; S.nContextSwitchHoverTickOut = -1;
@ -1005,9 +1004,10 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
}while(pFrameLogFirst != pFrameFirst); }while(pFrameLogFirst != pFrameFirst);
if(nGet == (uint32_t)-1) if (nGet == UINT32_MAX) {
continue; continue;
MP_ASSERT(nGet != (uint32_t)-1); }
MP_ASSERT(nGet != UINT32_MAX);
nPut = pFrameLogLast->nLogStart[i]; nPut = pFrameLogLast->nLogStart[i];
@ -1023,9 +1023,9 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
int64_t nBaseTicks = bGpu ? nBaseTicksGpu : nBaseTicksCpu; int64_t nBaseTicks = bGpu ? nBaseTicksGpu : nBaseTicksCpu;
char ThreadName[MicroProfileThreadLog::THREAD_MAX_LEN + 16]; char ThreadName[MicroProfileThreadLog::THREAD_MAX_LEN + 16];
uint64_t nThreadId = pLog->nThreadId; 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; nY += 3;
uint32_t nThreadColor = -1; uint32_t nThreadColor = UINT32_MAX;
if(pLog->nThreadId == nContextSwitchHoverThreadAfter || pLog->nThreadId == nContextSwitchHoverThreadBefore) if(pLog->nThreadId == nContextSwitchHoverThreadAfter || pLog->nThreadId == nContextSwitchHoverThreadBefore)
nThreadColor = UI.nHoverColorShared|0x906060; nThreadColor = UI.nHoverColorShared|0x906060;
MicroProfileDrawText(0, nY, nThreadColor, &ThreadName[0], (uint32_t)strlen(&ThreadName[0])); MicroProfileDrawText(0, nY, nThreadColor, &ThreadName[0], (uint32_t)strlen(&ThreadName[0]));
@ -1048,7 +1048,7 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
uint32_t nEnd = nRange[j][1]; uint32_t nEnd = nRange[j][1];
for(uint32_t k = nStart; k < nEnd; ++k) for(uint32_t k = nStart; k < nEnd; ++k)
{ {
MicroProfileLogEntry* pEntry = pLog->Log + k; MicroProfileLogEntry* pEntry = &pLog->Log[k];
int nType = MicroProfileLogType(*pEntry); int nType = MicroProfileLogType(*pEntry);
if(MP_LOG_ENTER == nType) if(MP_LOG_ENTER == nType)
{ {
@ -1066,7 +1066,7 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
continue; continue;
} }
MicroProfileLogEntry* pEntryEnter = pLog->Log + nStack[nStackPos-1]; MicroProfileLogEntry* pEntryEnter = &pLog->Log[nStack[nStackPos-1]];
if(MicroProfileLogTimerIndex(*pEntryEnter) != MicroProfileLogTimerIndex(*pEntry)) if(MicroProfileLogTimerIndex(*pEntryEnter) != MicroProfileLogTimerIndex(*pEntry))
{ {
//uprintf("mismatch %llx %llx\n", pEntryEnter->nToken, pEntry->nToken); //uprintf("mismatch %llx %llx\n", pEntryEnter->nToken, pEntry->nToken);
@ -1126,7 +1126,7 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
uint32_t nIntegerWidth = (uint32_t)(fXEnd - fXStart); uint32_t nIntegerWidth = (uint32_t)(fXEnd - fXStart);
if(nIntegerWidth) if(nIntegerWidth)
{ {
if(bHover && UI.nActiveMenu == -1) if(bHover && UI.nActiveMenu == UINT32_MAX)
{ {
nHoverToken = MicroProfileLogTimerIndex(*pEntry); nHoverToken = MicroProfileLogTimerIndex(*pEntry);
#if MICROPROFILE_DEBUG #if MICROPROFILE_DEBUG
@ -1146,7 +1146,7 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
int nCharacters = (nTextWidth - 2*MICROPROFILE_TEXT_WIDTH) / MICROPROFILE_TEXT_WIDTH; int nCharacters = (nTextWidth - 2*MICROPROFILE_TEXT_WIDTH) / MICROPROFILE_TEXT_WIDTH;
if(nCharacters>0) 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 #endif
@ -1158,7 +1158,7 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
int nLineX = (int)floor(fXAvg+0.5f); int nLineX = (int)floor(fXAvg+0.5f);
if(nLineX != (int)nLinesDrawn[nStackPos]) if(nLineX != (int)nLinesDrawn[nStackPos])
{ {
if(bHover && UI.nActiveMenu == -1) if(bHover && UI.nActiveMenu == UINT32_MAX)
{ {
nHoverToken = (uint32_t)MicroProfileLogTimerIndex(*pEntry); nHoverToken = (uint32_t)MicroProfileLogTimerIndex(*pEntry);
nHoverTime = MicroProfileLogTickDifference(nTickStart, nTickEnd); nHoverTime = MicroProfileLogTickDifference(nTickStart, nTickEnd);
@ -1235,9 +1235,9 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
// nThreadId is 32-bit on Windows // 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) ); 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 #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 #endif
uint32_t nThreadColor = -1; uint32_t nThreadColor = UINT32_MAX;
if(nThreadId == nContextSwitchHoverThreadAfter || nThreadId == nContextSwitchHoverThreadBefore) if(nThreadId == nContextSwitchHoverThreadAfter || nThreadId == nContextSwitchHoverThreadBefore)
nThreadColor = UI.nHoverColorShared|0x906060; nThreadColor = UI.nHoverColorShared|0x906060;
MicroProfileDrawDetailedContextSwitchBars(nY+2, nThreadId, nContextSwitchStart, nContextSwitchEnd, nBaseTicksCpu, nBaseY); MicroProfileDrawDetailedContextSwitchBars(nY+2, nThreadId, nContextSwitchStart, nContextSwitchEnd, nBaseTicksCpu, nBaseY);
@ -1249,9 +1249,6 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
S.nContextSwitchHoverCpu = S.nContextSwitchHoverCpuNext; S.nContextSwitchHoverCpu = S.nContextSwitchHoverCpuNext;
UI.pDisplayMouseOver = pMouseOverNext; UI.pDisplayMouseOver = pMouseOverNext;
if(!S.nRunning) if(!S.nRunning)
@ -1286,10 +1283,10 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart); float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart);
float fStartTextX = fXStart - fStartTextWidth - 2; float fStartTextX = fXStart - fStartTextWidth - 2;
MicroProfileDrawBox(fStartTextX, nBaseY, fStartTextX + fStartTextWidth + 2, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat); 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); 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); 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) if(UI.nMouseRight)
{ {
@ -1316,10 +1313,10 @@ void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY,
float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart); float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart);
float fStartTextX = fXStart - fStartTextWidth - 2; float fStartTextX = fXStart - fStartTextWidth - 2;
MicroProfileDrawBox(fStartTextX, nBaseY, fStartTextX + fStartTextWidth + 2, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat); 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); 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); 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 @@ void MicroProfileDrawDetailedFrameHistory(uint32_t nWidth, uint32_t nHeight, uin
fBaseX = fXStart; fBaseX = fXStart;
uint32_t nColor = MICROPROFILE_FRAME_HISTORY_COLOR_CPU; uint32_t nColor = MICROPROFILE_FRAME_HISTORY_COLOR_CPU;
if(nIndex == nSelectedFrame) if(nIndex == nSelectedFrame)
nColor = (uint32_t)-1; nColor = UINT32_MAX;
MicroProfileDrawBox(fXStart, nBaseY + fScale * nBarHeight, fXEnd, nBaseY+MICROPROFILE_FRAME_HISTORY_HEIGHT, nColor, MicroProfileBoxTypeBar); MicroProfileDrawBox(fXStart, nBaseY + fScale * nBarHeight, fXEnd, nBaseY+MICROPROFILE_FRAME_HISTORY_HEIGHT, nColor, MicroProfileBoxTypeBar);
if(pNext->nFrameStartCpu > nCpuStart) if(pNext->nFrameStartCpu > nCpuStart)
{ {
@ -1387,7 +1384,7 @@ void MicroProfileDrawDetailedView(uint32_t nWidth, uint32_t nHeight)
uint32_t nBaseY = MICROPROFILE_TEXT_HEIGHT + 1; uint32_t nBaseY = MICROPROFILE_TEXT_HEIGHT + 1;
int nSelectedFrame = -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); nSelectedFrame = ((MICROPROFILE_NUM_FRAMES) * (UI.nWidth-UI.nMouseX) / UI.nWidth);
@ -1425,7 +1422,7 @@ void MicroProfileDrawHeader(int32_t nX, uint32_t nWidth, const char* pName)
if(pName) if(pName)
{ {
MicroProfileDrawBox(nX-8, MICROPROFILE_TEXT_HEIGHT + 2, nX + nWidth+5, MICROPROFILE_TEXT_HEIGHT + 2 + (MICROPROFILE_TEXT_HEIGHT+1), 0xff000000|g_nMicroProfileBackColors[1]); 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 @@ void MicroProfileLoopActiveGroupsDraw(int32_t nX, int32_t nY, const char* pName,
uint32_t nCount = 0; uint32_t nCount = 0;
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j) for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{ {
uint64_t nMask = 1ll << j; uint64_t nMask = 1ULL << j;
if(nMask & nGroup) if(nMask & nGroup)
{ {
nY += MICROPROFILE_TEXT_HEIGHT + 1; nY += MICROPROFILE_TEXT_HEIGHT + 1;
@ -1521,7 +1518,7 @@ void MicroProfileCalcTimers(float* pTimers, float* pAverage, float* pMax, float*
} }
} }
} }
nMask <<= 1ll; nMask <<= 1;
} }
} }
@ -1543,7 +1540,7 @@ void MicroProfileDrawBarArrayCallback(uint32_t nTimer, uint32_t nIdx, uint64_t n
snprintf(sBuffer, SBUF_MAX-1, "%5.2f", pTimers[nIdx]); snprintf(sBuffer, SBUF_MAX-1, "%5.2f", pTimers[nIdx]);
if (!pTimers2) if (!pTimers2)
MicroProfileDrawBox(nX + nTextWidth, nY, nX + nTextWidth + fWidth * pTimers[nIdx+1], nY + nHeight, UI.nOpacityForeground|S.TimerInfo[nTimer].nColor, MicroProfileBoxTypeBar); 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 @@ void MicroProfileDrawBarCallCountCallback(uint32_t nTimer, uint32_t nIdx, uint64
MicroProfile& S = *MicroProfileGet(); MicroProfile& S = *MicroProfileGet();
char sBuffer[SBUF_MAX]; char sBuffer[SBUF_MAX];
int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5d", S.Frame[nTimer].nCount);//fix 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);
} }
uint32_t MicroProfileDrawBarCallCount(int32_t nX, int32_t nY, const char* pName) uint32_t MicroProfileDrawBarCallCount(int32_t nX, int32_t nY, const char* pName)
@ -1588,7 +1585,7 @@ void MicroProfileDrawBarMetaAverageCallback(uint32_t nTimer, uint32_t nIdx, uint
float fRcpFrames = pArgs->fRcpFrames; float fRcpFrames = pArgs->fRcpFrames;
char sBuffer[SBUF_MAX]; char sBuffer[SBUF_MAX];
int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5.2f", pCounters[nTimer] * fRcpFrames); 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);
} }
uint32_t MicroProfileDrawBarMetaAverage(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight) uint32_t MicroProfileDrawBarMetaAverage(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
@ -1609,8 +1606,8 @@ void MicroProfileDrawBarMetaCountCallback(uint32_t nTimer, uint32_t nIdx, uint64
{ {
uint64_t* pCounters = (uint64_t*)pExtra; uint64_t* pCounters = (uint64_t*)pExtra;
char sBuffer[SBUF_MAX]; char sBuffer[SBUF_MAX];
int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5llu", pCounters[nTimer]); int nLen = snprintf(sBuffer, SBUF_MAX-1, "%5" PRIu64, pCounters[nTimer]);
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);
} }
uint32_t MicroProfileDrawBarMetaCount(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight) 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) if(bMouseOver)
{ {
float fXAvg = fMouseXPrc * MICROPROFILE_GRAPH_WIDTH + nX; 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]; char buf[32];
int nLen = snprintf(buf, sizeof(buf)-1, "%5.2fms", S.fReferenceTime); 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) for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{ {
uint64_t nMask = 1ll << j; uint64_t nMask = 1ULL << j;
if(nMask & nActiveGroup) if(nMask & nActiveGroup)
{ {
MICROPROFILE_PRINTF("%s\n", S.GroupInfo[j].pName); MICROPROFILE_PRINTF("%s\n", S.GroupInfo[j].pName);
@ -1823,7 +1820,7 @@ void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeight)
uint32_t nNumGroups = 0; uint32_t nNumGroups = 0;
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j) for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{ {
if(nActiveGroup & (1ll << j)) if(nActiveGroup & (1ULL << j))
{ {
nNumTimers += S.GroupInfo[j].nNumTimers; nNumTimers += S.GroupInfo[j].nNumTimers;
nNumGroups += 1; nNumGroups += 1;
@ -1878,7 +1875,7 @@ void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeight)
for(uint32_t i = 0; i < nNumTimers+nNumGroups+1; ++i) for(uint32_t i = 0; i < nNumTimers+nNumGroups+1; ++i)
{ {
uint32_t nY0 = nY + i * (nHeight + 1); 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))); MicroProfileDrawBox(nX, nY0, nWidth+nX, nY0 + (nHeight+1)+1, UI.nOpacityBackground | (g_nMicroProfileBackColors[nColorIndex++ & 1] + ((bInside) ? 0x002c2c2c : 0)));
} }
nX += 10; nX += 10;
@ -1927,22 +1924,22 @@ void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeight)
nY = nHeight + 3 - UI.nOffsetY; nY = nHeight + 3 - UI.nOffsetY;
for(uint32_t i = 0; i < nNumTimers+nNumGroups+1; ++i) for(uint32_t i = 0; i < nNumTimers+nNumGroups+1; ++i)
{ {
uint32_t nY0 = nY + i * (nHeight + 1); const uint32_t nY0 = nY + i * (nHeight + 1);
bool bInside = (UI.nActiveMenu == -1) && ((UI.nMouseY >= nY0) && (UI.nMouseY < (nY0 + 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))); MicroProfileDrawBox(nX, nY0, nTimerWidth, nY0 + (nHeight+1)+1, 0xff0000000 | (g_nMicroProfileBackColors[nColorIndex++ & 1] + ((bInside) ? 0x002c2c2c : 0)));
} }
nX += MicroProfileDrawBarLegend(nX, nY, nTotalHeight, nTimerWidth-5) + 1; nX += MicroProfileDrawBarLegend(nX, nY, nTotalHeight, nTimerWidth-5) + 1;
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j) 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; nLegendOffset += S.GroupInfo[j].nNumTimers+1;
} }
} }
MicroProfileDrawHeader(nX, nTimerWidth-5, "Group"); 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]); 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]); MicroProfileDrawLineHorizontal(0, nWidth, 2*MICROPROFILE_TEXT_HEIGHT + 3, UI.nOpacityBackground|g_nMicroProfileBackColors[0]|g_nMicroProfileBackColors[1]);
} }
@ -2003,7 +2000,7 @@ const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
} }
else else
{ {
*bSelected = 0 != (S.nActiveGroupWanted & (1ll << Item.nIndex)); *bSelected = 0 != (S.nActiveGroupWanted & (1ULL << Item.nIndex));
snprintf(buffer, sizeof(buffer)-1, " %s", Item.pName); snprintf(buffer, sizeof(buffer)-1, " %s", Item.pName);
} }
return buffer; return buffer;
@ -2015,16 +2012,18 @@ const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
const char* MicroProfileUIMenuAggregate(int nIndex, bool* bSelected) const char* MicroProfileUIMenuAggregate(int nIndex, bool* bSelected)
{ {
MicroProfile& S = *MicroProfileGet(); 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]; uint32_t val = g_MicroProfileAggregatePresets[nIndex];
*bSelected = (int)S.nAggregateFlip == val; *bSelected = S.nAggregateFlip == val;
if (0 == val) if (0 == val)
{
return "Infinite"; return "Infinite";
}
else else
{ {
static char buf[128]; static char buf[128];
snprintf(buf, sizeof(buf)-1, "%7d", val); snprintf(buf, sizeof(buf)-1, "%7u", val);
return buf; return buf;
} }
} }
@ -2098,10 +2097,12 @@ const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
{ {
static char buf[128]; static char buf[128];
*bSelected = false; *bSelected = false;
int nNumPresets = sizeof(g_MicroProfilePresetNames) / sizeof(g_MicroProfilePresetNames[0]); int nNumPresets = static_cast<int>(g_MicroProfilePresetNames.size());
int nIndexSave = nIndex - nNumPresets - 1; int nIndexSave = nIndex - nNumPresets - 1;
if (nIndex == nNumPresets) if (nIndex == nNumPresets)
{
return "--"; return "--";
}
else if(nIndexSave >=0 && nIndexSave < nNumPresets) else if(nIndexSave >=0 && nIndexSave < nNumPresets)
{ {
snprintf(buf, sizeof(buf)-1, "Save '%s'", g_MicroProfilePresetNames[nIndexSave]); snprintf(buf, sizeof(buf)-1, "Save '%s'", g_MicroProfilePresetNames[nIndexSave]);
@ -2120,13 +2121,13 @@ const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
const char* MicroProfileUIMenuCustom(int nIndex, bool* bSelected) const char* MicroProfileUIMenuCustom(int nIndex, bool* bSelected)
{ {
if((uint32_t)-1 == UI.nCustomActive) if(UINT32_MAX == UI.nCustomActive)
{ {
*bSelected = nIndex == 0; *bSelected = nIndex == 0;
} }
else else
{ {
*bSelected = nIndex-2 == UI.nCustomActive; *bSelected = nIndex-2 == static_cast<int>(UI.nCustomActive);
} }
switch(nIndex) switch(nIndex)
{ {
@ -2202,7 +2203,7 @@ void MicroProfileUIClickGroups(int nIndex)
else else
{ {
MP_ASSERT(Item.nIndex < S.nGroupCount); MP_ASSERT(Item.nIndex < S.nGroupCount);
S.nActiveGroupWanted ^= (1ll << Item.nIndex); S.nActiveGroupWanted ^= (1ULL << Item.nIndex);
} }
} }
} }
@ -2273,7 +2274,7 @@ void MicroProfileUIClickOptions(int nIndex)
void MicroProfileUIClickPreset(int nIndex) 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; int nIndexSave = nIndex - nNumPresets - 1;
if(nIndexSave >= 0 && nIndexSave < nNumPresets) if(nIndexSave >= 0 && nIndexSave < nNumPresets)
{ {
@ -2310,7 +2311,7 @@ void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
uint32_t nX = 0; uint32_t nX = 0;
uint32_t nY = 0; uint32_t nY = 0;
bool bMouseOver = UI.nMouseY < MICROPROFILE_TEXT_HEIGHT + 1;
#define SBUF_SIZE 256 #define SBUF_SIZE 256
char buffer[256]; char buffer[256];
MicroProfileDrawBox(nX, nY, nX + nWidth, nY + (MICROPROFILE_TEXT_HEIGHT+1)+1, 0xff000000|g_nMicroProfileBackColors[1]); MicroProfileDrawBox(nX, nY, nX + nWidth, nY + (MICROPROFILE_TEXT_HEIGHT+1)+1, 0xff000000|g_nMicroProfileBackColors[1]);
@ -2321,7 +2322,7 @@ void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
uint32_t nNumMenuItems = 0; uint32_t nNumMenuItems = 0;
int nLen = snprintf(buffer, 127, "MicroProfile"); 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); nX += (sizeof("MicroProfile")+2) * (MICROPROFILE_TEXT_WIDTH+1);
pMenuText[nNumMenuItems++] = "Mode"; pMenuText[nNumMenuItems++] = "Mode";
pMenuText[nNumMenuItems++] = "Groups"; pMenuText[nNumMenuItems++] = "Groups";
@ -2409,7 +2410,7 @@ 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) for(uint32_t i = 0; i < nNumMenuItems; ++i)
{ {
nMenuX[i] = nX; nMenuX[i] = nX;
@ -2419,17 +2420,17 @@ 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); MicroProfileDrawBox(nX-1, nY, nX + nLen * (MICROPROFILE_TEXT_WIDTH+1), nY +(MICROPROFILE_TEXT_HEIGHT+1)+1, 0xff888888);
nSelectMenu = i; nSelectMenu = i;
if((UI.nMouseLeft || UI.nMouseRight) && i == (int)nPauseIndex) if((UI.nMouseLeft || UI.nMouseRight) && i == (uint32_t)nPauseIndex)
{ {
S.nToggleRunning = 1; 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); 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; UI.nActiveMenu = nMenu;
if((uint32_t)-1 != nMenu) if(UINT32_MAX != nMenu)
{ {
nX = nMenuX[nMenu]; nX = nMenuX[nMenu];
nY += MICROPROFILE_TEXT_HEIGHT+1; nY += MICROPROFILE_TEXT_HEIGHT+1;
@ -2450,9 +2451,9 @@ void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
{ {
UI.nActiveMenu = nMenu; 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]); MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000|g_nMicroProfileBackColors[1]);
for(int i = 0; i < nNumLines; ++i) for(int i = 0; i < nNumLines; ++i)
@ -2461,7 +2462,6 @@ void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
const char* pString = CB(i, &bSelected); const char* pString = CB(i, &bSelected);
if(UI.nMouseY >= nY && UI.nMouseY < nY + MICROPROFILE_TEXT_HEIGHT + 1) if(UI.nMouseY >= nY && UI.nMouseY < nY + MICROPROFILE_TEXT_HEIGHT + 1)
{ {
bMouseOver = true;
if(UI.nMouseLeft || UI.nMouseRight) if(UI.nMouseLeft || UI.nMouseRight)
{ {
CBClick[nMenu](i); CBClick[nMenu](i);
@ -2469,7 +2469,7 @@ void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
MicroProfileDrawBox(nX, nY, nX + nWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888); MicroProfileDrawBox(nX, nY, nX + nWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888);
} }
int nLen = snprintf(buffer, SBUF_SIZE-1, "%c %s", bSelected ? '*' : ' ' ,pString); 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; nY += MICROPROFILE_TEXT_HEIGHT+1;
} }
} }
@ -2484,7 +2484,7 @@ void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
float fMaxMs = fToMs * S.nFlipMaxDisplay; float fMaxMs = fToMs * S.nFlipMaxDisplay;
int nLen = snprintf(FrameTimeMessage, sizeof(FrameTimeMessage)-1, "Time[%6.2f] Avg[%6.2f] Max[%6.2f]", fMs, fAverageMs, fMaxMs); int nLen = snprintf(FrameTimeMessage, sizeof(FrameTimeMessage)-1, "Time[%6.2f] Avg[%6.2f] Max[%6.2f]", fMs, fAverageMs, fMaxMs);
pMenuText[nNumMenuItems++] = &FrameTimeMessage[0]; 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 @@ void MicroProfileMoveGraph()
void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight) void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
{ {
if((uint32_t)-1 != UI.nCustomActive) if(UINT32_MAX != UI.nCustomActive)
{ {
MicroProfile& S = *MicroProfileGet(); MicroProfile& S = *MicroProfileGet();
MP_ASSERT(UI.nCustomActive < MICROPROFILE_CUSTOM_MAX); MP_ASSERT(UI.nCustomActive < MICROPROFILE_CUSTOM_MAX);
@ -2571,8 +2571,8 @@ void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
pColors[i] = S.TimerInfo[nTimerIndex].nColor; 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 + 3*MICROPROFILE_TEXT_WIDTH, nOffsetY, UINT32_MAX, "Avg", sizeof("Avg")-1);
MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING + 13*MICROPROFILE_TEXT_WIDTH, nOffsetY, (uint32_t)-1, "Max", sizeof("Max")-1); MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING + 13*MICROPROFILE_TEXT_WIDTH, nOffsetY, UINT32_MAX, "Max", sizeof("Max")-1);
for(uint32_t i = 0; i < nCount; ++i) for(uint32_t i = 0; i < nCount; ++i)
{ {
nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT); nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
@ -2582,10 +2582,10 @@ void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
int nSize; int nSize;
uint32_t nOffsetX = MICROPROFILE_CUSTOM_PADDING; uint32_t nOffsetX = MICROPROFILE_CUSTOM_PADDING;
nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2f", pTimeAvg[i]); 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); nOffsetX += (nSize+2) * (MICROPROFILE_TEXT_WIDTH+1);
nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2f", pTimeMax[i]); 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); nOffsetX += (nSize+2) * (MICROPROFILE_TEXT_WIDTH+1);
nSize = snprintf(Buffer, sizeof(Buffer)-1, "%s:%s", S.GroupInfo[nGroupIndex].pName, pTimerInfo->pName); nSize = snprintf(Buffer, sizeof(Buffer)-1, "%s:%s", S.GroupInfo[nGroupIndex].pName, pTimerInfo->pName);
MicroProfileDrawText(nOffsetX, nOffsetY, pTimerInfo->nColor, Buffer, nSize); MicroProfileDrawText(nOffsetX, nOffsetY, pTimerInfo->nColor, Buffer, nSize);
@ -2599,9 +2599,9 @@ void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
nOffsetY = nOffsetYBase; nOffsetY = nOffsetYBase;
float* pMs = pCustom->nFlags & MICROPROFILE_CUSTOM_BAR_SOURCE_MAX ? pTimeMax : pTimeAvg; float* pMs = pCustom->nFlags & MICROPROFILE_CUSTOM_BAR_SOURCE_MAX ? pTimeMax : pTimeAvg;
const char* pString = pCustom->nFlags & MICROPROFILE_CUSTOM_BAR_SOURCE_MAX ? "Max" : "Avg"; const char* pString = pCustom->nFlags & MICROPROFILE_CUSTOM_BAR_SOURCE_MAX ? "Max" : "Avg";
MicroProfileDrawText(nMaxOffsetX, nOffsetY, (uint32_t)-1, pString, strlen(pString)); MicroProfileDrawText(nMaxOffsetX, nOffsetY, UINT32_MAX, pString, static_cast<uint32_t>(strlen(pString)));
int nSize = snprintf(Buffer, sizeof(Buffer)-1, "%6.2fms", fReference); 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) for(uint32_t i = 0; i < nCount; ++i)
{ {
nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT); nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
@ -2613,9 +2613,9 @@ void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
{ {
nOffsetY += 2*(1+MICROPROFILE_TEXT_HEIGHT); nOffsetY += 2*(1+MICROPROFILE_TEXT_HEIGHT);
const char* pString = pCustom->nFlags & MICROPROFILE_CUSTOM_STACK_SOURCE_MAX ? "Max" : "Avg"; const char* pString = pCustom->nFlags & MICROPROFILE_CUSTOM_STACK_SOURCE_MAX ? "Max" : "Avg";
MicroProfileDrawText(MICROPROFILE_CUSTOM_PADDING, nOffsetY, (uint32_t)-1, pString, 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); 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); nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
float fPosX = MICROPROFILE_CUSTOM_PADDING; float fPosX = MICROPROFILE_CUSTOM_PADDING;
float* pMs = pCustom->nFlags & MICROPROFILE_CUSTOM_STACK_SOURCE_MAX ? pTimeMax : pTimeAvg; float* pMs = pCustom->nFlags & MICROPROFILE_CUSTOM_STACK_SOURCE_MAX ? pTimeMax : pTimeAvg;
@ -2668,7 +2668,7 @@ void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
UI.nHoverTime = 0; UI.nHoverTime = 0;
UI.nHoverFrame = -1; UI.nHoverFrame = -1;
if(S.nDisplay != MP_DRAW_DETAILED) if(S.nDisplay != MP_DRAW_DETAILED)
S.nContextSwitchHoverThread = S.nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadBefore = -1; S.nContextSwitchHoverThread = S.nContextSwitchHoverThreadAfter = S.nContextSwitchHoverThreadBefore = UINT32_MAX;
MicroProfileMoveGraph(); MicroProfileMoveGraph();
@ -2798,13 +2798,13 @@ 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) if(UI.nHoverToken != MICROPROFILE_INVALID_TOKEN)
{ {
MicroProfileDrawFloatTooltip(UI.nMouseX, UI.nMouseY, UI.nHoverToken, UI.nHoverTime); 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()); float fToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
MicroProfileStringArray ToolTip; MicroProfileStringArray ToolTip;
@ -2820,7 +2820,7 @@ void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
MicroProfileStringArrayFormat(&ToolTip, "%6.2fms", fToMs * nDifference ); MicroProfileStringArrayFormat(&ToolTip, "%6.2fms", fToMs * nDifference );
MicroProfileStringArrayAddLiteral(&ToolTip, "CPU"); MicroProfileStringArrayAddLiteral(&ToolTip, "CPU");
MicroProfileStringArrayFormat(&ToolTip, "%d", S.nContextSwitchHoverCpu); 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 @@ void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
} }
} }
#endif #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) if(UI.nMouseLeft)
{ {
@ -2883,7 +2883,7 @@ void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
#endif #endif
m.unlock(); m.unlock();
} }
else if(UI.nCustomActive != (uint32_t)-1) else if(UI.nCustomActive != UINT32_MAX)
{ {
std::recursive_mutex& m = MicroProfileGetMutex(); std::recursive_mutex& m = MicroProfileGetMutex();
m.lock(); m.lock();
@ -3179,7 +3179,7 @@ void MicroProfileLoadPreset(const char* pSuffix)
{ {
if(0 == MP_STRCASECMP(pGroupName, S.GroupInfo[j].pName)) 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; uint64_t nGroupIndex = S.TimerInfo[j].nGroupIndex;
if(0 == MP_STRCASECMP(pGraphName, S.TimerInfo[j].pName) && 0 == MP_STRCASECMP(pGraphGroupName, S.GroupInfo[nGroupIndex].pName)) 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.Graph[i].nToken = nToken; // note: group index is stored here but is checked without in MicroProfileToggleGraph()!
S.TimerInfo[j].bGraph = true; S.TimerInfo[j].bGraph = true;
if(nToken != nPrevToken) if(nToken != nPrevToken)
@ -3235,7 +3235,7 @@ uint32_t MicroProfileCustomGroupFind(const char* pCustomName)
return i; return i;
} }
} }
return (uint32_t)-1; return UINT32_MAX;
} }
uint32_t MicroProfileCustomGroup(const char* pCustomName) uint32_t MicroProfileCustomGroup(const char* pCustomName)
@ -3251,7 +3251,7 @@ uint32_t MicroProfileCustomGroup(const char* pCustomName)
uint32_t nIndex = UI.nCustomCount; uint32_t nIndex = UI.nCustomCount;
UI.nCustomCount++; UI.nCustomCount++;
memset(&UI.Custom[nIndex], 0, sizeof(UI.Custom[nIndex])); 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) if(nLen > MICROPROFILE_NAME_MAX_LEN-1)
nLen = MICROPROFILE_NAME_MAX_LEN-1; nLen = MICROPROFILE_NAME_MAX_LEN-1;
memcpy(&UI.Custom[nIndex].pName[0], pCustomName, nLen); memcpy(&UI.Custom[nIndex].pName[0], pCustomName, nLen);
@ -3309,7 +3309,7 @@ void MicroProfileCustomGroupEnable(uint32_t nIndex)
void MicroProfileCustomGroupToggle(const char* pCustomName) void MicroProfileCustomGroupToggle(const char* pCustomName)
{ {
uint32_t nIndex = MicroProfileCustomGroupFind(pCustomName); uint32_t nIndex = MicroProfileCustomGroupFind(pCustomName);
if(nIndex == (uint32_t)-1 || nIndex == UI.nCustomActive) if(nIndex == UINT32_MAX || nIndex == UI.nCustomActive)
{ {
MicroProfileCustomGroupDisable(); MicroProfileCustomGroupDisable();
} }
@ -3328,13 +3328,13 @@ void MicroProfileCustomGroupDisable()
{ {
MicroProfile& S = *MicroProfileGet(); MicroProfile& S = *MicroProfileGet();
S.nForceGroupUI = 0; S.nForceGroupUI = 0;
UI.nCustomActive = (uint32_t)-1; UI.nCustomActive = UINT32_MAX;
} }
void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup, const char* pTimer) void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup, const char* pTimer)
{ {
uint32_t nIndex = MicroProfileCustomGroupFind(pCustomName); uint32_t nIndex = MicroProfileCustomGroupFind(pCustomName);
if((uint32_t)-1 == nIndex) if(UINT32_MAX == nIndex)
{ {
return; return;
} }
@ -3344,7 +3344,7 @@ void MicroProfileCustomGroupAddTimer(const char* pCustomName, const char* pGroup
MP_ASSERT(nToken != MICROPROFILE_INVALID_TOKEN); //Timer must be registered first. MP_ASSERT(nToken != MICROPROFILE_INVALID_TOKEN); //Timer must be registered first.
UI.Custom[nIndex].pTimers[nTimerIndex] = nToken; UI.Custom[nIndex].pTimers[nTimerIndex] = nToken;
uint16_t nGroup = MicroProfileGetGroupIndex(nToken); uint16_t nGroup = MicroProfileGetGroupIndex(nToken);
UI.Custom[nIndex].nGroupMask |= (1ll << nGroup); UI.Custom[nIndex].nGroupMask |= (1ULL << nGroup);
UI.Custom[nIndex].nNumTimers++; UI.Custom[nIndex].nNumTimers++;
} }