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

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

GIS编程

开发平台：

Visual C++

perfdraw.c：源码内容
  2. /*
  3.  * perfdraw.c - $Revision: 1.4 $
  4.  */
  6. #include <GL/glut.h>
  7. #include <math.h>
  8. #include <stdio.h>
  9. #include "skyfly.h"
  11. #if !defined(GL_VERSION_1_1)
  12. #if defined(GL_EXT_texture_object)
  13. #define glBindTexture(A,B)     glBindTextureEXT(A,B)
  14. #define glGenTextures(A,B)     glGenTexturesEXT(A,B)
  15. #define glDeleteTextures(A,B)  glDeleteTexturesEXT(A,B)
  16. #else
  17. #define glBindTexture(A,B)
  18. #define glGenTextures(A,B)
  19. #define glDeleteTextures(A,B)
  20. #endif
  21. #endif
  23. /* static routine decls */
  25. extern int clouds;
  26. static void drawlitmesh_11(float *objdata);
  27. static void drawcolrtexmesh_10(float *objdata);
  28. static void drawclouds(float *objdata);
  30. void drawperfobj(perfobj_t *perfobj)
  31. {
  32.     float     *vdata_ptr =(float *) perfobj->vdata;
  33.     extern void texenv(int), lightpos(void);
  35.     unsigned int *flagsptr = perfobj->flags;
  36.     float     *dp;
  38.     for (;;) {
  39.         switch (*flagsptr) {
  40. /*
  41.  * A paper plane is a single tmesh folded on itself so the orientations
  42.  * of some triangles in the mesh are incorrect with respect to
  43.  * their normals. This is solved by drawing the tmesh twice;
  44.  * first draw only backfaces, then only frontfaces.
  45.  */
  46. case PD_DRAW_PAPER_PLANE:
  47. flagsptr += 1;
  48. glCullFace(GL_FRONT);
  49. drawlitmesh_11(vdata_ptr);
  50. glCullFace(GL_BACK);
  51. drawlitmesh_11((float *)((perfobj_vert_t *) vdata_ptr + 11));
  52. glPopMatrix();
  53. break;
  55. case PD_DRAW_TERRAIN_CELL:
  56. dp = *(float **) (flagsptr + 1);
  57. flagsptr += 2;
  58. drawcolrtexmesh_10(dp);
  59. break;
  61. case PD_DRAW_CLOUDS:
  62.                         if (rgbmode) {
  63. #if 0
  64.                             glColor3ub(0x30, 0x40, 0xb0);
  65. #else
  66.                             glColor3f(1.0f, 1.0f, 1.0f);
  67. #endif
  68.                         }
  69. glDisable(GL_CULL_FACE);
  70. glDisable(GL_DEPTH_TEST);
  71. /*texenv(2);*/
  72. drawclouds(vdata_ptr);
  73. glEnable(GL_DEPTH_TEST);
  74. glEnable(GL_CULL_FACE);
  75. flagsptr += 1;
  76. break;
  78. case PD_PAPER_PLANE_MODE:
  79. switch (*(flagsptr + 1)) {
  80. case PLANES_START:
  81.                             glShadeModel(GL_FLAT);
  82.                             glEnable(GL_LIGHTING);
  83.                             glDisable(GL_TEXTURE_2D);
  84.                             if (fog && !rgbmode)
  85.                                 glDisable(GL_FOG);
  86.                             break;
  87. case PLANES_END:
  88.                             glShadeModel(GL_SMOOTH);
  89.                             glDisable(GL_LIGHTING);
  90.                             if (fog && !rgbmode && FOG_LEVELS > 1)
  91.                                 glEnable(GL_FOG);
  92.                             break;
  93.                         }
  94. flagsptr += 2;
  95. break;
  97. case PD_PAPER_PLANE_POS:        /* contains the pushmatrix */
  98. glPushMatrix();
  99. glTranslatef(*(vdata_ptr), *(vdata_ptr + 1), *(vdata_ptr + 2));
  100. glRotatef(*(vdata_ptr + 3), 0.0, 0.0, 1.0);
  101. glRotatef(*(vdata_ptr + 4), 0.0, 1.0, 0.0);
  102. glRotatef(*(vdata_ptr + 5), 1.0, 0.0, 0.0);
  103. flagsptr += 1;
  104. break;
  106. case PD_VIEWER_POS:
  107. glLoadIdentity();
  108. glRotatef(-90., 1.0, 0., 0.);
  109. glRotatef(*(vdata_ptr + 3) * RAD_TO_DEG, 0.0, 0.0, 1.0); /* yaw */
  110. lightpos();
  111. glTranslatef(-*(vdata_ptr), -*(vdata_ptr + 1), -*(vdata_ptr + 2));
  112. flagsptr += 1;
  113. break;
  115. case PD_TEXTURE_BIND:
  116. glBindTexture(GL_TEXTURE_2D, *(flagsptr + 1));
  117. texenv(*(flagsptr + 1));
  118. glEnable(GL_TEXTURE_2D);
  119. flagsptr += 2;
  120. break;
  122. case PD_END:
  123. return;
  125. default:
  126. fprintf(stderr, "Bad PD primitive %dn", *flagsptr);
  127. flagsptr++;
  128. break;
  129. }
  130. }
  131. }
  133. /*
  134.  * Notice how the following routines unwind loops and pre-compute indexes
  135.  * at compile time. This is crucial in obtaining the maximum data transfer 
  136.  * from cpu to the graphics pipe.
  137.  */
  138. static void drawlitmesh_11(float *op)
  139. {
  140.     glBegin(GL_TRIANGLE_STRIP);
  141.     /* one */
  142.     glNormal3fv((op + PD_V_NORMAL));
  143.     glVertex3fv((op + PD_V_POINT));
  144.     /* two */
  145.     glNormal3fv((op + (PD_V_SIZE + PD_V_NORMAL)));
  146.     glVertex3fv((op + (PD_V_SIZE + PD_V_POINT)));
  147.     /* three */
  148.     glNormal3fv((op + (2 * PD_V_SIZE + PD_V_NORMAL)));
  149.     glVertex3fv((op + (2 * PD_V_SIZE + PD_V_POINT)));
  150.     /* four */
  151.     glNormal3fv((op + (3 * PD_V_SIZE + PD_V_NORMAL)));
  152.     glVertex3fv((op + (3 * PD_V_SIZE + PD_V_POINT)));
  153.     /* five */
  154.     glNormal3fv((op + (4 * PD_V_SIZE + PD_V_NORMAL)));
  155.     glVertex3fv((op + (4 * PD_V_SIZE + PD_V_POINT)));
  156.     /* six */
  157.     glNormal3fv((op + (5 * PD_V_SIZE + PD_V_NORMAL)));
  158.     glVertex3fv((op + (5 * PD_V_SIZE + PD_V_POINT)));
  159.     /* seven */
  160.     glNormal3fv((op + (6 * PD_V_SIZE + PD_V_NORMAL)));
  161.     glVertex3fv((op + (6 * PD_V_SIZE + PD_V_POINT)));
  162.     /* eight */
  163.     glNormal3fv((op + (7 * PD_V_SIZE + PD_V_NORMAL)));
  164.     glVertex3fv((op + (7 * PD_V_SIZE + PD_V_POINT)));
  165.     /* nine */
  166.     glNormal3fv((op + (8 * PD_V_SIZE + PD_V_NORMAL)));
  167.     glVertex3fv((op + (8 * PD_V_SIZE + PD_V_POINT)));
  168.     /* ten */
  169.     glNormal3fv((op + (9 * PD_V_SIZE + PD_V_NORMAL)));
  170.     glVertex3fv((op + (9 * PD_V_SIZE + PD_V_POINT)));
  171.     /* eleven */
  172.     glNormal3fv((op + (10 * PD_V_SIZE + PD_V_NORMAL)));
  173.     glVertex3fv((op + (10 * PD_V_SIZE + PD_V_POINT)));
  175. glEnd();
  177. }
  179. static void drawcolrtexmesh_10(float *op)
  180. {
  181.     glBegin(GL_TRIANGLE_STRIP);
  182. /* one */
  183.     glTexCoord2fv((op + PD_V_TEX));
  184.     glColor3fv((op + PD_V_COLOR));
  185.     glVertex3fv((op + PD_V_POINT));
  186.     /* two */
  187.     glTexCoord2fv((op + (PD_V_SIZE + PD_V_TEX)));
  188.     glColor3fv((op + (PD_V_SIZE + PD_V_COLOR)));
  189.     glVertex3fv((op + (PD_V_SIZE + PD_V_POINT)));
  190.     /* three */
  191.     glTexCoord2fv((op + (2 * PD_V_SIZE + PD_V_TEX)));
  192.     glColor3fv((op + (2 * PD_V_SIZE + PD_V_COLOR)));
  193.     glVertex3fv((op + (2 * PD_V_SIZE + PD_V_POINT)));
  194.     /* four */
  195.     glTexCoord2fv((op + (3 * PD_V_SIZE + PD_V_TEX)));
  196.     glColor3fv((op + (3 * PD_V_SIZE + PD_V_COLOR)));
  197.     glVertex3fv((op + (3 * PD_V_SIZE + PD_V_POINT)));
  198.     /* five */
  199.     glTexCoord2fv((op + (4 * PD_V_SIZE + PD_V_TEX)));
  200.     glColor3fv((op + (4 * PD_V_SIZE + PD_V_COLOR)));
  201.     glVertex3fv((op + (4 * PD_V_SIZE + PD_V_POINT)));
  202.     /* six */
  203.     glTexCoord2fv((op + (5 * PD_V_SIZE + PD_V_TEX)));
  204.     glColor3fv((op + (5 * PD_V_SIZE + PD_V_COLOR)));
  205.     glVertex3fv((op + (5 * PD_V_SIZE + PD_V_POINT)));
  206.     /* seven */
  207.     glTexCoord2fv((op + (6 * PD_V_SIZE + PD_V_TEX)));
  208.     glColor3fv((op + (6 * PD_V_SIZE + PD_V_COLOR)));
  209.     glVertex3fv((op + (6 * PD_V_SIZE + PD_V_POINT)));
  210.     /* eight */
  211.     glTexCoord2fv((op + (7 * PD_V_SIZE + PD_V_TEX)));
  212.     glColor3fv((op + (7 * PD_V_SIZE + PD_V_COLOR)));
  213.     glVertex3fv((op + (7 * PD_V_SIZE + PD_V_POINT)));
  214.     /* nine */
  215.     glTexCoord2fv((op + (8 * PD_V_SIZE + PD_V_TEX)));
  216.     glColor3fv((op + (8 * PD_V_SIZE + PD_V_COLOR)));
  217.     glVertex3fv((op + (8 * PD_V_SIZE + PD_V_POINT)));
  218.     /* ten */
  219.     glTexCoord2fv((op + (9 * PD_V_SIZE + PD_V_TEX)));
  220.     glColor3fv((op + (9 * PD_V_SIZE + PD_V_COLOR)));
  221.     glVertex3fv((op + (9 * PD_V_SIZE + PD_V_POINT)));
  223.     glEnd();
  224. }
  226. static void drawclouds(float *op)
  227. {
  228. #define SKY_STRIPS 24
  230. /* Break into quad strips so cheap fog works better */
  231. if (0 == clouds) {
  233.         GLfloat *vc0, *vc1, *vc2;
  234.         GLfloat *tc0, *tc1, *tc2;
  235.         GLfloat sky_s0, sky_s1, sky_t0, sky_t1;
  236.         GLfloat sky_x0, sky_x1, sky_y0, sky_y1, sky_z;
  237.         int ii, jj;
  238.         GLfloat s0, s1, t0, t1;
  239.         GLfloat x0, x1, y0, y1, z0;
  241.         vc0 = op + PD_V_POINT;
  242.         vc1 = op + PD_V_POINT + PD_V_SIZE;
  243.         vc2 = op + PD_V_POINT + PD_V_SIZE * 2;
  245.         tc0 = op + PD_V_TEX;
  246.         tc1 = op + PD_V_TEX + PD_V_SIZE;
  247.         tc2 = op + PD_V_TEX + PD_V_SIZE * 2;
  249.         sky_s0 = tc0[0];
  250.         sky_s1 = tc1[0];
  251.         sky_t0 = tc0[1];
  252.         sky_t1 = tc2[1];
  254.         sky_x0 = vc0[0];
  255.         sky_x1 = vc1[0];
  256.         sky_y0 = vc0[1];
  257.         sky_y1 = vc2[1];
  258.         sky_z  = vc0[2];
  260.         clouds = glGenLists(1);
  262.         glNewList(clouds, GL_COMPILE);
  264.         s1 = (1.0f / SKY_STRIPS) * (sky_s1 - sky_s0);
  265.         t1 = (1.0f / SKY_STRIPS) * (sky_t1 - sky_t0);
  266.         x1 = (1.0f / SKY_STRIPS) * (sky_x1 - sky_x0);
  267.         y1 = (1.0f / SKY_STRIPS) * (sky_y1 - sky_y0);
  269.         z0 = sky_z;
  270.         s0 = sky_s0;
  271.         x0 = sky_x0;
  273.         for (ii = 0; ii < SKY_STRIPS; ii++, s0 += s1, x0 += x1) {
  275.             t0 = sky_t0;
  276.             y0 = sky_y0;
  278.             glBegin(GL_QUAD_STRIP);
  280.             glTexCoord2f(s0, t0);
  281.             glVertex3f(x0, y0, z0);
  283.             glTexCoord2f(s0 + s1, t0);
  284.             glVertex3f(x0 + x1, y0, z0);
  286.             for (jj = 0; jj < SKY_STRIPS; jj++, t0 += t1, y0 += y1) {
  288.                 glTexCoord2f(s0 + s1, t0 + t1);
  289.                 glVertex3f(x0 + x1, y0 + y1, z0);
  291.                 glTexCoord2f(s0, t0 + t1);
  292.                 glVertex3f(x0, y0 + y1, z0);
  293.             }
  295.             glEnd();
  297.         }
  299.         glEndList();
  300.     }
  302. glCallList(clouds);
  303. }
  305. void putv3fdata(float *v, perfobj_vert_t *ptr)
  306. {
  307.   ptr->vert[0] = v[0];
  308.   ptr->vert[1] = v[1];
  309.   ptr->vert[2] = v[2];
  310. }
  312. void putc3fdata(float *c, perfobj_vert_t *ptr)
  313. {
  314.   ptr->color[0] = c[0];
  315.   ptr->color[1] = c[1];
  316.   ptr->color[2] = c[2];
  317. }
  319. void putn3fdata(float *n, perfobj_vert_t *ptr)
  320. {
  321.   ptr->normal[0] = n[0];
  322.   ptr->normal[1] = n[1];
  323.   ptr->normal[2] = n[2];
  324. }
  326. void putt2fdata(float *t, perfobj_vert_t *ptr)
  327. {
  328.   ptr->texture[0] = t[0];
  329.   ptr->texture[1] = t[1];
  330. }