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