GLuint CreateProgram(int nType, const char* pShader)
{
MP_ASSERT(0 == glGetError());
GLuint handle = glCreateShaderObjectARB(nType);
glShaderSource(handle, 1, (const char**)&pShader, 0);
glCompileShader(handle);
DumpGlLog(handle);
MP_ASSERT(handle);
MP_ASSERT(0 == glGetError());
return handle;
}
mreal_t ASTCall::evaluate(void* data) const
{
mreal_t result = 0.0f;
mreal_t t[10];
size_t i, len = _arguments.getLength();
for (i = 0; i < len; i++)
{
t[i] = _arguments[i]->evaluate(data);
}
void* fn = getFunction()->getPtr();
MP_ASSERT(getFunction()->getArguments() == len);
switch (len)
{
case 0: result = ((MFunc_Ret_F_ARG0)fn)(); break;
case 1: result = ((MFunc_Ret_F_ARG1)fn)(t[0]); break;
case 2: result = ((MFunc_Ret_F_ARG2)fn)(t[0], t[1]); break;
case 3: result = ((MFunc_Ret_F_ARG3)fn)(t[0], t[1], t[2]); break;
case 4: result = ((MFunc_Ret_F_ARG4)fn)(t[0], t[1], t[2], t[3]); break;
case 5: result = ((MFunc_Ret_F_ARG5)fn)(t[0], t[1], t[2], t[3], t[4]); break;
case 6: result = ((MFunc_Ret_F_ARG6)fn)(t[0], t[1], t[2], t[3], t[4], t[5]); break;
case 7: result = ((MFunc_Ret_F_ARG7)fn)(t[0], t[1], t[2], t[3], t[4], t[5], t[6]); break;
case 8: result = ((MFunc_Ret_F_ARG8)fn)(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7]); break;
}
return result;
}
mresult_t ExpressionParser::parseTree(ASTElement** dst)
{
Vector<ASTElement*> elements;
mresult_t result = MRESULT_OK;
for (;;)
{
ASTElement* ast = NULL;
if ((result = parseExpression(&ast, NULL, 0, false)) != MRESULT_OK)
goto failed;
if (ast) elements.append(ast);
MP_ASSERT(_last.tokenType != MTOKEN_ERROR);
switch (_last.tokenType)
{
case MTOKEN_END_OF_INPUT:
goto finished;
case MTOKEN_COMMA:
case MTOKEN_RPAREN:
result = MRESULT_UNEXPECTED_TOKEN;
goto failed;
case MTOKEN_SEMICOLON:
// Skip semicolon and parse next expression
_tokenizer.next(&_last);
break;
}
}
finished:
if (elements.getLength() == 0)
{
return MRESULT_NO_EXPRESSION;
}
else if (elements.getLength() == 1)
{
*dst = elements[0];
return MRESULT_OK;
}
else
{
ASTBlock* block = new ASTBlock(_ctx.genId());
block->getChildrenVector().swap(elements);
*dst = block;
return MRESULT_OK;
}
failed:
for (size_t i = 0; i < elements.getLength(); i++) delete elements[i];
return result;
}
void DumpGlLog(GLuint handle)
{
return;
int nLogLen = 0;
MP_ASSERT(0 == glGetError());
glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &nLogLen);
if(nLogLen > 1)
{
char* pChars = (char*)malloc(nLogLen);
int nLen = 0;
glGetInfoLogARB(handle, nLogLen, &nLen, pChars);
printf("COMPILE MESSAGE\n%s\n\n", pChars);
free(pChars);
__BREAK();
}
CheckGlError();
}
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);
}
mreal_t ASTOperator::evaluate(void* data) const
{
mreal_t result;
switch (getOperatorType())
{
case MOPERATOR_ASSIGN:
{
MP_ASSERT(_left->getElementType() == MELEMENT_VARIABLE);
result = _right->evaluate(data);
reinterpret_cast<mreal_t*>((char*)data +
reinterpret_cast<ASTVariable*>(_left)->getOffset())[0] = result;
break;
}
case MOPERATOR_PLUS:
result = _left->evaluate(data) + _right->evaluate(data);
break;
case MOPERATOR_MINUS:
result = _left->evaluate(data) - _right->evaluate(data);
break;
case MOPERATOR_MUL:
result = _left->evaluate(data) * _right->evaluate(data);
break;
case MOPERATOR_DIV:
result = _left->evaluate(data) / _right->evaluate(data);
break;
case MOPERATOR_MOD:
{
mreal_t vl = _left->evaluate(data);
mreal_t vr = _right->evaluate(data);
result = fmodf(vl, vr);
break;
}
}
return result;
}
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;
}
mresult_t ExpressionParser::parseExpression(ASTElement** dst,
ASTElement* _left,
int minPriority,
bool isInsideExpression)
{
ASTElement* left = _left;
ASTElement* right = NULL;
mresult_t result = MRESULT_OK;
uint op = MOPERATOR_NONE;
Token& token = _last;
Token helper;
for (;;)
{
_tokenizer.next(&token);
switch (token.tokenType)
{
// ----------------------------------------------------------------------
case MTOKEN_ERROR:
_tokenizer.back(&token);
result = MRESULT_INVALID_TOKEN;
goto failure;
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_COMMA:
case MTOKEN_SEMICOLON:
if (left == NULL)
{
return (isInsideExpression)
? MRESULT_UNEXPECTED_TOKEN
: MRESULT_OK;
}
// ... fall through ...
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_END_OF_INPUT:
if (op != MOPERATOR_NONE)
{
// Operand expected
result = MRESULT_EXPRESSION_EXPECTED;
goto failure;
}
_tokenizer.back(&token);
*dst = left;
return MRESULT_OK;
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_INTEGER:
case MTOKEN_FLOAT:
if (left != NULL && op == MOPERATOR_NONE)
{
// Expected operator or end of expression
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
right = new ASTConstant(_ctx.genId(), token.f);
break;
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_LPAREN:
if (left != NULL && op == MOPERATOR_NONE)
{
// Expected operator or end of expression
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
result = parseExpression(&right, NULL, 0, true);
if (result != MRESULT_OK)
goto failure;
_tokenizer.next(&token);
if (token.tokenType != MTOKEN_RPAREN)
{
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
break;
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_RPAREN:
if (op != MOPERATOR_NONE)
{
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
if (left == NULL && isInsideExpression)
{
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
_tokenizer.back(&token);
*dst = left;
return MRESULT_OK;
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_OPERATOR:
if (token.operatorType == MOPERATOR_ASSIGN)
{
/* Why not?
// Assignment inside expression is not allowed.
if (isInsideExpression)
{
result = MRESULT_ASSIGNMENT_INSIDE_EXPRESSION;
goto failure;
}
*/
// Can assign only to a variable
if (left == NULL || left->getElementType() != MELEMENT_VARIABLE)
{
result = MRESULT_ASSIGNMENT_TO_NON_VARIABLE;
goto failure;
}
}
if (op != MOPERATOR_NONE || left == NULL)
{
if (token.operatorType == MOPERATOR_PLUS)
// Ignore unary plus
continue;
if (token.operatorType == MOPERATOR_MINUS)
{
// Unary minus
result = parseExpression(&right, right, mpOperatorInfo[MOPERATOR_UMINUS].priority, true);
if (result != MRESULT_OK)
goto failure;
if (right == NULL)
{
result = MRESULT_EXPRESSION_EXPECTED;
goto failure;
}
ASTTransform* transform = new ASTTransform(_ctx.genId());
transform->setTransformType(MTRANSFORM_NEGATE);
transform->setChild(right);
right = transform;
break;
}
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
op = token.operatorType;
if (mpOperatorInfo[op].priority < minPriority || (mpOperatorInfo[op].priority == minPriority && mpOperatorInfo[op].assoc == LeftAssoc))
{
_tokenizer.back(&token);
*dst = left;
return MRESULT_OK;
}
continue;
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
case MTOKEN_SYMBOL:
{
if (left != NULL && op == MOPERATOR_NONE)
{
// Expected operator or end of expression
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
const char* symbolName = _tokenizer.beg + token.pos;
size_t symbolLength = token.len;
Token ttoken;
bool isFunction = (_tokenizer.peek(&ttoken) == MTOKEN_LPAREN);
// Parse function
if (isFunction)
{
Function* function = _ctx._ctx->functions.get(symbolName, symbolLength);
if (function == NULL)
{
result = MRESULT_INVALID_FUNCTION;
goto failure;
}
// Parse LPAREN token again
_tokenizer.next(&ttoken);
Vector<ASTElement*> arguments;
// Parse function arguments
int numArgs = function->getArgumentsCount();
int n = 0;
for (;;++n)
{
_tokenizer.next(&ttoken);
if (ttoken.tokenType == MTOKEN_ERROR)
{
mpDeleteAll(arguments);
result = MRESULT_INVALID_TOKEN;
goto failure;
}
// ')' - End of function call
if (ttoken.tokenType == MTOKEN_RPAREN)
{
if (n == numArgs) break;
mpDeleteAll(arguments);
result = MRESULT_NOT_ENOUGH_ARGUMENTS;
goto failure;
}
// ',' - Arguments delimiter
if (n != 0)
{
if (ttoken.tokenType == MTOKEN_COMMA)
{
if (n >= numArgs)
{
mpDeleteAll(arguments);
result = MRESULT_TOO_MANY_ARGUMENTS;
goto failure;
}
}
else
{
mpDeleteAll(arguments);
result = MRESULT_UNEXPECTED_TOKEN;
goto failure;
}
}
else
{
_tokenizer.back(&ttoken);
}
// Parse argument expression
ASTElement* arg;
if ((result = parseExpression(&arg, NULL, 0, true)) != MRESULT_OK)
{
mpDeleteAll(arguments);
goto failure;
}
arguments.append(arg);
}
// Done
ASTCall* call = new ASTCall(_ctx.genId(), function);
call->swapArguments(arguments);
right = call;
}
else
// Parse variable
{
Variable* var = _ctx._ctx->variables.get(symbolName, symbolLength);
if (var == NULL)
{
result = MRESULT_INVALID_SYMBOL;
goto failure;
}
if (var->type == MVARIABLE_CONSTANT)
right = new ASTConstant(_ctx.genId(), var->c.value);
else
right = new ASTVariable(_ctx.genId(), var);
}
break;
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
default:
MP_ASSERT_NOT_REACHED();
// ----------------------------------------------------------------------
}
MP_ASSERT(right != NULL);
if (left)
{
_tokenizer.peek(&helper);
if (helper.tokenType == MTOKEN_OPERATOR)
{
int lp = mpOperatorInfo[op].priority;
int np = mpOperatorInfo[helper.operatorType].priority;
if (lp < np || (lp == np && mpOperatorInfo[op].assoc == RightAssoc))
{
result = parseExpression(&right, right, lp, true);
if (result != MRESULT_OK)
goto failure;
}
}
MP_ASSERT(op != MOPERATOR_NONE);
ASTOperator* parent = new ASTOperator(_ctx.genId(), op);
parent->setLeft(left);
parent->setRight(right);
left = parent;
right = NULL;
op = MOPERATOR_NONE;
}
else
{
left = right;
right = NULL;
}
}
failure:
if (left) delete left;
if (right) delete right;
*dst = NULL;
return result;
}
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;
}
