testgles2.c (20569B)
1 /* 2 Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org> 3 4 This software is provided 'as-is', without any express or implied 5 warranty. In no event will the authors be held liable for any damages 6 arising from the use of this software. 7 8 Permission is granted to anyone to use this software for any purpose, 9 including commercial applications, and to alter it and redistribute it 10 freely. 11 */ 12 #include <stdlib.h> 13 #include <stdio.h> 14 #include <string.h> 15 #include <math.h> 16 17 #ifdef __EMSCRIPTEN__ 18 #include <emscripten/emscripten.h> 19 #endif 20 21 #include "SDL_test_common.h" 22 23 #if defined(__IPHONEOS__) || defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__NACL__) \ 24 || defined(__WINDOWS__) || defined(__LINUX__) 25 #define HAVE_OPENGLES2 26 #endif 27 28 #ifdef HAVE_OPENGLES2 29 30 #include "SDL_opengles2.h" 31 32 typedef struct GLES2_Context 33 { 34 #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params; 35 #include "../src/render/opengles2/SDL_gles2funcs.h" 36 #undef SDL_PROC 37 } GLES2_Context; 38 39 40 static SDLTest_CommonState *state; 41 static SDL_GLContext *context = NULL; 42 static int depth = 16; 43 static GLES2_Context ctx; 44 45 static int LoadContext(GLES2_Context * data) 46 { 47 #if SDL_VIDEO_DRIVER_UIKIT 48 #define __SDL_NOGETPROCADDR__ 49 #elif SDL_VIDEO_DRIVER_ANDROID 50 #define __SDL_NOGETPROCADDR__ 51 #elif SDL_VIDEO_DRIVER_PANDORA 52 #define __SDL_NOGETPROCADDR__ 53 #endif 54 55 #if defined __SDL_NOGETPROCADDR__ 56 #define SDL_PROC(ret,func,params) data->func=func; 57 #else 58 #define SDL_PROC(ret,func,params) \ 59 do { \ 60 data->func = SDL_GL_GetProcAddress(#func); \ 61 if ( ! data->func ) { \ 62 return SDL_SetError("Couldn't load GLES2 function %s: %s", #func, SDL_GetError()); \ 63 } \ 64 } while ( 0 ); 65 #endif /* __SDL_NOGETPROCADDR__ */ 66 67 #include "../src/render/opengles2/SDL_gles2funcs.h" 68 #undef SDL_PROC 69 return 0; 70 } 71 72 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ 73 static void 74 quit(int rc) 75 { 76 int i; 77 78 if (context != NULL) { 79 for (i = 0; i < state->num_windows; i++) { 80 if (context[i]) { 81 SDL_GL_DeleteContext(context[i]); 82 } 83 } 84 85 SDL_free(context); 86 } 87 88 SDLTest_CommonQuit(state); 89 exit(rc); 90 } 91 92 #define GL_CHECK(x) \ 93 x; \ 94 { \ 95 GLenum glError = ctx.glGetError(); \ 96 if(glError != GL_NO_ERROR) { \ 97 SDL_Log("glGetError() = %i (0x%.8x) at line %i\n", glError, glError, __LINE__); \ 98 quit(1); \ 99 } \ 100 } 101 102 /* 103 * Simulates desktop's glRotatef. The matrix is returned in column-major 104 * order. 105 */ 106 static void 107 rotate_matrix(float angle, float x, float y, float z, float *r) 108 { 109 float radians, c, s, c1, u[3], length; 110 int i, j; 111 112 radians = (float)(angle * M_PI) / 180.0f; 113 114 c = SDL_cosf(radians); 115 s = SDL_sinf(radians); 116 117 c1 = 1.0f - SDL_cosf(radians); 118 119 length = (float)SDL_sqrt(x * x + y * y + z * z); 120 121 u[0] = x / length; 122 u[1] = y / length; 123 u[2] = z / length; 124 125 for (i = 0; i < 16; i++) { 126 r[i] = 0.0; 127 } 128 129 r[15] = 1.0; 130 131 for (i = 0; i < 3; i++) { 132 r[i * 4 + (i + 1) % 3] = u[(i + 2) % 3] * s; 133 r[i * 4 + (i + 2) % 3] = -u[(i + 1) % 3] * s; 134 } 135 136 for (i = 0; i < 3; i++) { 137 for (j = 0; j < 3; j++) { 138 r[i * 4 + j] += c1 * u[i] * u[j] + (i == j ? c : 0.0f); 139 } 140 } 141 } 142 143 /* 144 * Simulates gluPerspectiveMatrix 145 */ 146 static void 147 perspective_matrix(float fovy, float aspect, float znear, float zfar, float *r) 148 { 149 int i; 150 float f; 151 152 f = 1.0f/SDL_tanf(fovy * 0.5f); 153 154 for (i = 0; i < 16; i++) { 155 r[i] = 0.0; 156 } 157 158 r[0] = f / aspect; 159 r[5] = f; 160 r[10] = (znear + zfar) / (znear - zfar); 161 r[11] = -1.0f; 162 r[14] = (2.0f * znear * zfar) / (znear - zfar); 163 r[15] = 0.0f; 164 } 165 166 /* 167 * Multiplies lhs by rhs and writes out to r. All matrices are 4x4 and column 168 * major. In-place multiplication is supported. 169 */ 170 static void 171 multiply_matrix(float *lhs, float *rhs, float *r) 172 { 173 int i, j, k; 174 float tmp[16]; 175 176 for (i = 0; i < 4; i++) { 177 for (j = 0; j < 4; j++) { 178 tmp[j * 4 + i] = 0.0; 179 180 for (k = 0; k < 4; k++) { 181 tmp[j * 4 + i] += lhs[k * 4 + i] * rhs[j * 4 + k]; 182 } 183 } 184 } 185 186 for (i = 0; i < 16; i++) { 187 r[i] = tmp[i]; 188 } 189 } 190 191 /* 192 * Create shader, load in source, compile, dump debug as necessary. 193 * 194 * shader: Pointer to return created shader ID. 195 * source: Passed-in shader source code. 196 * shader_type: Passed to GL, e.g. GL_VERTEX_SHADER. 197 */ 198 void 199 process_shader(GLuint *shader, const char * source, GLint shader_type) 200 { 201 GLint status = GL_FALSE; 202 const char *shaders[1] = { NULL }; 203 char buffer[1024]; 204 GLsizei length; 205 206 /* Create shader and load into GL. */ 207 *shader = GL_CHECK(ctx.glCreateShader(shader_type)); 208 209 shaders[0] = source; 210 211 GL_CHECK(ctx.glShaderSource(*shader, 1, shaders, NULL)); 212 213 /* Clean up shader source. */ 214 shaders[0] = NULL; 215 216 /* Try compiling the shader. */ 217 GL_CHECK(ctx.glCompileShader(*shader)); 218 GL_CHECK(ctx.glGetShaderiv(*shader, GL_COMPILE_STATUS, &status)); 219 220 /* Dump debug info (source and log) if compilation failed. */ 221 if(status != GL_TRUE) { 222 ctx.glGetProgramInfoLog(*shader, sizeof(buffer), &length, &buffer[0]); 223 buffer[length] = '\0'; 224 SDL_Log("Shader compilation failed: %s", buffer);fflush(stderr); 225 quit(-1); 226 } 227 } 228 229 /* 3D data. Vertex range -0.5..0.5 in all axes. 230 * Z -0.5 is near, 0.5 is far. */ 231 const float _vertices[] = 232 { 233 /* Front face. */ 234 /* Bottom left */ 235 -0.5, 0.5, -0.5, 236 0.5, -0.5, -0.5, 237 -0.5, -0.5, -0.5, 238 /* Top right */ 239 -0.5, 0.5, -0.5, 240 0.5, 0.5, -0.5, 241 0.5, -0.5, -0.5, 242 /* Left face */ 243 /* Bottom left */ 244 -0.5, 0.5, 0.5, 245 -0.5, -0.5, -0.5, 246 -0.5, -0.5, 0.5, 247 /* Top right */ 248 -0.5, 0.5, 0.5, 249 -0.5, 0.5, -0.5, 250 -0.5, -0.5, -0.5, 251 /* Top face */ 252 /* Bottom left */ 253 -0.5, 0.5, 0.5, 254 0.5, 0.5, -0.5, 255 -0.5, 0.5, -0.5, 256 /* Top right */ 257 -0.5, 0.5, 0.5, 258 0.5, 0.5, 0.5, 259 0.5, 0.5, -0.5, 260 /* Right face */ 261 /* Bottom left */ 262 0.5, 0.5, -0.5, 263 0.5, -0.5, 0.5, 264 0.5, -0.5, -0.5, 265 /* Top right */ 266 0.5, 0.5, -0.5, 267 0.5, 0.5, 0.5, 268 0.5, -0.5, 0.5, 269 /* Back face */ 270 /* Bottom left */ 271 0.5, 0.5, 0.5, 272 -0.5, -0.5, 0.5, 273 0.5, -0.5, 0.5, 274 /* Top right */ 275 0.5, 0.5, 0.5, 276 -0.5, 0.5, 0.5, 277 -0.5, -0.5, 0.5, 278 /* Bottom face */ 279 /* Bottom left */ 280 -0.5, -0.5, -0.5, 281 0.5, -0.5, 0.5, 282 -0.5, -0.5, 0.5, 283 /* Top right */ 284 -0.5, -0.5, -0.5, 285 0.5, -0.5, -0.5, 286 0.5, -0.5, 0.5, 287 }; 288 289 const float _colors[] = 290 { 291 /* Front face */ 292 /* Bottom left */ 293 1.0, 0.0, 0.0, /* red */ 294 0.0, 0.0, 1.0, /* blue */ 295 0.0, 1.0, 0.0, /* green */ 296 /* Top right */ 297 1.0, 0.0, 0.0, /* red */ 298 1.0, 1.0, 0.0, /* yellow */ 299 0.0, 0.0, 1.0, /* blue */ 300 /* Left face */ 301 /* Bottom left */ 302 1.0, 1.0, 1.0, /* white */ 303 0.0, 1.0, 0.0, /* green */ 304 0.0, 1.0, 1.0, /* cyan */ 305 /* Top right */ 306 1.0, 1.0, 1.0, /* white */ 307 1.0, 0.0, 0.0, /* red */ 308 0.0, 1.0, 0.0, /* green */ 309 /* Top face */ 310 /* Bottom left */ 311 1.0, 1.0, 1.0, /* white */ 312 1.0, 1.0, 0.0, /* yellow */ 313 1.0, 0.0, 0.0, /* red */ 314 /* Top right */ 315 1.0, 1.0, 1.0, /* white */ 316 0.0, 0.0, 0.0, /* black */ 317 1.0, 1.0, 0.0, /* yellow */ 318 /* Right face */ 319 /* Bottom left */ 320 1.0, 1.0, 0.0, /* yellow */ 321 1.0, 0.0, 1.0, /* magenta */ 322 0.0, 0.0, 1.0, /* blue */ 323 /* Top right */ 324 1.0, 1.0, 0.0, /* yellow */ 325 0.0, 0.0, 0.0, /* black */ 326 1.0, 0.0, 1.0, /* magenta */ 327 /* Back face */ 328 /* Bottom left */ 329 0.0, 0.0, 0.0, /* black */ 330 0.0, 1.0, 1.0, /* cyan */ 331 1.0, 0.0, 1.0, /* magenta */ 332 /* Top right */ 333 0.0, 0.0, 0.0, /* black */ 334 1.0, 1.0, 1.0, /* white */ 335 0.0, 1.0, 1.0, /* cyan */ 336 /* Bottom face */ 337 /* Bottom left */ 338 0.0, 1.0, 0.0, /* green */ 339 1.0, 0.0, 1.0, /* magenta */ 340 0.0, 1.0, 1.0, /* cyan */ 341 /* Top right */ 342 0.0, 1.0, 0.0, /* green */ 343 0.0, 0.0, 1.0, /* blue */ 344 1.0, 0.0, 1.0, /* magenta */ 345 }; 346 347 const char* _shader_vert_src = 348 " attribute vec4 av4position; " 349 " attribute vec3 av3color; " 350 " uniform mat4 mvp; " 351 " varying vec3 vv3color; " 352 " void main() { " 353 " vv3color = av3color; " 354 " gl_Position = mvp * av4position; " 355 " } "; 356 357 const char* _shader_frag_src = 358 " precision lowp float; " 359 " varying vec3 vv3color; " 360 " void main() { " 361 " gl_FragColor = vec4(vv3color, 1.0); " 362 " } "; 363 364 typedef struct shader_data 365 { 366 GLuint shader_program, shader_frag, shader_vert; 367 368 GLint attr_position; 369 GLint attr_color, attr_mvp; 370 371 int angle_x, angle_y, angle_z; 372 373 } shader_data; 374 375 static void 376 Render(unsigned int width, unsigned int height, shader_data* data) 377 { 378 float matrix_rotate[16], matrix_modelview[16], matrix_perspective[16], matrix_mvp[16]; 379 380 /* 381 * Do some rotation with Euler angles. It is not a fixed axis as 382 * quaterions would be, but the effect is cool. 383 */ 384 rotate_matrix((float)data->angle_x, 1.0f, 0.0f, 0.0f, matrix_modelview); 385 rotate_matrix((float)data->angle_y, 0.0f, 1.0f, 0.0f, matrix_rotate); 386 387 multiply_matrix(matrix_rotate, matrix_modelview, matrix_modelview); 388 389 rotate_matrix((float)data->angle_z, 0.0f, 1.0f, 0.0f, matrix_rotate); 390 391 multiply_matrix(matrix_rotate, matrix_modelview, matrix_modelview); 392 393 /* Pull the camera back from the cube */ 394 matrix_modelview[14] -= 2.5; 395 396 perspective_matrix(45.0f, (float)width/height, 0.01f, 100.0f, matrix_perspective); 397 multiply_matrix(matrix_perspective, matrix_modelview, matrix_mvp); 398 399 GL_CHECK(ctx.glUniformMatrix4fv(data->attr_mvp, 1, GL_FALSE, matrix_mvp)); 400 401 data->angle_x += 3; 402 data->angle_y += 2; 403 data->angle_z += 1; 404 405 if(data->angle_x >= 360) data->angle_x -= 360; 406 if(data->angle_x < 0) data->angle_x += 360; 407 if(data->angle_y >= 360) data->angle_y -= 360; 408 if(data->angle_y < 0) data->angle_y += 360; 409 if(data->angle_z >= 360) data->angle_z -= 360; 410 if(data->angle_z < 0) data->angle_z += 360; 411 412 GL_CHECK(ctx.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)); 413 GL_CHECK(ctx.glDrawArrays(GL_TRIANGLES, 0, 36)); 414 } 415 416 int done; 417 Uint32 frames; 418 shader_data *datas; 419 420 void loop() 421 { 422 SDL_Event event; 423 int i; 424 int status; 425 426 /* Check for events */ 427 ++frames; 428 while (SDL_PollEvent(&event) && !done) { 429 switch (event.type) { 430 case SDL_WINDOWEVENT: 431 switch (event.window.event) { 432 case SDL_WINDOWEVENT_RESIZED: 433 for (i = 0; i < state->num_windows; ++i) { 434 if (event.window.windowID == SDL_GetWindowID(state->windows[i])) { 435 int w, h; 436 status = SDL_GL_MakeCurrent(state->windows[i], context[i]); 437 if (status) { 438 SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); 439 break; 440 } 441 /* Change view port to the new window dimensions */ 442 SDL_GL_GetDrawableSize(state->windows[i], &w, &h); 443 ctx.glViewport(0, 0, w, h); 444 state->window_w = event.window.data1; 445 state->window_h = event.window.data2; 446 /* Update window content */ 447 Render(event.window.data1, event.window.data2, &datas[i]); 448 SDL_GL_SwapWindow(state->windows[i]); 449 break; 450 } 451 } 452 break; 453 } 454 } 455 SDLTest_CommonEvent(state, &event, &done); 456 } 457 if (!done) { 458 for (i = 0; i < state->num_windows; ++i) { 459 status = SDL_GL_MakeCurrent(state->windows[i], context[i]); 460 if (status) { 461 SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); 462 463 /* Continue for next window */ 464 continue; 465 } 466 Render(state->window_w, state->window_h, &datas[i]); 467 SDL_GL_SwapWindow(state->windows[i]); 468 } 469 } 470 #ifdef __EMSCRIPTEN__ 471 else { 472 emscripten_cancel_main_loop(); 473 } 474 #endif 475 } 476 477 int 478 main(int argc, char *argv[]) 479 { 480 int fsaa, accel; 481 int value; 482 int i; 483 SDL_DisplayMode mode; 484 Uint32 then, now; 485 int status; 486 shader_data *data; 487 488 /* Initialize parameters */ 489 fsaa = 0; 490 accel = 0; 491 492 /* Initialize test framework */ 493 state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); 494 if (!state) { 495 return 1; 496 } 497 for (i = 1; i < argc;) { 498 int consumed; 499 500 consumed = SDLTest_CommonArg(state, i); 501 if (consumed == 0) { 502 if (SDL_strcasecmp(argv[i], "--fsaa") == 0) { 503 ++fsaa; 504 consumed = 1; 505 } else if (SDL_strcasecmp(argv[i], "--accel") == 0) { 506 ++accel; 507 consumed = 1; 508 } else if (SDL_strcasecmp(argv[i], "--zdepth") == 0) { 509 i++; 510 if (!argv[i]) { 511 consumed = -1; 512 } else { 513 depth = SDL_atoi(argv[i]); 514 consumed = 1; 515 } 516 } else { 517 consumed = -1; 518 } 519 } 520 if (consumed < 0) { 521 static const char *options[] = { "[--fsaa]", "[--accel]", "[--zdepth %d]", NULL }; 522 SDLTest_CommonLogUsage(state, argv[0], options); 523 quit(1); 524 } 525 i += consumed; 526 } 527 528 /* Set OpenGL parameters */ 529 state->window_flags |= SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS; 530 state->gl_red_size = 5; 531 state->gl_green_size = 5; 532 state->gl_blue_size = 5; 533 state->gl_depth_size = depth; 534 state->gl_major_version = 2; 535 state->gl_minor_version = 0; 536 state->gl_profile_mask = SDL_GL_CONTEXT_PROFILE_ES; 537 538 if (fsaa) { 539 state->gl_multisamplebuffers=1; 540 state->gl_multisamplesamples=fsaa; 541 } 542 if (accel) { 543 state->gl_accelerated=1; 544 } 545 if (!SDLTest_CommonInit(state)) { 546 quit(2); 547 return 0; 548 } 549 550 context = (SDL_GLContext *)SDL_calloc(state->num_windows, sizeof(context)); 551 if (context == NULL) { 552 SDL_Log("Out of memory!\n"); 553 quit(2); 554 } 555 556 /* Create OpenGL ES contexts */ 557 for (i = 0; i < state->num_windows; i++) { 558 context[i] = SDL_GL_CreateContext(state->windows[i]); 559 if (!context[i]) { 560 SDL_Log("SDL_GL_CreateContext(): %s\n", SDL_GetError()); 561 quit(2); 562 } 563 } 564 565 /* Important: call this *after* creating the context */ 566 if (LoadContext(&ctx) < 0) { 567 SDL_Log("Could not load GLES2 functions\n"); 568 quit(2); 569 return 0; 570 } 571 572 573 574 if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) { 575 SDL_GL_SetSwapInterval(1); 576 } else { 577 SDL_GL_SetSwapInterval(0); 578 } 579 580 SDL_GetCurrentDisplayMode(0, &mode); 581 SDL_Log("Screen bpp: %d\n", SDL_BITSPERPIXEL(mode.format)); 582 SDL_Log("\n"); 583 SDL_Log("Vendor : %s\n", ctx.glGetString(GL_VENDOR)); 584 SDL_Log("Renderer : %s\n", ctx.glGetString(GL_RENDERER)); 585 SDL_Log("Version : %s\n", ctx.glGetString(GL_VERSION)); 586 SDL_Log("Extensions : %s\n", ctx.glGetString(GL_EXTENSIONS)); 587 SDL_Log("\n"); 588 589 status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); 590 if (!status) { 591 SDL_Log("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value); 592 } else { 593 SDL_Log( "Failed to get SDL_GL_RED_SIZE: %s\n", 594 SDL_GetError()); 595 } 596 status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); 597 if (!status) { 598 SDL_Log("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value); 599 } else { 600 SDL_Log( "Failed to get SDL_GL_GREEN_SIZE: %s\n", 601 SDL_GetError()); 602 } 603 status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); 604 if (!status) { 605 SDL_Log("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value); 606 } else { 607 SDL_Log( "Failed to get SDL_GL_BLUE_SIZE: %s\n", 608 SDL_GetError()); 609 } 610 status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); 611 if (!status) { 612 SDL_Log("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", depth, value); 613 } else { 614 SDL_Log( "Failed to get SDL_GL_DEPTH_SIZE: %s\n", 615 SDL_GetError()); 616 } 617 if (fsaa) { 618 status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value); 619 if (!status) { 620 SDL_Log("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value); 621 } else { 622 SDL_Log( "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", 623 SDL_GetError()); 624 } 625 status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value); 626 if (!status) { 627 SDL_Log("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, 628 value); 629 } else { 630 SDL_Log( "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", 631 SDL_GetError()); 632 } 633 } 634 if (accel) { 635 status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value); 636 if (!status) { 637 SDL_Log("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value); 638 } else { 639 SDL_Log( "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", 640 SDL_GetError()); 641 } 642 } 643 644 datas = (shader_data *)SDL_calloc(state->num_windows, sizeof(shader_data)); 645 646 /* Set rendering settings for each context */ 647 for (i = 0; i < state->num_windows; ++i) { 648 649 int w, h; 650 status = SDL_GL_MakeCurrent(state->windows[i], context[i]); 651 if (status) { 652 SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); 653 654 /* Continue for next window */ 655 continue; 656 } 657 SDL_GL_GetDrawableSize(state->windows[i], &w, &h); 658 ctx.glViewport(0, 0, w, h); 659 660 data = &datas[i]; 661 data->angle_x = 0; data->angle_y = 0; data->angle_z = 0; 662 663 /* Shader Initialization */ 664 process_shader(&data->shader_vert, _shader_vert_src, GL_VERTEX_SHADER); 665 process_shader(&data->shader_frag, _shader_frag_src, GL_FRAGMENT_SHADER); 666 667 /* Create shader_program (ready to attach shaders) */ 668 data->shader_program = GL_CHECK(ctx.glCreateProgram()); 669 670 /* Attach shaders and link shader_program */ 671 GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_vert)); 672 GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_frag)); 673 GL_CHECK(ctx.glLinkProgram(data->shader_program)); 674 675 /* Get attribute locations of non-fixed attributes like color and texture coordinates. */ 676 data->attr_position = GL_CHECK(ctx.glGetAttribLocation(data->shader_program, "av4position")); 677 data->attr_color = GL_CHECK(ctx.glGetAttribLocation(data->shader_program, "av3color")); 678 679 /* Get uniform locations */ 680 data->attr_mvp = GL_CHECK(ctx.glGetUniformLocation(data->shader_program, "mvp")); 681 682 GL_CHECK(ctx.glUseProgram(data->shader_program)); 683 684 /* Enable attributes for position, color and texture coordinates etc. */ 685 GL_CHECK(ctx.glEnableVertexAttribArray(data->attr_position)); 686 GL_CHECK(ctx.glEnableVertexAttribArray(data->attr_color)); 687 688 /* Populate attributes for position, color and texture coordinates etc. */ 689 GL_CHECK(ctx.glVertexAttribPointer(data->attr_position, 3, GL_FLOAT, GL_FALSE, 0, _vertices)); 690 GL_CHECK(ctx.glVertexAttribPointer(data->attr_color, 3, GL_FLOAT, GL_FALSE, 0, _colors)); 691 692 GL_CHECK(ctx.glEnable(GL_CULL_FACE)); 693 GL_CHECK(ctx.glEnable(GL_DEPTH_TEST)); 694 } 695 696 /* Main render loop */ 697 frames = 0; 698 then = SDL_GetTicks(); 699 done = 0; 700 701 #ifdef __EMSCRIPTEN__ 702 emscripten_set_main_loop(loop, 0, 1); 703 #else 704 while (!done) { 705 loop(); 706 } 707 #endif 708 709 /* Print out some timing information */ 710 now = SDL_GetTicks(); 711 if (now > then) { 712 SDL_Log("%2.2f frames per second\n", 713 ((double) frames * 1000) / (now - then)); 714 } 715 #if !defined(__ANDROID__) && !defined(__NACL__) 716 quit(0); 717 #endif 718 return 0; 719 } 720 721 #else /* HAVE_OPENGLES2 */ 722 723 int 724 main(int argc, char *argv[]) 725 { 726 SDL_Log("No OpenGL ES support on this system\n"); 727 return 1; 728 } 729 730 #endif /* HAVE_OPENGLES2 */ 731 732 /* vi: set ts=4 sw=4 expandtab: */