test/testgles2.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 23 May 2019 14:19:00 -0700
changeset 12756 4116bf232fe7
parent 12503 806492103856
child 12758 3c6a6dad3487
permissions -rw-r--r--
Added a function to get the current Android SDK version at runtime
     1 /*
     2   Copyright (C) 1997-2019 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             SDL_Log ("Usage: %s %s [--fsaa] [--accel] [--zdepth %%d]\n", argv[0],
   522                     SDLTest_CommonUsage(state));
   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: */