void WorkerThreadLong(int threadId)
{
uint32_t c0 = 0xff3399ff;
uint32_t c1 = 0xffff99ff;
char name[100];
snprintf(name, 99, "Worker_long%d", threadId);
MicroProfileOnThreadCreate(&name[0]);
while(!g_nQuit)
{
MICROPROFILE_SCOPEI("long", "outer 150ms", c0);
MICROPROFILE_META_CPU("Sleep",100);
usleep(100*1000);
for(int i = 0; i < 10; ++i)
{
MICROPROFILE_SCOPEI("long", "inner 5ms", c1);
MICROPROFILE_META_CPU("Sleep",5);
usleep(5000);
}
}
}
void EngineService::AcceptVisitor( JobFiber& /*fiber*/, const ServiceTickVisitor ) {
MICROPROFILE_SCOPEI( GetName(), "Update", 0xABBBCB );
XAUDIO2_PERFORMANCE_DATA performanceData;
_audio->GetPerformanceData( &performanceData );
if( _audioGlitchCount != performanceData.GlitchesSinceEngineStarted ) {
_audioGlitchCount = performanceData.GlitchesSinceEngineStarted;
_log( MessageSeverity::Error, "XAudio reported audio processing stall since last invocation of IXAudio2::GetPerformanceData()!" ET_UTF8_NEWLINE_LITERAL );
}
}
void spinsleep(int64_t nUs)
{
MICROPROFILE_SCOPEI("spin","sleep", 0xffff);
float fToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
int64_t nTickStart = MP_TICK();
float fElapsed = 0;
float fTarget = nUs / 1000000.f;
do
{
int64_t nTickEnd = MP_TICK();
fElapsed = (nTickEnd - nTickStart) * fToMs;
}while(fElapsed < fTarget);
}
int main()
{
MicroProfileSetForceEnable(true);
MicroProfileOnThreadCreate("Main");
{
MICROPROFILE_SCOPEI("Group", "Name", -1);
MICROPROFILE_LABEL("Group", "Label");
MICROPROFILE_LABELF("Group", "Label %d", 5);
}
MicroProfileFlip();
MicroProfileOnThreadExit();
}
void DrawGLStuff()
{
MICROPROFILE_SCOPEI("MicroProfile", "DRAWSTUFF", 0xffff3456);
MICROPROFILE_SCOPEGPUI("DRAWSTUFF", 0xffff4444);
glUseProgramObjectARB(g_Program);
glBindVertexArray(g_VAO);
static float f = 0;
f += 0.01f;
int amount =(int)( (((cos(f) + 1) * 0.5f) *10)+ 2);
MP_ASSERT(amount > 0);
for(int i = 0; i < amount; ++i)
{
MICROPROFILE_SCOPEGPUI("DRAWSTUFF_INNER", 0xffff4444);
glDrawArrays(GL_TRIANGLES, 0, QUADS*6);
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glUseProgramObjectARB(0);
glBindVertexArray(0);
}
void WorkerThread(int threadId)
{
char name[100];
snprintf(name, 99, "Worker%d", threadId);
MicroProfileOnThreadCreate(&name[0]);
uint32_t c0 = 0xff3399ff;
uint32_t c1 = 0xffff99ff;
uint32_t c2 = 0xff33ff00;
uint32_t c3 = 0xff3399ff;
uint32_t c4 = 0xff33ff33;
while(!g_nQuit)
{
switch(threadId)
{
case 0:
{
usleep(100);
{
MICROPROFILE_SCOPEI("Thread0", "Work Thread0", c4);
MICROPROFILE_META_CPU("Sleep",10);
usleep(200);
{
MICROPROFILE_SCOPEI("Thread0", "Work Thread1", c3);
MICROPROFILE_META_CPU("DrawCalls", 1);
MICROPROFILE_META_CPU("DrawCalls", 1);
MICROPROFILE_META_CPU("DrawCalls", 1);
usleep(200);
{
MICROPROFILE_SCOPEI("Thread0", "Work Thread2", c2);
MICROPROFILE_META_CPU("DrawCalls", 1);
usleep(200);
{
MICROPROFILE_SCOPEI("Thread0", "Work Thread3", c1);
MICROPROFILE_META_CPU("DrawCalls", 4);
MICROPROFILE_META_CPU("Triangles",1000);
usleep(200);
}
}
}
}
}
break;
case 1:
{
usleep(100);
MICROPROFILE_SCOPEI("Thread1", "Work Thread 1", c1);
usleep(2000);
}
break;
case 2:
{
usleep(1000);
{
MICROPROFILE_SCOPEI("Thread2", "Worker2", c0);
spinsleep(100000);
{
MICROPROFILE_SCOPEI("Thread2", "InnerWork0", c1);
spinsleep(100);
{
MICROPROFILE_SCOPEI("Thread2", "InnerWork1", c2);
usleep(100);
{
MICROPROFILE_SCOPEI("Thread2", "InnerWork2", c3);
usleep(100);
{
// for(uint32_t i = 0; i < 1000; ++i)
// {
// MICROPROFILE_SCOPEI("Thread2", "InnerWork3", c4);
// spinsleep(10);
// }
}
}
}
}
}
}
break;
case 3:
{
MICROPROFILE_SCOPEI("ThreadWork", "MAIN", c0);
usleep(1000);;
for(uint32_t i = 0; i < 10; ++i)
{
MICROPROFILE_SCOPEI("ThreadWork", "Inner0", c1);
usleep(100);
for(uint32_t j = 0; j < 4; ++j)
{
MICROPROFILE_SCOPEI("ThreadWork", "Inner1", c4);
usleep(50);
MICROPROFILE_SCOPEI("ThreadWork", "Inner1", c4);
usleep(50);
MICROPROFILE_SCOPEI("ThreadWork", "Inner2", c2);
usleep(50);
MICROPROFILE_SCOPEI("ThreadWork", "Inner3", c3);
usleep(50);
MICROPROFILE_SCOPEI("ThreadWork", "Inner4", c3);
usleep(50);
}
}
}
break;
default:
MICROPROFILE_SCOPE(ThreadSafeMain);
usleep(1000);;
for(uint32_t i = 0; i < 5; ++i)
{
MICROPROFILE_SCOPE(ThreadSafeInner0);
usleep(1000);
for(uint32_t j = 0; j < 4; ++j)
{
MICROPROFILE_META_CPU("custom_very_long_meta", 1);
MICROPROFILE_SCOPE(ThreadSafeInner1);
usleep(500);
MICROPROFILE_SCOPE(ThreadSafeInner2);
usleep(150);
MICROPROFILE_SCOPE(ThreadSafeInner3);
usleep(150);
MICROPROFILE_SCOPE(ThreadSafeInner4);
usleep(150);
}
}
break;
}
}
}
int main(int argc, char* argv[])
{
MICROPROFILE_REGISTER_GROUP("Thread0", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("Thread1", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("Thread2", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("Thread2xx", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("MAIN", "main", 0x88fff00f);
g_QueueGraphics = MICROPROFILE_GPU_INIT_QUEUE("GPU-Graphics-Queue");
printf("press 'z' to toggle microprofile drawing\n");
printf("press 'right shift' to pause microprofile update\n");
printf("press 'x' to toggle profiling\n");
printf("press 'c' to toggle enable of all profiler groups\n");
MicroProfileOnThreadCreate("AA_Main");
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
return 1;
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetSwapInterval(1);
SDL_Window * pWindow = SDL_CreateWindow("microprofiledemo", 10, 10, WIDTH, HEIGHT, SDL_WINDOW_OPENGL);
if(!pWindow)
return 1;
SDL_GLContext glcontext = SDL_GL_CreateContext(pWindow);
glewExperimental=1;
GLenum err=glewInit();
if(err!=GLEW_OK)
{
__BREAK();
}
glGetError(); //glew generates an error
#if MICROPROFILE_ENABLED
MicroProfileGpuInitGL();
MicroProfileDrawInit();
MP_ASSERT(glGetError() == 0);
MicroProfileToggleDisplayMode();
MicroProfileInitUI();
MicroProfileCustomGroup("Custom1", 2, 47, 2.f, MICROPROFILE_CUSTOM_BARS);
MicroProfileCustomGroupAddTimer("Custom1", "MicroProfile", "Draw");
MicroProfileCustomGroupAddTimer("Custom1", "MicroProfile", "Detailed View");
MicroProfileCustomGroup("Custom2", 2, 100, 20.f, MICROPROFILE_CUSTOM_BARS|MICROPROFILE_CUSTOM_BAR_SOURCE_MAX);
MicroProfileCustomGroupAddTimer("Custom2", "MicroProfile", "Draw");
MicroProfileCustomGroupAddTimer("Custom2", "MicroProfile", "Detailed View");
MicroProfileCustomGroup("Custom3", 2, 0, 5.f, MICROPROFILE_CUSTOM_STACK|MICROPROFILE_CUSTOM_STACK_SOURCE_MAX);
MicroProfileCustomGroupAddTimer("Custom3", "MicroProfile", "Draw");
MicroProfileCustomGroupAddTimer("Custom3", "MicroProfile", "Detailed View");
MicroProfileCustomGroup("ThreadSafe", 6, 10, 600.f, MICROPROFILE_CUSTOM_BARS | MICROPROFILE_CUSTOM_STACK);
MicroProfileCustomGroupAddTimer("ThreadSafe", "ThreadSafe", "main");
MicroProfileCustomGroupAddTimer("ThreadSafe", "ThreadSafe", "inner0");
MicroProfileCustomGroupAddTimer("ThreadSafe", "ThreadSafe", "inner1");
MicroProfileCustomGroupAddTimer("ThreadSafe", "ThreadSafe", "inner2");
MicroProfileCustomGroupAddTimer("ThreadSafe", "ThreadSafe", "inner3");
MicroProfileCustomGroupAddTimer("ThreadSafe", "ThreadSafe", "inner4");
#endif
MICROPROFILE_COUNTER_CONFIG("memory/main", MICROPROFILE_COUNTER_FORMAT_BYTES, 10ll<<30ll, 0);
MICROPROFILE_COUNTER_CONFIG("memory/gpu/indexbuffers", MICROPROFILE_COUNTER_FORMAT_BYTES, 0, 0);
MICROPROFILE_COUNTER_CONFIG("memory/gpu/vertexbuffers", MICROPROFILE_COUNTER_FORMAT_BYTES, 0, 0);
MICROPROFILE_COUNTER_CONFIG("memory/mainx", MICROPROFILE_COUNTER_FORMAT_BYTES, 10000, 0);
MICROPROFILE_COUNTER_ADD("memory/main", 1000);
MICROPROFILE_COUNTER_ADD("memory/gpu/vertexbuffers", 1000);
MICROPROFILE_COUNTER_ADD("memory/gpu/indexbuffers", 200);
MICROPROFILE_COUNTER_ADD("memory//", 10<<10);
MICROPROFILE_COUNTER_ADD("memory//main", (32ll<<30ll) + (1ll <<29ll));
MICROPROFILE_COUNTER_ADD("//memory//mainx/\\//", 1000);
MICROPROFILE_COUNTER_ADD("//memoryx//mainx/", 1000);
MICROPROFILE_COUNTER_ADD("//memoryy//main/", -1000000);
MICROPROFILE_COUNTER_ADD("//\\\\///lala////lelel", 1000);
MICROPROFILE_COUNTER_CONFIG("engine/frames", MICROPROFILE_COUNTER_FORMAT_DEFAULT, 1000, 0);
MICROPROFILE_COUNTER_SET("fisk/geder/", 42);
MICROPROFILE_COUNTER_SET("fisk/aborre/", -2002);
MICROPROFILE_COUNTER_SET_LIMIT("fisk/aborre/", 120);
static int Frames = 0;
static uint64_t FramesX = 0;
MICROPROFILE_COUNTER_SET_INT64_PTR("frames/int64", &FramesX);
MICROPROFILE_COUNTER_SET_INT32_PTR("frames/int32", &Frames);
MICROPROFILE_COUNTER_CONFIG("/test/sinus", MICROPROFILE_COUNTER_FORMAT_BYTES, 0, MICROPROFILE_COUNTER_FLAG_DETAILED);
MICROPROFILE_COUNTER_CONFIG("/test/cosinus", MICROPROFILE_COUNTER_FORMAT_DEFAULT, 0, MICROPROFILE_COUNTER_FLAG_DETAILED);
MICROPROFILE_COUNTER_CONFIG("/runtime/sdl_frame_events", MICROPROFILE_COUNTER_FORMAT_DEFAULT, 0, MICROPROFILE_COUNTER_FLAG_DETAILED);
StartFakeWork();
while(!g_nQuit)
{
Frames++;
FramesX += 1024*1024;
MICROPROFILE_SCOPE(MAIN);
MICROPROFILE_COUNTER_ADD("engine/frames", 1);
SDL_Event Evt;
while(SDL_PollEvent(&Evt))
{
MICROPROFILE_COUNTER_LOCAL_ADD(SDLFrameEvents, 1);
HandleEvent(&Evt);
}
MICROPROFILE_COUNTER_LOCAL_UPDATE_SET(SDLFrameEvents);
glClearColor(0.3f,0.4f,0.6f,0.f);
glViewport(0, 0, WIDTH, HEIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
#if 1||FAKE_WORK
{
MICROPROFILE_SCOPEI("BMain", "Dummy", 0xff3399ff);
for(uint32_t i = 0; i < 14; ++i)
{
MICROPROFILE_SCOPEI("BMain", "1ms", 0xff3399ff);
MICROPROFILE_META_CPU("Sleep",1);
usleep(1000);
}
}
#endif
MicroProfileMouseButton(g_MouseDown0, g_MouseDown1);
MicroProfileMousePosition(g_MouseX, g_MouseY, g_MouseDelta);
g_MouseDelta = 0;
MicroProfileFlip(0);
static float f = 0;
f += 0.1f;
int sinus = (int)(10000000 * (sinf(f)));
int cosinus = int(cosf(f*1.3f) * 100000 + 50000);
MICROPROFILE_COUNTER_SET("/test/sinus", sinus);
MICROPROFILE_COUNTER_SET("/test/cosinus", cosinus);
{
MICROPROFILE_SCOPEGPUI("MicroProfileDraw", 0x88dd44);
float projection[16];
float left = 0.f;
float right = WIDTH;
float bottom = HEIGHT;
float top = 0.f;
float near = -1.f;
float far = 1.f;
memset(&projection[0], 0, sizeof(projection));
projection[0] = 2.0f / (right - left);
projection[5] = 2.0f / (top - bottom);
projection[10] = -2.0f / (far - near);
projection[12] = - (right + left) / (right - left);
projection[13] = - (top + bottom) / (top - bottom);
projection[14] = - (far + near) / (far - near);
projection[15] = 1.f;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
#if MICROPROFILE_ENABLED
MicroProfileBeginDraw(WIDTH, HEIGHT, &projection[0]);
MicroProfileDraw(WIDTH, HEIGHT);
MicroProfileEndDraw();
#endif
glDisable(GL_BLEND);
}
MICROPROFILE_SCOPEI("MAIN", "Flip", 0xffee00);
SDL_GL_SwapWindow(pWindow);
}
StopFakeWork();
MicroProfileShutdown();
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(pWindow);
SDL_Quit();
return 0;
}
int main(int argc, char* argv[])
{
MicroProfileOnThreadCreate("AA_Main");
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
return 1;
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetSwapInterval(1);
SDL_Window * pWindow = SDL_CreateWindow("microprofiledemo", 10, 10, WIDTH, HEIGHT, SDL_WINDOW_OPENGL);
if(!pWindow)
return 1;
SDL_GLContext glcontext = SDL_GL_CreateContext(pWindow);
glewExperimental=1;
GLenum err=glewInit();
printf("ERROR IS %d\n",err);
if(err!=GLEW_OK)
{
__BREAK();
}
glGetError(); //glew generates an error
InitGLBuffers();
#if MICROPROFILE_ENABLED
MicroProfileGpuInitGL();
#endif
SDL_GL_SetSwapInterval(1);
while(!g_nQuit)
{
MICROPROFILE_SCOPE(MAIN);
MICROPROFILE_COUNTER_ADD("engine/frames", 1);
SDL_Event Evt;
while(SDL_PollEvent(&Evt))
{
MICROPROFILE_COUNTER_LOCAL_ADD_ATOMIC(SDLFrameEvents, 1);
HandleEvent(&Evt);
}
MICROPROFILE_COUNTER_LOCAL_UPDATE_SET_ATOMIC(SDLFrameEvents);
glClearColor(0.3f,0.4f,0.6f,0.f);
glViewport(0, 0, WIDTH, HEIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
DrawGLStuff();
MicroProfileFlip(0);
MICROPROFILE_SCOPEI("MAIN", "Flip", 0xffee00);
SDL_GL_SwapWindow(pWindow);
static bool bOnce = false;
if(!bOnce)
{
bOnce = true;
printf("open localhost:%d in chrome to capture profile data\n", MicroProfileWebServerPort());
}
}
MicroProfileShutdown();
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(pWindow);
SDL_Quit();
return 0;
}
void WorldService::AcceptVisitor( ServiceBlackboard& /*blackboard*/ ) {
// Default implementation should not do anything.
MICROPROFILE_SCOPEI( GetName(), "Default service attach function", 0xA011F0 );
}
void WorldService::AcceptVisitor( MessageBus& /*messageBus*/ ) {
// Default implementation should not do anything.
MICROPROFILE_SCOPEI( GetName(), "Default message dispatch function", 0xA011F0 );
}
void WorldService::AcceptVisitor( Scheduling::JobFiber& /*executor*/, const PostScriptTickVisitor ) {
// Default implementation should not do anything.
MICROPROFILE_SCOPEI( GetName(), "Default script post-tick function", 0xA011F0 );
}
void WorldService::AcceptVisitor( JobFiber& /*fiber*/, VariableTickVisitor& /*visitor*/ ) {
// Default implementation should not do anything.
MICROPROFILE_SCOPEI( GetName(), "Default variable-rate tick function", 0xA011F0 );
}
void WorldService::AcceptVisitor( JobFiber& /*fiber*/, const GameStopVisitor ) {
// Default implementation should not do anything.
MICROPROFILE_SCOPEI( GetName(), "Default game stop function", 0xA011F0 );
}
int main(int argc, char* argv[])
{
MICROPROFILE_REGISTER_GROUP("Thread0", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("Thread1", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("Thread2", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("Thread2xx", "Threads", 0x88008800);
MICROPROFILE_REGISTER_GROUP("GPU", "main", 0x88fff00f);
MICROPROFILE_REGISTER_GROUP("MAIN", "main", 0x88fff00f);
printf("press 'z' to toggle microprofile drawing\n");
printf("press 'right shift' to pause microprofile update\n");
printf("press 'x' to toggle profiling\n");
printf("press 'c' to toggle enable of all profiler groups\n");
MicroProfileOnThreadCreate("AA_Main");
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
return 1;
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetSwapInterval(1);
SDL_Window * pWindow = SDL_CreateWindow("microprofiledemo", 10, 10, WIDTH, HEIGHT, SDL_WINDOW_OPENGL);
if(!pWindow)
return 1;
SDL_GLContext glcontext = SDL_GL_CreateContext(pWindow);
glewExperimental=1;
GLenum err=glewInit();
if(err!=GLEW_OK)
{
__BREAK();
}
glGetError(); //glew generates an error
#if MICROPROFILE_ENABLED
MicroProfileGpuInitGL();
MicroProfileDrawInit();
MP_ASSERT(glGetError() == 0);
MicroProfileToggleDisplayMode();
#endif
StartFakeWork();
while(!g_nQuit)
{
MICROPROFILE_SCOPE(MAIN);
SDL_Event Evt;
while(SDL_PollEvent(&Evt))
{
HandleEvent(&Evt);
}
glClearColor(0.3f,0.4f,0.6f,0.f);
glViewport(0, 0, WIDTH, HEIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
#if 1||FAKE_WORK
{
MICROPROFILE_SCOPEI("BMain", "Dummy", 0xff3399ff);
for(uint32_t i = 0; i < 14; ++i)
{
MICROPROFILE_SCOPEI("BMain", "1ms", 0xff3399ff);
MICROPROFILE_META_CPU("Sleep",1);
usleep(1000);
}
}
#endif
MicroProfileMouseButton(g_MouseDown0, g_MouseDown1);
MicroProfileMousePosition(g_MouseX, g_MouseY, g_MouseDelta);
g_MouseDelta = 0;
MicroProfileFlip();
{
MICROPROFILE_SCOPEGPUI("MicroProfileDraw", 0x88dd44);
float projection[16];
float left = 0.f;
float right = WIDTH;
float bottom = HEIGHT;
float top = 0.f;
float near = -1.f;
float far = 1.f;
memset(&projection[0], 0, sizeof(projection));
projection[0] = 2.0f / (right - left);
projection[5] = 2.0f / (top - bottom);
projection[10] = -2.0f / (far - near);
projection[12] = - (right + left) / (right - left);
projection[13] = - (top + bottom) / (top - bottom);
projection[14] = - (far + near) / (far - near);
projection[15] = 1.f;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
#if MICROPROFILE_ENABLED
MicroProfileBeginDraw(WIDTH, HEIGHT, &projection[0]);
MicroProfileDraw(WIDTH, HEIGHT);
MicroProfileEndDraw();
#endif
glDisable(GL_BLEND);
}
MICROPROFILE_SCOPEI("MAIN", "Flip", 0xffee00);
SDL_GL_SwapWindow(pWindow);
}
StopFakeWork();
MicroProfileShutdown();
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(pWindow);
SDL_Quit();
return 0;
}
