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

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

GIS编程

开发平台：

Visual C++

terrain.c：源码内容
  1. /*
  2.  * This program is under the GNU GPL.
  3.  * Use at your own risk.
  4.  *
  5.  * written by David Bucciarelli (tech.hmw@plus.it)
  6.  *            Humanware s.r.l.
  7.  *
  8.  * based on a Mikael SkiZoWalker's (MoDEL) / France (Skizo@Hol.Fr) demo
  9.  */
  11. #include <stdio.h>
  12. #include <math.h>
  13. #include <string.h>
  14. #include <stdlib.h>
  15. #include <time.h>
  17. #ifdef _WIN32
  18. #include <windows.h>
  19. #endif
  21. #include <GL/glut.h>
  23. #ifndef M_PI
  24. #define M_PI 3.14159265
  25. #endif
  27. #define heightMnt 450
  28. #define lenghtXmnt 62
  29. #define lenghtYmnt 62
  31. #define stepXmnt     96.0
  32. #define stepYmnt     96.0
  34. #define WIDTH 640
  35. #define HEIGHT 480
  37. #define TSCALE 4
  39. #define FRAME 50
  41. #define FOV 85
  43. static GLfloat terrain[256*256];
  44. static GLfloat terraincolor[256*256][3];
  46. static int fog=1;
  47. static int bfcull=1;
  48. static int usetex=1;
  49. static int poutline=0;
  50. static int help=1;
  51. static int joyavailable=0;
  52. static int joyactive=0;
  53. static long GlobalMnt=0;
  55. static int scrwidth=WIDTH;
  56. static int scrheight=HEIGHT;
  58. #define OBSSTARTX 992.0
  59. #define OBSSTARTY 103.0
  61. static float obs[3]={OBSSTARTX,heightMnt*1.3,OBSSTARTY};
  62. static float dir[3],v1[2],v2[2];
  63. static float v=0.0;
  64. static float alpha=75.0;
  65. static float beta=90.0;
  67. static float gettime(void)
  68. {
  69.   static clock_t told=0;
  70.   clock_t tnew,ris;
  72.   tnew=clock();
  74.   ris=tnew-told;
  76.   told=tnew;
  78.   return(ris/(float)CLOCKS_PER_SEC);
  79. }
  81. static void calcposobs(void)
  82. {
  83.   float alpha1,alpha2;
  85.   dir[0]=sin(alpha*M_PI/180.0);
  86.   dir[2]=cos(alpha*M_PI/180.0)*sin(beta*M_PI/180.0);
  87.   dir[1]=cos(beta*M_PI/180.0);
  89.   alpha1=alpha+FOV/2.0;
  90.   v1[0]=sin(alpha1*M_PI/180.0);
  91.   v1[1]=cos(alpha1*M_PI/180.0);
  93.   alpha2=alpha-FOV/2.0;
  94.   v2[0]=sin(alpha2*M_PI/180.0);
  95.   v2[1]=cos(alpha2*M_PI/180.0);
  96.   
  97.   obs[0]+=v*dir[0];
  98.   obs[1]+=v*dir[1];
  99.   obs[2]+=v*dir[2];
  101.   if(obs[1]<0.0)
  102.     obs[1]=0.0;
  103. }
  105. static void reshape( int width, int height )
  106. {
  107.   scrwidth=width;
  108.   scrheight=height;
  109.   glViewport(0, 0, (GLint)width, (GLint)height);
  110.   glMatrixMode(GL_PROJECTION);
  111.   glLoadIdentity();
  112.   gluPerspective(50.0, ((GLfloat) width/(GLfloat)height), lenghtXmnt*stepYmnt*0.01,
  113.  lenghtXmnt*stepYmnt*0.7);
  114.   glMatrixMode(GL_MODELVIEW);
  115.   glLoadIdentity();
  116. }
  118. int clipstrip(float y, float *start, float *end)
  119. {
  120.   float x1,x2,t1,t2,tmp;
  122.   if(v1[1]==0.0) {
  123.     t1=0.0;
  124.     x1=-HUGE_VAL;
  125.   } else {
  126.     t1=y/v1[1];
  127.     x1=t1*v1[0];
  128.   }
  130.   if(v2[1]==0.0) {
  131.     t2=0.0;
  132.     x2=HUGE_VAL;
  133.   } else {
  134.     t2=y/v2[1];
  135.     x2=t2*v2[0];
  136.   }
  138.   if(((x1<-(lenghtXmnt*stepXmnt)/2) && (t2<=0.0)) ||
  139.      ((t1<=0.0) && (x2>(lenghtXmnt*stepXmnt)/2)) ||
  140.      ((t1<0.0) && (t2<0.0)))
  141.     return 0;
  143.   if((t1==0.0) && (t2==0.0)) {
  144.     if((v1[0]<0.0) && (v1[1]>0.0) && (v2[0]<0.0) && (v2[1]<0.0)) {
  145.       *start=-(lenghtXmnt*stepXmnt)/2;
  146.       *end=stepXmnt;
  147.       return 1;
  148.     } else {
  149.       if((v1[0]>0.0) && (v1[1]<0.0) && (v2[0]>0.0) && (v2[1]>0.0)) {
  150. *start=-stepXmnt;
  151. *end=(lenghtXmnt*stepXmnt)/2;
  152. return 1;
  153.       } else
  154. return 0;
  155.     }
  156.   } else {
  157.     if(t2<0.0) {
  158.       if(x1<0.0)
  159. x2=-(lenghtXmnt*stepXmnt)/2;
  160.       else
  161. x2=(lenghtXmnt*stepXmnt)/2;
  162.     }
  164.     if(t1<0.0) {
  165.       if(x2<0.0)
  166. x1=-(lenghtXmnt*stepXmnt)/2;
  167.       else
  168. x1=(lenghtXmnt*stepXmnt)/2;
  169.     }
  170.   }
  172.   if(x1>x2) {
  173.     tmp=x1;
  174.     x1=x2;
  175.     x2=tmp;
  176.   }
  178.   x1-=stepXmnt;
  179.   if(x1<-(lenghtXmnt*stepXmnt)/2)
  180.     x1=-(lenghtXmnt*stepXmnt)/2;
  182.   x2+=stepXmnt;
  183.   if(x2>(lenghtXmnt*stepXmnt)/2)
  184.     x2=(lenghtXmnt*stepXmnt)/2;
  186.   *start=((int)(x1/stepXmnt))*stepXmnt;
  187.   *end=((int)(x2/stepXmnt))*stepXmnt;
  189.   return 1;
  190. }
  192. static void printstring(void *font, char *string)
  193. {
  194.   int len,i;
  196.   len=(int)strlen(string);
  197.   for(i=0;i<len;i++)
  198.     glutBitmapCharacter(font,string[i]);
  199. }
  201. static void printhelp(void)
  202. {
  203.   glEnable(GL_BLEND);
  204.   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  205.   glColor4f(0.0,0.0,0.0,0.5);
  206.   glRecti(40,40,600,440);
  207.   glDisable(GL_BLEND);
  209.   glColor3f(1.0,0.0,0.0);
  210.   glRasterPos2i(300,420);
  211.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"Help");
  213.   glRasterPos2i(60,390);
  214.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"h - Togle Help");
  215.   glRasterPos2i(60,360);
  216.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"t - Togle Textures");
  217.   glRasterPos2i(60,330);
  218.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"f - Togle Fog");
  219.   glRasterPos2i(60,300);
  220.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"p - Wire frame");
  221.   glRasterPos2i(60,270);
  222.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"b - Togle Back face culling");
  223.   glRasterPos2i(60,240);
  224.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"Arrow Keys - Rotate");
  225.   glRasterPos2i(60,210);
  226.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"a - Increase velocity");
  227.   glRasterPos2i(60,180);
  228.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"z - Decrease velocity");
  230.   glRasterPos2i(60,150);
  231.   if(joyavailable)
  232.     printstring(GLUT_BITMAP_TIMES_ROMAN_24,"j - Togle jostick control (Joystick control available)");
  233.   else
  234.     printstring(GLUT_BITMAP_TIMES_ROMAN_24,"(No Joystick control available)");
  235. }
  237. void drawterrain(void)
  238. {
  239.   int h,i,idx,ox,oy;
  240.   float j,k,start,end;
  242.   ox=(int)(obs[0]/stepXmnt);
  243.   oy=(int)(obs[2]/stepYmnt);
  244.   GlobalMnt=((ox*TSCALE)&255)+((oy*TSCALE)&255)*256;
  246.   glPushMatrix();
  247.   glTranslatef((float)ox*stepXmnt,0,(float)oy*stepYmnt);
  249.   for(h=0,k=-(lenghtYmnt*stepYmnt)/2;h<lenghtYmnt;k+=stepYmnt,h++) {
  250.     if(!clipstrip(k,&start,&end))
  251.       continue;
  253.     glBegin(GL_TRIANGLE_STRIP); /* I hope that the optimizer will be able to improve this code */
  254.     for(i=(int)(lenghtXmnt/2+start/stepXmnt),j=start;j<=end;j+=stepXmnt,i++) {
  255.       idx=(i*TSCALE+h*256*TSCALE+GlobalMnt)&65535;
  256.       glColor3fv(terraincolor[idx]);
  257.       glTexCoord2f((ox+i)/8.0,(oy+h)/8.0);
  258.       glVertex3f(j,terrain[idx],k);
  260.       idx=(i*TSCALE+h*256*TSCALE+256*TSCALE+GlobalMnt)&65535; 
  261.       glColor3fv(terraincolor[idx]);
  262.       glTexCoord2f((ox+i)/8.0,(oy+h+1)/8.0);
  263.       glVertex3f(j,terrain[idx],k+stepYmnt);
  264.     }
  265.     glEnd();
  266.   }
  268.   glDisable(GL_CULL_FACE);
  269.   glDisable(GL_TEXTURE_2D);
  270.   glEnable(GL_BLEND);
  271.   glBegin(GL_QUADS);
  272.   glColor4f(0.1,0.7,1.0,0.4);
  273.   glVertex3f(-(lenghtXmnt*stepXmnt)/2.0,heightMnt*0.6,-(lenghtYmnt*stepYmnt)/2.0);
  274.   glVertex3f(-(lenghtXmnt*stepXmnt)/2.0,heightMnt*0.6,(lenghtYmnt*stepYmnt)/2.0);
  275.   glVertex3f((lenghtXmnt*stepXmnt)/2.0,heightMnt*0.6,(lenghtYmnt*stepYmnt)/2.0);
  276.   glVertex3f((lenghtXmnt*stepXmnt)/2.0,heightMnt*0.6,-(lenghtYmnt*stepYmnt)/2.0);
  277.   glEnd();
  278.   glDisable(GL_BLEND);
  279.   if(bfcull)
  280.     glEnable(GL_CULL_FACE);
  281.   glEnable(GL_TEXTURE_2D);
  283.   glPopMatrix();
  285. }
  287. static void dojoy(void)
  288. {
  289. #ifdef _WIN32
  290.   static UINT max[2]={0,0};
  291.   static UINT min[2]={0xffffffff,0xffffffff},center[2];
  292.   MMRESULT res;
  293.   JOYINFO joy;
  295.   res=joyGetPos(JOYSTICKID1,&joy);
  297.   if(res==JOYERR_NOERROR) {
  298.     joyavailable=1;
  300.     if(max[0]<joy.wXpos)
  301.       max[0]=joy.wXpos;
  302.     if(min[0]>joy.wXpos)
  303.       min[0]=joy.wXpos;
  304.     center[0]=(max[0]+min[0])/2;
  306.     if(max[1]<joy.wYpos)
  307.       max[1]=joy.wYpos;
  308.     if(min[1]>joy.wYpos)
  309.       min[1]=joy.wYpos;
  310.     center[1]=(max[1]+min[1])/2;
  312.     if(joyactive) {
  313.       if(fabs(center[0]-(float)joy.wXpos)>0.1*(max[0]-min[0]))
  314. alpha+=2.5*(center[0]-(float)joy.wXpos)/(max[0]-min[0]);
  315.       if(fabs(center[1]-(float)joy.wYpos)>0.1*(max[1]-min[1]))
  316. beta+=2.5*(center[1]-(float)joy.wYpos)/(max[1]-min[1]);
  318.       if(joy.wButtons & JOY_BUTTON1)
  319. v+=0.5;
  320.       if(joy.wButtons & JOY_BUTTON2)
  321. v-=0.5;
  322.     }
  323.   } else
  324.     joyavailable=0;
  325. #endif
  326. }
  328. void drawscene(void)
  329. {
  330.   static int count=0;
  331.   static char frbuf[80];
  332.   float fr;
  334.   dojoy();
  336.   glShadeModel(GL_SMOOTH);
  337.   glEnable(GL_DEPTH_TEST);
  339.   if(usetex)
  340.     glEnable(GL_TEXTURE_2D);
  341.   else
  342.     glDisable(GL_TEXTURE_2D);
  344.   if(fog)
  345.     glEnable(GL_FOG);
  346.   else
  347.     glDisable(GL_FOG);
  349.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  351.   glPushMatrix();
  353.   calcposobs();
  354.   gluLookAt(obs[0],obs[1],obs[2],
  355.     obs[0]+dir[0],obs[1]+dir[1],obs[2]+dir[2],
  356.     0.0,1.0,0.0);
  358.   drawterrain();
  359.   glPopMatrix();
  361.   if((count % FRAME)==0) {
  362.     fr=gettime();
  363.     sprintf(frbuf,"Frame rate: %.3f",FRAME/fr);
  364.   }
  366.   glDisable(GL_TEXTURE_2D);
  367.   glDisable(GL_DEPTH_TEST);
  368.   glDisable(GL_FOG);
  369.   glShadeModel(GL_FLAT);
  371.   glMatrixMode(GL_PROJECTION);
  372.   glLoadIdentity();
  373.   glOrtho(-0.5,639.5,-0.5,479.5,-1.0,1.0);
  374.   glMatrixMode(GL_MODELVIEW);
  375.   glLoadIdentity();
  377.   glColor3f(1.0,0.0,0.0);
  378.   glRasterPos2i(10,10);
  379.   printstring(GLUT_BITMAP_HELVETICA_18,frbuf);
  380.   glRasterPos2i(350,470);
  381.   printstring(GLUT_BITMAP_HELVETICA_10,"Terrain V1.2 Written by David Bucciarelli (tech.hmw@plus.it)");
  382.   glRasterPos2i(434,457);
  383.   printstring(GLUT_BITMAP_HELVETICA_10,"Based on a Mickael's demo (Skizo@Hol.Fr)");
  385.   if(help)
  386.     printhelp();
  388.   reshape(scrwidth,scrheight);
  390.   glutSwapBuffers();
  392.   count++;
  393. }
  395. /* ARGSUSED1 */
  396. static void key(unsigned char k, int x, int y)
  397. {
  398.   switch (k) {
  399.   case 27:
  400.     exit(0);
  401.     break;
  402.   case 'a':
  403.     v+=0.5;
  404.     break;
  405.   case 'z':
  406.     v-=0.5;
  407.     break;
  408.   case 'p':
  409.     if(poutline) {
  410.       glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  411.       poutline=0;
  412.     } else {
  413.       glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  414.       poutline=1;
  415.     }
  416.     break;
  417.   case 'j':
  418.     joyactive=(!joyactive);
  419.     break;
  420.   case 'h':
  421.     help=(!help);
  422.     break;
  423.   case 'f':
  424.     fog=(!fog);
  425.     break;
  426.   case 't':
  427.     usetex=(!usetex);
  428.     break;
  429.   case 'b':
  430.     if(bfcull) {
  431.       glDisable(GL_CULL_FACE);
  432.       bfcull=0;
  433.     } else {
  434.       glEnable(GL_CULL_FACE);
  435.       bfcull=1;
  436.     }
  437.     break;
  438.   }
  439. }
  441. /* ARGSUSED1 */
  442. static void special(int k, int x, int y)
  443. {
  444.   switch(k) {
  445.   case GLUT_KEY_LEFT:
  446.     alpha+=2.0;
  447.     break;
  448.   case GLUT_KEY_RIGHT:
  449.     alpha-=2.0;
  450.     break;
  451.   case GLUT_KEY_DOWN:
  452.     beta-=2.0;
  453.     break;
  454.   case GLUT_KEY_UP:
  455.     beta+=2.0;
  456.     break;
  457.   }
  458. }
  460. static void calccolor(GLfloat height, GLfloat c[3])
  461. {
  462.   GLfloat color[4][3]={
  463.     {1.0,1.0,1.0},
  464.     {0.0,0.8,0.0},
  465.     {1.0,1.0,0.3},
  466.     {0.0,0.0,0.8}
  467.   };
  468.   GLfloat fact;
  470.   height=height*(1.0/255.0);
  472.   if(height>=0.9) {
  473.     c[0]=color[0][0]; c[1]=color[0][1]; c[2]=color[0][2];
  474.     return;
  475.   }
  477.   if((height<0.9) && (height>=0.7)) {
  478.     fact=(height-0.7)*5.0;
  479.     c[0]=fact*color[0][0]+(1.0-fact)*color[1][0];
  480.     c[1]=fact*color[0][1]+(1.0-fact)*color[1][1];
  481.     c[2]=fact*color[0][2]+(1.0-fact)*color[1][2];
  482.     return;
  483.   }
  485.   if((height<0.7) && (height>=0.6)) {
  486.     fact=(height-0.6)*10.0;
  487.     c[0]=fact*color[1][0]+(1.0-fact)*color[2][0];
  488.     c[1]=fact*color[1][1]+(1.0-fact)*color[2][1];
  489.     c[2]=fact*color[1][2]+(1.0-fact)*color[2][2];
  490.     return;
  491.   }
  493.   if((height<0.6) && (height>=0.5)) {
  494.     fact=(height-0.5)*10.0;
  495.     c[0]=fact*color[2][0]+(1.0-fact)*color[3][0];
  496.     c[1]=fact*color[2][1]+(1.0-fact)*color[3][1];
  497.     c[2]=fact*color[2][2]+(1.0-fact)*color[3][2];
  498.     return;
  499.   }
  501.   c[0]=color[3][0]; c[1]=color[3][1]; c[2]=color[3][2];
  502. }
  504. static void loadpic (void)
  505. {
  506.   GLubyte bufferter[256*256],terrainpic[256*256];
  507.   FILE *FilePic;
  508.   int i,tmp;
  509.   GLenum gluerr;
  511.   if((FilePic=fopen("mnt.bin","r"))==NULL) {
  512.     fprintf(stderr,"Error loading Mnt.binn");
  513.     exit(-1);
  514.   }
  515.   fread(bufferter , 256*256 , 1 , FilePic);
  516.   fclose(FilePic);
  518.   for (i=0;i<(256*256);i++) {
  519.     terrain[i]=(bufferter[i]*(heightMnt/255.0f));
  520.     calccolor((GLfloat)bufferter[i],terraincolor[i]);
  521.     tmp=(((int)bufferter[i])+96);
  522.     terrainpic[i]=(tmp>255) ? 255 : tmp;
  523.   }
  525.   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  526.   if((gluerr=gluBuild2DMipmaps(GL_TEXTURE_2D, 1, 256, 256, GL_LUMINANCE,
  527.        GL_UNSIGNED_BYTE, (GLvoid *)(&terrainpic[0])))) {
  528.     fprintf(stderr,"GLULib%sn",gluErrorString(gluerr));
  529.     exit(-1);
  530.   }
  532.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  533.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  535.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_LINEAR);
  536.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  538.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
  539.   glEnable(GL_TEXTURE_2D);
  540. }
  542. static void init( void )
  543. {
  544.   float fogcolor[4]={0.6,0.7,0.7,1.0};
  546.   glClearColor(fogcolor[0],fogcolor[1],fogcolor[2],fogcolor[3]);
  547.   glClearDepth(1.0);
  548.   glDepthFunc(GL_LEQUAL);
  549.   glShadeModel(GL_SMOOTH);
  550.   glEnable(GL_DEPTH_TEST);
  551.   glEnable(GL_CULL_FACE);
  553.   glDisable(GL_BLEND);
  554.   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  556.   glEnable(GL_FOG);
  557.   glFogi(GL_FOG_MODE,GL_EXP2);
  558.   glFogfv(GL_FOG_COLOR,fogcolor);
  559.   glFogf(GL_FOG_DENSITY,0.0007);
  560. #ifdef FX
  561.   glHint(GL_FOG_HINT,GL_NICEST);
  562. #endif
  564.   reshape(scrwidth,scrheight);
  565. }
  568. int main(int ac, char **av)
  569. {
  570.   glutInitWindowPosition(0,0);
  571.   glutInitWindowSize(WIDTH,HEIGHT);
  572.   glutInit(&ac,av);
  574.   glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
  576.   glutCreateWindow("Terrain");
  578.   loadpic();
  580.   init();
  582. #ifndef FX
  583.   glDisable(GL_TEXTURE_2D);
  584.   usetex=0;
  585. #endif
  587.   glutReshapeFunc(reshape);
  588.   glutDisplayFunc(drawscene);
  589.   glutKeyboardFunc(key);
  590.   glutSpecialFunc(special);
  591.   glutIdleFunc(drawscene);
  593.   glutMainLoop();
  595.   return 0;             /* ANSI C requires main to return int. */
  596. }