开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
testgl.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：17k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

testgl.c：源码内容
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <math.h>
  6. #include "SDL.h"
  8. #ifdef HAVE_OPENGL
  10. #include "SDL_opengl.h"
  12. /* Undefine this if you want a flat cube instead of a rainbow cube */
  13. #define SHADED_CUBE
  15. /* Define this to be the name of the logo image to use with -logo */
  16. #define LOGO_FILE "icon.bmp"
  18. /* The SDL_OPENGLBLIT interface is deprecated.
  19.    The code is still available for benchmark purposes though.
  20. */
  21. static SDL_bool USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
  23. /**********************************************************************/
  25. void HotKey_ToggleFullScreen(void)
  26. {
  27. SDL_Surface *screen;
  29. screen = SDL_GetVideoSurface();
  30. if ( SDL_WM_ToggleFullScreen(screen) ) {
  31. printf("Toggled fullscreen mode - now %sn",
  32.     (screen->flags&SDL_FULLSCREEN) ? "fullscreen" : "windowed");
  33. } else {
  34. printf("Unable to toggle fullscreen moden");
  35. }
  36. }
  38. void HotKey_ToggleGrab(void)
  39. {
  40. SDL_GrabMode mode;
  42. printf("Ctrl-G: toggling input grab!n");
  43. mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
  44. if ( mode == SDL_GRAB_ON ) {
  45. printf("Grab was onn");
  46. } else {
  47. printf("Grab was offn");
  48. }
  49. mode = SDL_WM_GrabInput(!mode);
  50. if ( mode == SDL_GRAB_ON ) {
  51. printf("Grab is now onn");
  52. } else {
  53. printf("Grab is now offn");
  54. }
  55. }
  57. void HotKey_Iconify(void)
  58. {
  59. printf("Ctrl-Z: iconifying window!n");
  60. SDL_WM_IconifyWindow();
  61. }
  63. int HandleEvent(SDL_Event *event)
  64. {
  65. int done;
  67. done = 0;
  68. switch( event->type ) {
  69.     case SDL_ACTIVEEVENT:
  70. /* See what happened */
  71. printf( "app %s ", event->active.gain ? "gained" : "lost" );
  72. if ( event->active.state & SDL_APPACTIVE ) {
  73. printf( "active " );
  74. } else if ( event->active.state & SDL_APPMOUSEFOCUS ) {
  75. printf( "mouse " );
  76. } else if ( event->active.state & SDL_APPINPUTFOCUS ) {
  77. printf( "input " );
  78. }
  79. printf( "focusn" );
  80. break;
  83.     case SDL_KEYDOWN:
  84. if ( event->key.keysym.sym == SDLK_ESCAPE ) {
  85. done = 1;
  86. }
  87. if ( (event->key.keysym.sym == SDLK_g) &&
  88.      (event->key.keysym.mod & KMOD_CTRL) ) {
  89. HotKey_ToggleGrab();
  90. }
  91. if ( (event->key.keysym.sym == SDLK_z) &&
  92.      (event->key.keysym.mod & KMOD_CTRL) ) {
  93. HotKey_Iconify();
  94. }
  95. if ( (event->key.keysym.sym == SDLK_RETURN) &&
  96.      (event->key.keysym.mod & KMOD_ALT) ) {
  97. HotKey_ToggleFullScreen();
  98. }
  99. printf("key '%s' pressedn", 
  100. SDL_GetKeyName(event->key.keysym.sym));
  101. break;
  102.     case SDL_QUIT:
  103. done = 1;
  104. break;
  105. }
  106. return(done);
  107. }
  109. void SDL_GL_Enter2DMode()
  110. {
  111. SDL_Surface *screen = SDL_GetVideoSurface();
  113. /* Note, there may be other things you need to change,
  114.    depending on how you have your OpenGL state set up.
  115. */
  116. glPushAttrib(GL_ENABLE_BIT);
  117. glDisable(GL_DEPTH_TEST);
  118. glDisable(GL_CULL_FACE);
  119. glEnable(GL_TEXTURE_2D);
  121. /* This allows alpha blending of 2D textures with the scene */
  122. glEnable(GL_BLEND);
  123. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  125. glViewport(0, 0, screen->w, screen->h);
  127. glMatrixMode(GL_PROJECTION);
  128. glPushMatrix();
  129. glLoadIdentity();
  131. glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);
  133. glMatrixMode(GL_MODELVIEW);
  134. glPushMatrix();
  135. glLoadIdentity();
  137. glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  138. }
  140. void SDL_GL_Leave2DMode()
  141. {
  142. glMatrixMode(GL_MODELVIEW);
  143. glPopMatrix();
  145. glMatrixMode(GL_PROJECTION);
  146. glPopMatrix();
  148. glPopAttrib();
  149. }
  151. /* Quick utility function for texture creation */
  152. static int power_of_two(int input)
  153. {
  154. int value = 1;
  156. while ( value < input ) {
  157. value <<= 1;
  158. }
  159. return value;
  160. }
  162. GLuint SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
  163. {
  164. GLuint texture;
  165. int w, h;
  166. SDL_Surface *image;
  167. SDL_Rect area;
  168. Uint32 saved_flags;
  169. Uint8  saved_alpha;
  171. /* Use the surface width and height expanded to powers of 2 */
  172. w = power_of_two(surface->w);
  173. h = power_of_two(surface->h);
  174. texcoord[0] = 0.0f; /* Min X */
  175. texcoord[1] = 0.0f; /* Min Y */
  176. texcoord[2] = (GLfloat)surface->w / w; /* Max X */
  177. texcoord[3] = (GLfloat)surface->h / h; /* Max Y */
  179. image = SDL_CreateRGBSurface(
  180. SDL_SWSURFACE,
  181. w, h,
  182. 32,
  183. #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
  184. 0x000000FF, 
  185. 0x0000FF00, 
  186. 0x00FF0000, 
  187. 0xFF000000
  188. #else
  189. 0xFF000000,
  190. 0x00FF0000, 
  191. 0x0000FF00, 
  192. 0x000000FF
  193. #endif
  194.        );
  195. if ( image == NULL ) {
  196. return 0;
  197. }
  199. /* Save the alpha blending attributes */
  200. saved_flags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
  201. saved_alpha = surface->format->alpha;
  202. if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
  203. SDL_SetAlpha(surface, 0, 0);
  204. }
  206. /* Copy the surface into the GL texture image */
  207. area.x = 0;
  208. area.y = 0;
  209. area.w = surface->w;
  210. area.h = surface->h;
  211. SDL_BlitSurface(surface, &area, image, &area);
  213. /* Restore the alpha blending attributes */
  214. if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
  215. SDL_SetAlpha(surface, saved_flags, saved_alpha);
  216. }
  218. /* Create an OpenGL texture for the image */
  219. glGenTextures(1, &texture);
  220. glBindTexture(GL_TEXTURE_2D, texture);
  221. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  222. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  223. glTexImage2D(GL_TEXTURE_2D,
  224.      0,
  225.      GL_RGBA,
  226.      w, h,
  227.      0,
  228.      GL_RGBA,
  229.      GL_UNSIGNED_BYTE,
  230.      image->pixels);
  231. SDL_FreeSurface(image); /* No longer needed */
  233. return texture;
  234. }
  236. void DrawLogoTexture(void)
  237. {
  238. static GLuint texture;
  239. static GLfloat texMinX, texMinY;
  240. static GLfloat texMaxX, texMaxY;
  241. static int x = 0;
  242. static int y = 0;
  243. static int w, h;
  244. static int delta_x = 1;
  245. static int delta_y = 1;
  246. static Uint32 last_moved = 0;
  248. SDL_Surface *screen = SDL_GetVideoSurface();
  250. if ( ! texture ) {
  251. SDL_Surface *image;
  252. GLfloat texcoord[4];
  254. /* Load the image (could use SDL_image library here) */
  255. image = SDL_LoadBMP(LOGO_FILE);
  256. if ( image == NULL ) {
  257. return;
  258. }
  259. w = image->w;
  260. h = image->h;
  262. /* Convert the image into an OpenGL texture */
  263. texture = SDL_GL_LoadTexture(image, texcoord);
  265. /* Make texture coordinates easy to understand */
  266. texMinX = texcoord[0];
  267. texMinY = texcoord[1];
  268. texMaxX = texcoord[2];
  269. texMaxY = texcoord[3];
  271. /* We don't need the original image anymore */
  272. SDL_FreeSurface(image);
  274. /* Make sure that the texture conversion is okay */
  275. if ( ! texture ) {
  276. return;
  277. }
  278. }
  280. /* Move the image around */
  281. x += delta_x;
  282. if ( x < 0 ) {
  283. x = 0;
  284. delta_x = -delta_x;
  285. } else
  286. if ( (x+w) > screen->w ) {
  287. x = screen->w-w;
  288. delta_x = -delta_x;
  289. }
  290. y += delta_y;
  291. if ( y < 0 ) {
  292. y = 0;
  293. delta_y = -delta_y;
  294. } else
  295. if ( (y+h) > screen->h ) {
  296. y = screen->h-h;
  297. delta_y = -delta_y;
  298. }
  300. /* Show the image on the screen */
  301. SDL_GL_Enter2DMode();
  302. glBindTexture(GL_TEXTURE_2D, texture);
  303. glBegin(GL_TRIANGLE_STRIP);
  304. glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
  305. glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y  );
  306. glTexCoord2f(texMinX, texMaxY); glVertex2i(x,   y+h);
  307. glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
  308. glEnd();
  309. SDL_GL_Leave2DMode();
  310. }
  312. /* This code is deprecated, but available for speed comparisons */
  313. void DrawLogoBlit(void)
  314. {
  315. static SDL_Surface *image = NULL;
  316. static GLuint texture;
  317. static GLfloat texMinX, texMinY;
  318. static GLfloat texMaxX, texMaxY;
  319. static int x = 0;
  320. static int y = 0;
  321. static int w, h;
  322. static int delta_x = 1;
  323. static int delta_y = 1;
  324. static Uint32 last_moved = 0;
  326. SDL_Rect dst;
  327. SDL_Surface *screen = SDL_GetVideoSurface();
  329. if ( image == NULL ) {
  330. SDL_Surface *temp;
  332. /* Load the image (could use SDL_image library here) */
  333. temp = SDL_LoadBMP(LOGO_FILE);
  334. if ( temp == NULL ) {
  335. return;
  336. }
  337. w = temp->w;
  338. h = temp->h;
  340. /* Convert the image into the screen format */
  341. image = SDL_CreateRGBSurface(
  342. SDL_SWSURFACE,
  343. w, h,
  344. screen->format->BitsPerPixel,
  345. screen->format->Rmask,
  346. screen->format->Gmask,
  347. screen->format->Bmask,
  348. screen->format->Amask);
  349. if ( image ) {
  350. SDL_BlitSurface(temp, NULL, image, NULL);
  351. }
  352. SDL_FreeSurface(temp);
  354. /* Make sure that the texture conversion is okay */
  355. if ( ! image ) {
  356. return;
  357. }
  358. }
  360. /* Move the image around
  361.            Note that we do not clear the old position.  This is because we
  362.            perform a glClear() which clears the framebuffer and then only
  363.            update the new area.
  364.            Note that you can also achieve interesting effects by modifying
  365.            the screen surface alpha channel.  It's set to 255 by default..
  366.          */
  367. x += delta_x;
  368. if ( x < 0 ) {
  369. x = 0;
  370. delta_x = -delta_x;
  371. } else
  372. if ( (x+w) > screen->w ) {
  373. x = screen->w-w;
  374. delta_x = -delta_x;
  375. }
  376. y += delta_y;
  377. if ( y < 0 ) {
  378. y = 0;
  379. delta_y = -delta_y;
  380. } else
  381. if ( (y+h) > screen->h ) {
  382. y = screen->h-h;
  383. delta_y = -delta_y;
  384. }
  385. dst.x = x;
  386. dst.y = y;
  387. dst.w = w;
  388. dst.h = h;
  389. SDL_BlitSurface(image, NULL, screen, &dst);
  391. /* Show the image on the screen */
  392. SDL_UpdateRects(screen, 1, &dst);
  393. }
  395. int RunGLTest( int argc, char* argv[],
  396.                int logo, int slowly, int bpp, float gamma, int noframe )
  397. {
  398. int i;
  399. int rgb_size[3];
  400. int w = 640;
  401. int h = 480;
  402. int done = 0;
  403. int frames;
  404. Uint32 start_time, this_time;
  405.         float color[8][3]= {{ 1.0,  1.0,  0.0}, 
  406.     { 1.0,  0.0,  0.0},
  407.     { 0.0,  0.0,  0.0},
  408.     { 0.0,  1.0,  0.0},
  409.     { 0.0,  1.0,  1.0},
  410.     { 1.0,  1.0,  1.0},
  411.     { 1.0,  0.0,  1.0},
  412.     { 0.0,  0.0,  1.0}};
  413. float cube[8][3]= {{ 0.5,  0.5, -0.5}, 
  414.    { 0.5, -0.5, -0.5},
  415.    {-0.5, -0.5, -0.5},
  416.    {-0.5,  0.5, -0.5},
  417.    {-0.5,  0.5,  0.5},
  418.    { 0.5,  0.5,  0.5},
  419.    { 0.5, -0.5,  0.5},
  420.    {-0.5, -0.5,  0.5}};
  421. Uint32 video_flags;
  422. int value;
  424. if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
  425. fprintf(stderr,"Couldn't initialize SDL: %sn",SDL_GetError());
  426. exit( 1 );
  427. }
  429. /* See if we should detect the display depth */
  430. if ( bpp == 0 ) {
  431. if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
  432. bpp = 8;
  433. } else {
  434. bpp = 16;  /* More doesn't seem to work */
  435. }
  436. }
  438. /* Set the flags we want to use for setting the video mode */
  439. if ( logo && USE_DEPRECATED_OPENGLBLIT ) {
  440. video_flags = SDL_OPENGLBLIT;
  441. } else {
  442. video_flags = SDL_OPENGL;
  443. }
  444. for ( i=1; argv[i]; ++i ) {
  445. if ( strcmp(argv[1], "-fullscreen") == 0 ) {
  446. video_flags |= SDL_FULLSCREEN;
  447. }
  448. }
  450.         if (noframe) {
  451.            video_flags |= SDL_NOFRAME;
  452.         }
  454. /* Initialize the display */
  455. switch (bpp) {
  456.     case 8:
  457. rgb_size[0] = 2;
  458. rgb_size[1] = 3;
  459. rgb_size[2] = 3;
  460. break;
  461.     case 15:
  462.     case 16:
  463. rgb_size[0] = 5;
  464. rgb_size[1] = 5;
  465. rgb_size[2] = 5;
  466. break;
  467.             default:
  468. rgb_size[0] = 8;
  469. rgb_size[1] = 8;
  470. rgb_size[2] = 8;
  471. break;
  472. }
  473. SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] );
  474. SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] );
  475. SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] );
  476. SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
  477. SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
  478. if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) {
  479. fprintf(stderr, "Couldn't set GL mode: %sn", SDL_GetError());
  480. SDL_Quit();
  481. exit(1);
  482. }
  484. printf("Screen BPP: %dn", SDL_GetVideoSurface()->format->BitsPerPixel);
  485. printf("n");
  486. printf( "Vendor     : %sn", glGetString( GL_VENDOR ) );
  487. printf( "Renderer   : %sn", glGetString( GL_RENDERER ) );
  488. printf( "Version    : %sn", glGetString( GL_VERSION ) );
  489. printf( "Extensions : %sn", glGetString( GL_EXTENSIONS ) );
  490. printf("n");
  492. SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
  493. printf( "SDL_GL_RED_SIZE: requested %d, got %dn", rgb_size[0],value);
  494. SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
  495. printf( "SDL_GL_GREEN_SIZE: requested %d, got %dn", rgb_size[1],value);
  496. SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
  497. printf( "SDL_GL_BLUE_SIZE: requested %d, got %dn", rgb_size[2],value);
  498. SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
  499. printf( "SDL_GL_DEPTH_SIZE: requested %d, got %dn", bpp, value );
  500. SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
  501. printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %dn", value );
  503. /* Set the window manager title bar */
  504. SDL_WM_SetCaption( "SDL GL test", "testgl" );
  506. /* Set the gamma for the window */
  507. if ( gamma != 0.0 ) {
  508. SDL_SetGamma(gamma, gamma, gamma);
  509. }
  511. glViewport( 0, 0, w, h );
  512. glMatrixMode( GL_PROJECTION );
  513. glLoadIdentity( );
  515. glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
  517. glMatrixMode( GL_MODELVIEW );
  518. glLoadIdentity( );
  520. glEnable(GL_DEPTH_TEST);
  522. glDepthFunc(GL_LESS);
  524. glShadeModel(GL_SMOOTH);
  526. /* Loop until done. */
  527. start_time = SDL_GetTicks();
  528. frames = 0;
  529. while( !done ) {
  530. GLenum gl_error;
  531. char* sdl_error;
  532. SDL_Event event;
  534. /* Do our drawing, too. */
  535. glClearColor( 0.0, 0.0, 0.0, 1.0 );
  536. glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  538. glBegin( GL_QUADS );
  540. #ifdef SHADED_CUBE
  541. glColor3fv(color[0]);
  542. glVertex3fv(cube[0]);
  543. glColor3fv(color[1]);
  544. glVertex3fv(cube[1]);
  545. glColor3fv(color[2]);
  546. glVertex3fv(cube[2]);
  547. glColor3fv(color[3]);
  548. glVertex3fv(cube[3]);
  550. glColor3fv(color[3]);
  551. glVertex3fv(cube[3]);
  552. glColor3fv(color[4]);
  553. glVertex3fv(cube[4]);
  554. glColor3fv(color[7]);
  555. glVertex3fv(cube[7]);
  556. glColor3fv(color[2]);
  557. glVertex3fv(cube[2]);
  559. glColor3fv(color[0]);
  560. glVertex3fv(cube[0]);
  561. glColor3fv(color[5]);
  562. glVertex3fv(cube[5]);
  563. glColor3fv(color[6]);
  564. glVertex3fv(cube[6]);
  565. glColor3fv(color[1]);
  566. glVertex3fv(cube[1]);
  568. glColor3fv(color[5]);
  569. glVertex3fv(cube[5]);
  570. glColor3fv(color[4]);
  571. glVertex3fv(cube[4]);
  572. glColor3fv(color[7]);
  573. glVertex3fv(cube[7]);
  574. glColor3fv(color[6]);
  575. glVertex3fv(cube[6]);
  577. glColor3fv(color[5]);
  578. glVertex3fv(cube[5]);
  579. glColor3fv(color[0]);
  580. glVertex3fv(cube[0]);
  581. glColor3fv(color[3]);
  582. glVertex3fv(cube[3]);
  583. glColor3fv(color[4]);
  584. glVertex3fv(cube[4]);
  586. glColor3fv(color[6]);
  587. glVertex3fv(cube[6]);
  588. glColor3fv(color[1]);
  589. glVertex3fv(cube[1]);
  590. glColor3fv(color[2]);
  591. glVertex3fv(cube[2]);
  592. glColor3fv(color[7]);
  593. glVertex3fv(cube[7]);
  594. #else // flat cube
  595. glColor3f(1.0, 0.0, 0.0);
  596. glVertex3fv(cube[0]);
  597. glVertex3fv(cube[1]);
  598. glVertex3fv(cube[2]);
  599. glVertex3fv(cube[3]);
  601. glColor3f(0.0, 1.0, 0.0);
  602. glVertex3fv(cube[3]);
  603. glVertex3fv(cube[4]);
  604. glVertex3fv(cube[7]);
  605. glVertex3fv(cube[2]);
  607. glColor3f(0.0, 0.0, 1.0);
  608. glVertex3fv(cube[0]);
  609. glVertex3fv(cube[5]);
  610. glVertex3fv(cube[6]);
  611. glVertex3fv(cube[1]);
  613. glColor3f(0.0, 1.0, 1.0);
  614. glVertex3fv(cube[5]);
  615. glVertex3fv(cube[4]);
  616. glVertex3fv(cube[7]);
  617. glVertex3fv(cube[6]);
  619. glColor3f(1.0, 1.0, 0.0);
  620. glVertex3fv(cube[5]);
  621. glVertex3fv(cube[0]);
  622. glVertex3fv(cube[3]);
  623. glVertex3fv(cube[4]);
  625. glColor3f(1.0, 0.0, 1.0);
  626. glVertex3fv(cube[6]);
  627. glVertex3fv(cube[1]);
  628. glVertex3fv(cube[2]);
  629. glVertex3fv(cube[7]);
  630. #endif /* SHADED_CUBE */
  632. glEnd( );
  634. glMatrixMode(GL_MODELVIEW);
  635. glRotatef(5.0, 1.0, 1.0, 1.0);
  637. /* Draw 2D logo onto the 3D display */
  638. if ( logo ) {
  639. if ( USE_DEPRECATED_OPENGLBLIT ) {
  640. DrawLogoBlit();
  641. } else {
  642. DrawLogoTexture();
  643. }
  644. }
  646. SDL_GL_SwapBuffers( );
  648. /* Check for error conditions. */
  649. gl_error = glGetError( );
  651. if( gl_error != GL_NO_ERROR ) {
  652. fprintf( stderr, "testgl: OpenGL error: %dn", gl_error );
  653. }
  655. sdl_error = SDL_GetError( );
  657. if( sdl_error[0] != '' ) {
  658. fprintf(stderr, "testgl: SDL error '%s'n", sdl_error);
  659. SDL_ClearError();
  660. }
  662. /* Allow the user to see what's happening */
  663. if ( slowly ) {
  664. SDL_Delay( 20 );
  665. }
  667. /* Check if there's a pending event. */
  668. while( SDL_PollEvent( &event ) ) {
  669. done = HandleEvent(&event);
  670. }
  671. ++frames;
  672. }
  674. /* Print out the frames per second */
  675. this_time = SDL_GetTicks();
  676. if ( this_time != start_time ) {
  677. printf("%2.2f FPSn",
  678. ((float)frames/(this_time-start_time))*1000.0);
  679. }
  681. /* Destroy our GL context, etc. */
  682. SDL_Quit( );
  683. return(0);
  684. }
  686. int main(int argc, char *argv[])
  687. {
  688. int i, logo;
  689. int numtests;
  690. int bpp = 0;
  691. int slowly;
  692. float gamma = 0.0;
  693.         int noframe = 0;
  695. logo = 0;
  696. slowly = 0;
  697. numtests = 1;
  698. for ( i=1; argv[i]; ++i ) {
  699. if ( strcmp(argv[i], "-twice") == 0 ) {
  700. ++numtests;
  701. }
  702. if ( strcmp(argv[i], "-logo") == 0 ) {
  703. logo = 1;
  704. USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
  705. }
  706. if ( strcmp(argv[i], "-logoblit") == 0 ) {
  707. logo = 1;
  708. USE_DEPRECATED_OPENGLBLIT = SDL_TRUE;
  709. }
  710. if ( strcmp(argv[i], "-slow") == 0 ) {
  711. slowly = 1;
  712. }
  713. if ( strcmp(argv[i], "-bpp") == 0 ) {
  714.          bpp = atoi(argv[++i]);
  715. }
  716. if ( strcmp(argv[i], "-gamma") == 0 ) {
  717.          gamma = (float)atof(argv[++i]);
  718. }
  719. if ( strcmp(argv[i], "-noframe") == 0 ) {
  720.          noframe = 1;
  721. }
  722. if ( strncmp(argv[i], "-h", 2) == 0 ) {
  723.          printf(
  724. "Usage: %s [-twice] [-logo] [-slow] [-bpp n] [-gamma n] [-noframe]n",
  725.         argv[0]);
  726. exit(0);
  727. }
  728. }
  729. for ( i=0; i<numtests; ++i ) {
  730.          RunGLTest(argc, argv, logo, slowly, bpp, gamma, noframe);
  731. }
  732. return 0;
  733. }
  735. #else /* HAVE_OPENGL */
  737. int main(int argc, char *argv[])
  738. {
  739. printf("No OpenGL support on this systemn");
  740. return 1;
  741. }
  743. #endif /* HAVE_OPENGL */