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

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

GIS编程

开发平台：

Visual C++

highlight.c：源码内容
  2. /* Copyright (c) Mark J. Kilgard, 1994. */
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  8. /**
  9.  * (c) Copyright 1993, Silicon Graphics, Inc.
  10.  * ALL RIGHTS RESERVED 
  11.  * Permission to use, copy, modify, and distribute this software for 
  12.  * any purpose and without fee is hereby granted, provided that the above
  13.  * copyright notice appear in all copies and that both the copyright notice
  14.  * and this permission notice appear in supporting documentation, and that 
  15.  * the name of Silicon Graphics, Inc. not be used in advertising
  16.  * or publicity pertaining to distribution of the software without specific,
  17.  * written prior permission. 
  18.  *
  19.  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  20.  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  21.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  22.  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  23.  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  24.  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  25.  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  26.  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  27.  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  28.  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  29.  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  30.  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  31.  * 
  32.  * US Government Users Restricted Rights 
  33.  * Use, duplication, or disclosure by the Government is subject to
  34.  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  35.  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  36.  * clause at DFARS 252.227-7013 and/or in similar or successor
  37.  * clauses in the FAR or the DOD or NASA FAR Supplement.
  38.  * Unpublished-- rights reserved under the copyright laws of the
  39.  * United States.  Contractor/manufacturer is Silicon Graphics,
  40.  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  41.  *
  42.  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
  43.  */
  44. /*
  45.  *  scene.c
  46.  *  This program demonstrates the use of the GL lighting model.
  47.  *  Objects are drawn using a grey material characteristic. 
  48.  *  A single light source illuminates the objects.
  49.  */
  50. #include <stdlib.h>
  51. #include <stdarg.h>
  52. #include <stdio.h>
  53. #include <GL/glut.h>
  55. #define BUFSIZE 512
  57. #define TORUS 1
  58. #define TETRAHEDRON 2
  59. #define ICOSAHEDRON 3
  61. GLuint selectBuf[BUFSIZE];
  63. int W = 500, H = 500;
  64. GLfloat x, y;
  65. int locating = 0;
  66. GLuint theObject = 0;
  67. int menu_inuse = 0;
  68. int mouse_state = 0;
  70. char *objectNames[] =
  71. {"Nothing", "Torus", "Tetrahedron", "Icosahedron"};
  73. void
  74. output(GLfloat x, GLfloat y, char *format,...)
  75. {
  76.   va_list args;
  77.   char buffer[200], *p;
  79.   va_start(args, format);
  80.   vsprintf(buffer, format, args);
  81.   va_end(args);
  82.   glPushMatrix();
  83.   glTranslatef(x, y, 0);
  84.   for (p = buffer; *p; p++)
  85.     glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
  86.   glPopMatrix();
  87. }
  89. /* Initialize material property and light source. */
  90. void
  91. myinit(void)
  92. {
  93.   GLfloat light_ambient[] =
  94.   {0.2, 0.2, 0.2, 1.0};
  95.   GLfloat light_diffuse[] =
  96.   {1.0, 1.0, 1.0, 1.0};
  97.   GLfloat light_specular[] =
  98.   {1.0, 1.0, 1.0, 1.0};
  99.   GLfloat light_position[] =
  100.   {1.0, 1.0, 1.0, 0.0};
  102.   glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  103.   glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  104.   glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  105.   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  107.   glEnable(GL_LIGHT0);
  108.   glDepthFunc(GL_LESS);
  109.   glEnable(GL_DEPTH_TEST);
  110.   glEnable(GL_LIGHTING);
  112.   glSelectBuffer(BUFSIZE, selectBuf);
  114.   glNewList(TORUS, GL_COMPILE);
  115.   glutSolidTorus(0.275, 0.85, 10, 15);
  116.   glEndList();
  117.   glNewList(TETRAHEDRON, GL_COMPILE);
  118.   glutSolidTetrahedron();
  119.   glEndList();
  120.   glNewList(ICOSAHEDRON, GL_COMPILE);
  121.   glutSolidIcosahedron();
  122.   glEndList();
  123. }
  125. void
  126. highlightBegin(void)
  127. {
  128.   static GLfloat red[4] =
  129.   {1.0, 0.0, 0.0, 1.0};
  131.   glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT);
  132.   glMaterialfv(GL_FRONT, GL_DIFFUSE, red);
  133.   glColor3f(1.0, 0.0, 0.0);
  134. }
  136. void
  137. highlightEnd(void)
  138. {
  139.   glPopAttrib();
  140. }
  142. void
  143. draw(void)
  144. {
  145.   glPushMatrix();
  146.   glScalef(1.3, 1.3, 1.3);
  147.   glRotatef(20.0, 1.0, 0.0, 0.0);
  149.   glLoadName(2);
  150.   glPushMatrix();
  151.   if (theObject == 2)
  152.     highlightBegin();
  153.   glTranslatef(-0.75, -0.5, 0.0);
  154.   glRotatef(270.0, 1.0, 0.0, 0.0);
  155.   glCallList(TETRAHEDRON);
  156.   if (theObject == 2)
  157.     highlightEnd();
  158.   glPopMatrix();
  160.   glLoadName(1);
  161.   glPushMatrix();
  162.   if (theObject == 1)
  163.     highlightBegin();
  164.   glTranslatef(-0.75, 0.5, 0.0);
  165.   glRotatef(90.0, 1.0, 0.0, 0.0);
  166.   glCallList(TORUS);
  167.   if (theObject == 1)
  168.     highlightEnd();
  169.   glPopMatrix();
  171.   glLoadName(3);
  172.   glPushMatrix();
  173.   if (theObject == 3)
  174.     highlightBegin();
  175.   glTranslatef(0.75, 0.0, -1.0);
  176.   glCallList(ICOSAHEDRON);
  177.   if (theObject == 3)
  178.     highlightEnd();
  179.   glPopMatrix();
  181.   glPopMatrix();
  182. }
  184. void
  185. myortho(void)
  186. {
  187.   if (W <= H)
  188.     glOrtho(-2.5, 2.5, -2.5 * (GLfloat) H / (GLfloat) W,
  189.       2.5 * (GLfloat) H / (GLfloat) W, -10.0, 10.0);
  190.   else
  191.     glOrtho(-2.5 * (GLfloat) W / (GLfloat) H,
  192.       2.5 * (GLfloat) W / (GLfloat) H, -2.5, 2.5, -10.0, 10.0);
  193. }
  195. /*  processHits() prints out the contents of the 
  196.  *  selection array.
  197.  */
  198. void
  199. processHits(GLint hits, GLuint buffer[])
  200. {
  201.   GLuint depth = (GLuint) ~0;
  202.   unsigned int getThisName;
  203.   GLint i;
  204.   GLuint names, *ptr;
  205.   GLuint newObject;
  207.   ptr = (GLuint *) buffer;
  208.   newObject = 0;
  209.   for (i = 0; i < hits; i++) {  /* for each hit  */
  210.     getThisName = 0;
  211.     names = *ptr;
  212.     ptr++;              /* skip # name */
  213.     if (*ptr <= depth) {
  214.       depth = *ptr;
  215.       getThisName = 1;
  216.     }
  217.     ptr++;              /* skip z1 */
  218.     if (*ptr <= depth) {
  219.       depth = *ptr;
  220.       getThisName = 1;
  221.     }
  222.     ptr++;              /* skip z2 */
  224.     if (getThisName)
  225.       newObject = *ptr;
  226.     ptr += names;       /* skip the names list */
  227.   }
  228.   if (theObject != newObject) {
  229.     theObject = newObject;
  230.     glutPostRedisplay();
  231.   }
  232. }
  234. /* ARGSUSED */
  235. void
  236. locate(int value)
  237. {
  238.   GLint viewport[4];
  239.   GLint hits;
  241.   if (locating) {
  242.     if (mouse_state == GLUT_ENTERED) {
  243.       (void) glRenderMode(GL_SELECT);
  244.       glInitNames();
  245.       glPushName(-1);
  247.       glMatrixMode(GL_PROJECTION);
  248.       glPushMatrix();
  249.       glLoadIdentity();
  250.       viewport[0] = 0;
  251.       viewport[1] = 0;
  252.       viewport[2] = W;
  253.       viewport[3] = H;
  254.       gluPickMatrix(x, H - y, 5.0, 5.0, viewport);
  255.       myortho();
  256.       glMatrixMode(GL_MODELVIEW);
  257.       draw();
  258.       glMatrixMode(GL_PROJECTION);
  259.       glPopMatrix();
  260.       glMatrixMode(GL_MODELVIEW);
  261.       hits = glRenderMode(GL_RENDER);
  262.     } else {
  263.       hits = 0;
  264.     }
  265.     processHits(hits, selectBuf);
  266.   }
  267.   locating = 0;
  268. }
  270. void
  271. passive(int newx, int newy)
  272. {
  273.   x = newx;
  274.   y = newy;
  275.   if (!locating) {
  276.     locating = 1;
  277.     glutTimerFunc(1, locate, 0);
  278.   }
  279. }
  281. void
  282. entry(int state)
  283. {
  284.   mouse_state = state;
  285.   if (!menu_inuse) {
  286.     if (state == GLUT_LEFT) {
  287.       if (theObject != 0) {
  288.         theObject = 0;
  289.         glutPostRedisplay();
  290.       }
  291.     }
  292.   }
  293. }
  295. void
  296. display(void)
  297. {
  298.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  299.   draw();
  301.   glPushAttrib(GL_ENABLE_BIT);
  302.   glDisable(GL_DEPTH_TEST);
  303.   glDisable(GL_LIGHTING);
  304.   glDisable(GL_LINE_SMOOTH);
  306.   glMatrixMode(GL_PROJECTION);
  307.   glPushMatrix();
  308.   glLoadIdentity();
  309.   gluOrtho2D(0, 3000, 0, 3000);
  310.   glMatrixMode(GL_MODELVIEW);
  311.   glPushMatrix();
  312.   glLoadIdentity();
  313.   output(80, 2800, "Automatically names object under mouse.");
  314.   output(80, 100, "Located: %s.", objectNames[theObject]);
  315.   glPopMatrix();
  316.   glMatrixMode(GL_PROJECTION);
  317.   glPopMatrix();
  318.   glMatrixMode(GL_MODELVIEW);
  319.   glPopAttrib();
  321.   glutSwapBuffers();
  322. }
  324. void
  325. myReshape(int w, int h)
  326. {
  327.   W = w;
  328.   H = h;
  329.   glViewport(0, 0, W, H);
  330.   glMatrixMode(GL_PROJECTION);
  331.   glLoadIdentity();
  332.   myortho();
  333.   glMatrixMode(GL_MODELVIEW);
  334. }
  336. void
  337. polygon_mode(int value)
  338. {
  339.   switch (value) {
  340.   case 1:
  341.     glEnable(GL_LIGHTING);
  342.     glDisable(GL_BLEND);
  343.     glEnable(GL_DEPTH_TEST);
  344.     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  345.     break;
  346.   case 2:
  347.     glDisable(GL_LIGHTING);
  348.     glColor3f(1.0, 1.0, 1.0);
  349.     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  350.     glEnable(GL_LINE_SMOOTH);
  351.     glEnable(GL_BLEND);
  352.     glDisable(GL_DEPTH_TEST);
  353.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  354.     break;
  355.   }
  356.   glutPostRedisplay();
  357. }
  359. void
  360. mstatus(int status, int newx, int newy)
  361. {
  362.   if (status == GLUT_MENU_NOT_IN_USE) {
  363.     menu_inuse = 0;
  364.     passive(newx, newy);
  365.   } else {
  366.     menu_inuse = 1;
  367.   }
  368. }
  370. void
  371. main_menu(int value)
  372. {
  373.   if (value == 666)
  374.     exit(0);
  375. }
  377. /*  Main Loop
  378.  *  Open window with initial window size, title bar, 
  379.  *  RGBA display mode, and handle input events.
  380.  */
  381. int
  382. main(int argc, char **argv)
  383. {
  384.   int submenu;
  386.   glutInit(&argc, argv);
  387.   glutInitWindowSize(W, H);
  388.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  389.   glutCreateWindow(argv[0]);
  390.   myinit();
  391.   glutReshapeFunc(myReshape);
  392.   glutDisplayFunc(display);
  393.   submenu = glutCreateMenu(polygon_mode);
  394.   glutAddMenuEntry("Filled", 1);
  395.   glutAddMenuEntry("Outline", 2);
  396.   glutCreateMenu(main_menu);
  397.   glutAddMenuEntry("Quit", 666);
  398.   glutAddSubMenu("Polygon mode", submenu);
  399.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  400.   glutPassiveMotionFunc(passive);
  401.   glutEntryFunc(entry);
  402.   glutMenuStatusFunc(mstatus);
  403.   glutMainLoop();
  404.   return 0;             /* ANSI C requires main to return int. */
  405. }