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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
txfdemo.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：9k
源码类别：

GIS编程

开发平台：

Visual C++

txfdemo.c：源码内容
  2. /* Copyright (c) Mark J. Kilgard, 1997. */
  4. /* This program is freely distributable without licensing fees  and is
  5.    provided without guarantee or warrantee expressed or  implied. This
  6.    program is -not- in the public domain. */
  8. /* X compile line: cc -o txfdemo txfdemo.c -lglut -lGLU -lGL -lXmu -lXext -lX11 -lm */
  10. #include <math.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <stdio.h>
  14. #include <GL/glut.h>
  16. #include "TexFont.h"
  18. /* Uncomment to debug various scenarios. */
  19. #if 0
  20. #undef GL_VERSION_1_1
  21. #undef GL_EXT_polygon_offset
  22. #endif
  24. #ifndef GL_VERSION_1_1
  25. #ifdef GL_EXT_polygon_offset
  26. #define GL_POLYGON_OFFSET_FILL GL_POLYGON_OFFSET_EXT
  27. #define glPolygonOffset(s,b) glPolygonOffsetEXT(s,b*0.001);
  28. #else
  29. /* Gag.  No polygon offset?  Artifacts will exist. */
  30. #define glPolygonOffset(s,b) /* nothing */
  31. #endif
  32. #endif
  34. #ifndef M_PI
  35. #define M_PI            3.14159265358979323846
  36. #endif
  38. static int doubleBuffer = 1;
  39. static char *filename = "rockfont.txf";
  40. static GLfloat angle = 20;
  41. static TexFont *txf;
  42. static int usePolygonOffset = 1;
  43. static int animation = 1;
  44. static int fullscreen = 0;
  46. void
  47. idle(void)
  48. {
  49.   angle += 4;
  50.   glutPostRedisplay();
  51. }
  53. void 
  54. visible(int vis)
  55. {
  56.   if (vis == GLUT_VISIBLE) {
  57.     if (animation) {
  58.       glutIdleFunc(idle);
  59.     }
  60.   } else {
  61.     glutIdleFunc(NULL);
  62.   }
  63. }
  65. void reshape(int w, int h)
  66. {
  67.    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
  68.    glMatrixMode(GL_PROJECTION);
  69.    glLoadIdentity();
  70.    gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
  71.    glMatrixMode(GL_MODELVIEW);
  72. }
  74. void
  75. cubeSide(void)
  76. {
  77.   glDisable(GL_TEXTURE_2D);
  78.   glDisable(GL_BLEND);
  79.   glDisable(GL_ALPHA_TEST);
  80.   glColor3f(0.3, 0.7, 0.3);
  81.   glRectf(-1.0, -1.0, 1.0, 1.0);
  82. }
  84. int alphaMode;
  86. void
  87. alphaModeSet(void)
  88. {
  89.   switch (alphaMode) {
  90.   case GL_ALPHA_TEST:
  91.     glDisable(GL_BLEND);
  92.     glEnable(GL_ALPHA_TEST);
  93.     glAlphaFunc(GL_GEQUAL, 0.5);
  94.     break;
  95.   case GL_BLEND:
  96.     glDisable(GL_ALPHA_TEST);
  97.     glEnable(GL_BLEND);
  98.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  99.     break;
  100.   case GL_ALPHA_TEST + GL_BLEND:
  101.     glEnable(GL_ALPHA_TEST);
  102.     glAlphaFunc(GL_GEQUAL, 0.0625);
  103.     glEnable(GL_BLEND);
  104.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  105.     break;
  106.   case GL_NONE:
  107.     glDisable(GL_ALPHA_TEST);
  108.     glDisable(GL_BLEND);
  109.     break;
  110.   }
  111. }
  113. void
  114. cubeSideWithOpenGLcircle(void)
  115. {
  116.   int w, ow, a, d;
  117.   char *text;
  118.   int len;
  119.   int i;
  120.   GLfloat flen;
  122.   cubeSide();
  124.   glPushMatrix();
  125.     alphaModeSet();
  126.     glEnable(GL_TEXTURE_2D);
  127.     if (usePolygonOffset) {
  128. #if defined(GL_EXT_polygon_offset) || defined(GL_VERSION_1_1)
  129.       glEnable(GL_POLYGON_OFFSET_FILL);
  130.       glPolygonOffset(0.0, -3);
  131. #endif
  132.     }
  133.     glColor3f(0.2, 0.2, 0.9);
  135.     txfGetStringMetrics(txf, "OpenGL", 6, &w, &a, &d);
  136.     text = "OpenGL OpenGL ";
  137.     len = (int) strlen(text);
  138.     txfGetStringMetrics(txf, text, len, &w, &a, &d);
  139.     txfGetStringMetrics(txf, "O", 1, &ow, &a, &d);
  141.     glScalef(5.6/w, 5.6/w, 5.6/w);
  142.     flen = len;
  143.     glTranslatef(-ow/2.0, -w/(M_PI*2.0), 0.0);
  145.     for (i=0; i<len; i++) {
  146.       if (text[i] == 'L' && usePolygonOffset) {
  147. /* Hack.  The "L" in OpenGL slightly overlaps the "G". Slightly
  148.    raise the "L" so that it will overlap the "G" in the depth
  149.    buffer to avoid a double blend.. */
  150.         glPolygonOffset(0.0, -4);
  151.         txfRenderGlyph(txf, text[i]);
  152.         glPolygonOffset(0.0, -3);
  153.       } else {
  154.         txfRenderGlyph(txf, text[i]);
  155.       }
  156.       glRotatef(360.0/flen, 0, 0, 1);
  157.     }
  158.     if (usePolygonOffset) {
  159. #if defined(GL_EXT_polygon_offset) || defined(GL_VERSION_1_1)
  160.       glDisable(GL_POLYGON_OFFSET_FILL);
  161. #endif
  162.     }
  163.   glPopMatrix();
  164. }
  166. void
  167. cubeSideWithText(char *text, int len)
  168. {
  169.   int w, a, d;
  171.   cubeSide();
  173.   glPushMatrix();
  174.     glEnable(GL_TEXTURE_2D);
  175.     alphaModeSet();
  176.     if (usePolygonOffset) {
  177. #if defined(GL_EXT_polygon_offset) || defined(GL_VERSION_1_1)
  178.       glEnable(GL_POLYGON_OFFSET_FILL);
  179.       glPolygonOffset(0.0, -3);
  180. #endif
  181.     }
  182.     glColor3f(0.2, 0.2, 0.9);
  184.     txfGetStringMetrics(txf, text, len, &w, &a, &d);
  186.     glScalef(1.8/w, 1.8/w, 1.8/w);
  187.     glTranslatef(-w/2.0, d-(a+d)/2.0, 0.0);
  189.     txfRenderFancyString(txf, text, len);
  190.     if (usePolygonOffset) {
  191. #if defined(GL_EXT_polygon_offset) || defined(GL_VERSION_1_1)
  192.       glDisable(GL_POLYGON_OFFSET_FILL);
  193. #endif
  194.     }
  195.   glPopMatrix();
  196. }
  198. void
  199. display(void)
  200. {
  201.   char *str;
  203.   /* Clear the color buffer. */
  204.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  206.   glPushMatrix();
  208.   glRotatef(-angle, 0, 1, 0);
  210.   glPushMatrix();
  211.     glTranslatef(0.0, 0.0, 1.0);
  212.     cubeSideWithOpenGLcircle();
  213.   glPopMatrix();
  214.   glPushMatrix();
  215.     glRotatef(90.0, 0, 1, 0);
  216.     glTranslatef(0.0, 0.0, 1.0);
  217.     str = "MAkes";
  218.     cubeSideWithText(str, (int) strlen(str));
  219.   glPopMatrix();
  220.   glPushMatrix();
  221.     glRotatef(180.0, 0, 1, 0);
  222.     glTranslatef(0.0, 0.0, 1.0);
  223.     str = "Text";
  224.     cubeSideWithText(str, (int) strlen(str));
  225.   glPopMatrix();
  226.   glPushMatrix();
  227.     glRotatef(270.0, 0, 1, 0);
  228.     glTranslatef(0.0, 0.0, 1.0);
  229.     str = "33T377000000003773D";
  230.     cubeSideWithText(str, 10);
  231.   glPopMatrix();
  233.   glPopMatrix();
  235.   /* Swap the buffers if necessary. */
  236.   if (doubleBuffer) {
  237.     glutSwapBuffers();
  238.   }
  239. }
  241. int savex;
  243. /* ARGSUSED23 */
  244. void
  245. mouse(int button, int state, int x, int y)
  246. {
  247.   if (button == GLUT_LEFT_BUTTON) {
  248.     if (state == GLUT_DOWN) {
  249.       glutIdleFunc(NULL);
  250.       savex = x;
  251.     } else {
  252.       if (animation)
  253.         glutIdleFunc(idle);
  254.     }
  255.   }
  256. }
  258. /* ARGSUSED1 */
  259. void
  260. motion(int x, int y)
  261. {
  262.   angle += (savex - x);
  263.   savex = x;
  264.   glutPostRedisplay();
  265. }
  267. int minifyMenu;
  269. void
  270. minifySelect(int value)
  271. {
  272.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, value);
  273.   glutPostRedisplay();
  274. }
  276. int alphaMenu;
  278. void
  279. alphaSelect(int value)
  280. {
  281.   alphaMode = value;
  282.   glutPostRedisplay();
  283. }
  285. int polygonOffsetMenu;
  287. void
  288. polygonOffsetSelect(int value)
  289. {
  290.   usePolygonOffset = value;
  291.   glutPostRedisplay();
  292. }
  294. int animationMenu;
  296. void
  297. animationSelect(int value)
  298. {
  299.   animation = value;
  300.   if (animation) {
  301.     glutIdleFunc(idle);
  302.   } else {
  303.     glutIdleFunc(NULL);
  304.   }
  305. }
  307. /* ARGSUSED1 */
  308. void
  309. keyboard(unsigned char c, int x, int y)
  310. {
  311.   switch(c) {
  312.   case 27:
  313.     exit(0);
  314.     break;
  315.   case ' ':
  316.     animation = 1 - animation;
  317.     if (animation) {
  318.       glutIdleFunc(idle);
  319.     } else  {
  320.       glutIdleFunc(NULL);
  321.     }
  322.     break;
  323.   }
  324. }
  326. void
  327. mainSelect(int value)
  328. {
  329.   if (value == 666) {
  330.     exit(0);
  331.   }
  332. }
  334. int
  335. main(int argc, char **argv)
  336. {
  337.   int i;
  339.   glutInit(&argc, argv);
  340.   for (i = 1; i < argc; i++) {
  341.     if (!strcmp(argv[i], "-sb")) {
  342.       doubleBuffer = 0;
  343.     } else if (!strcmp(argv[i], "-fullscreen")) {
  344.       fullscreen = 1;
  345.     } else {
  346.       filename = argv[i];
  347.     }
  348.   }
  349.   if (filename == NULL) {
  350.     fprintf(stderr, "usage: txfdemo [GLUT-options] [-sb] txf-filen");
  351.     exit(1);
  352.   }
  354.   txf = txfLoadFont(filename);
  355.   if (txf == NULL) {
  356.     fprintf(stderr, "Problem loading %s, %sn", filename, txfErrorString());
  357.     exit(1);
  358.   }
  360.   if (doubleBuffer) {
  361.     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
  362.   } else {
  363.     glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
  364.   }
  365.   glutInitWindowSize(300, 300);
  366.   if (fullscreen) {
  367.     glutGameModeString("640x480:16@60");
  368.     glutEnterGameMode();
  369.   } else {
  370.     glutCreateWindow("txfdemo");
  371.   }
  372.   glutDisplayFunc(display);
  373.   glutMouseFunc(mouse);
  374.   glutMotionFunc(motion);
  375.   glutKeyboardFunc(keyboard);
  376.   glutVisibilityFunc(visible);
  377.   glutReshapeFunc(reshape);
  379.   glMatrixMode(GL_PROJECTION);
  380.   glLoadIdentity();
  381.   gluPerspective(60.0, 1.0, 0.1, 20.0);
  382.   glMatrixMode(GL_MODELVIEW);
  383.   gluLookAt(0.0, 0.0, 4.0,
  384.     0.0, 0.0, 0.0,
  385.     0.0, 1.0, 0.0);
  387.   /* Use a gray background so the teximage with black backgrounds will show
  388.      against showtxf's background. */
  389.   glClearColor(0.0, 0.0, 0.0, 0.0);
  391.   glEnable(GL_DEPTH_TEST);
  392.   glEnable(GL_CULL_FACE);
  393.   alphaSelect(GL_ALPHA_TEST);
  394.   minifySelect(GL_NEAREST);
  396.   txfEstablishTexture(txf, 1, GL_TRUE);
  398.   if (!fullscreen) {
  399.     minifyMenu = glutCreateMenu(minifySelect);
  400.     glutAddMenuEntry("Nearest", GL_NEAREST);
  401.     glutAddMenuEntry("Linear", GL_LINEAR);
  402.     glutAddMenuEntry("Nearest mipmap nearest", GL_NEAREST_MIPMAP_NEAREST);
  403.     glutAddMenuEntry("Linear mipmap nearest", GL_LINEAR_MIPMAP_NEAREST);
  404.     glutAddMenuEntry("Nearest mipmap linear", GL_NEAREST_MIPMAP_LINEAR);
  405.     glutAddMenuEntry("Linear mipmap linear", GL_LINEAR_MIPMAP_LINEAR);
  407.     alphaMenu = glutCreateMenu(alphaSelect);
  408.     glutAddMenuEntry("Alpha testing", GL_ALPHA_TEST);
  409.     glutAddMenuEntry("Alpha blending", GL_BLEND);
  410.     glutAddMenuEntry("Both", GL_ALPHA_TEST + GL_BLEND);
  411.     glutAddMenuEntry("Nothing", GL_NONE);
  413.     polygonOffsetMenu = glutCreateMenu(polygonOffsetSelect);
  414.     glutAddMenuEntry("Enable", 1);
  415.     glutAddMenuEntry("Disable", 0);
  417.     animationMenu = glutCreateMenu(animationSelect);
  418.     glutAddMenuEntry("Start", 1);
  419.     glutAddMenuEntry("Stop", 0);
  421.     glutCreateMenu(mainSelect);
  422.     glutAddSubMenu("Filtering", minifyMenu);
  423.     glutAddSubMenu("Alpha", alphaMenu);
  424.     glutAddSubMenu("Polygon Offset", polygonOffsetMenu);
  425.     glutAddSubMenu("Animation", animationMenu);
  426.     glutAddMenuEntry("Quit", 666);
  427.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  428.   }
  430. #if !defined(GL_EXT_polygon_offset) && !defined(GL_VERSION_1_1)
  431.   fprintf(stderr, "Warning: polygon offset not available; artifacts will results.n");
  432. #endif
  434.   glutMainLoop();
  435.   return 0;             /* ANSI C requires main to return int. */
  436. }