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

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

GIS编程

开发平台：

Visual C++

ray.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.  */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <math.h>
  14. #ifdef _WIN32
  15. #include <windows.h>
  16. #endif
  18. #include <GL/glut.h>
  20. #if defined(GL_VERSION_1_1)
  21. /* Routines called directly. */
  22. #elif defined(GL_EXT_texture_object) && defined(GL_EXT_copy_texture) && defined(GL_EXT_subtexture)
  23. #define glBindTexture(A,B)     glBindTextureEXT(A,B)
  24. #define glGenTextures(A,B)     glGenTexturesEXT(A,B)
  25. #define glTexSubImage2D(A,B,C,D,E,F,G,H,I) glTexSubImage2DEXT(A,B,C,D,E,F,G,H,I)
  26. #else
  27. #define glBindTexture(A,B)
  28. #define glGenTextures(A,B)
  29. #define glTexSubImage2D(A,B,C,D,E,F,G,H,I)
  30. #endif
  32. static int WIDTH=640;
  33. static int HEIGHT=480;
  35. #define FRAME 50
  37. #define BASESIZE 7.5f
  38. #define SPHERE_RADIUS 0.75f
  40. #define TEX_CHECK_WIDTH 256
  41. #define TEX_CHECK_HEIGHT 256
  42. #define TEX_CHECK_SLOT_SIZE (TEX_CHECK_HEIGHT/16)
  43. #define TEX_CHECK_NUMSLOT (TEX_CHECK_HEIGHT/TEX_CHECK_SLOT_SIZE)
  45. #define TEX_REFLECT_WIDTH 256
  46. #define TEX_REFLECT_HEIGHT 256
  47. #define TEX_REFLECT_SLOT_SIZE (TEX_REFLECT_HEIGHT/16)
  48. #define TEX_REFLECT_NUMSLOT (TEX_REFLECT_HEIGHT/TEX_REFLECT_SLOT_SIZE)
  50. /* Some <math.h> files do not define M_PI... */
  51. #ifndef M_PI
  52. #define M_PI 3.14159265358979323846
  53. #endif
  55. #define EPSILON 0.0001
  57. #define clamp255(a)  ( (a)<(0.0f) ? (0.0f) : ((a)>(255.0f) ? (255.0f) : (a)) )
  59. #define fabs(x) ((x)<0.0f?-(x):(x))
  61. #define vequ(a,b) { (a)[0]=(b)[0]; (a)[1]=(b)[1]; (a)[2]=(b)[2]; }
  62. #define vsub(a,b,c) { (a)[0]=(b)[0]-(c)[0]; (a)[1]=(b)[1]-(c)[1]; (a)[2]=(b)[2]-(c)[2]; }
  63. #define dprod(a,b) ((a)[0]*(b)[0]+(a)[1]*(b)[1]+(a)[2]*(b)[2])
  64. #define vnormalize(a,b) { 
  65.   register float m_norm; 
  66.   m_norm=sqrt((double)dprod((a),(a))); 
  67.   (a)[0] /=m_norm; 
  68.   (a)[1] /=m_norm; 
  69.   (a)[2] /=m_norm; }
  71. static GLubyte checkmap[TEX_CHECK_HEIGHT][TEX_CHECK_WIDTH][3];
  72. static GLuint checkid;
  73. static int checkmap_currentslot=0;
  75. static GLubyte reflectmap[TEX_REFLECT_HEIGHT][TEX_REFLECT_WIDTH][3];
  76. static GLuint reflectid;
  77. static int reflectmap_currentslot=0;
  79. static GLuint lightdlist;
  80. static GLuint objdlist;
  82. static float lightpos[3]={2.1,2.1,2.8};
  83. static float objpos[3]={0.0,0.0,1.0};
  85. static float sphere_pos[TEX_CHECK_HEIGHT][TEX_REFLECT_WIDTH][3];
  87. static float fogcolor[4]={0.05,0.05,0.05,1.0};
  89. static float obs[3]={7.0,0.0,2.0};
  90. static float dir[3];
  91. static float v=0.0;
  92. static float alpha=-90.0;
  93. static float beta=90.0;
  95. static int fog=1;
  96. static int bfcull=1;
  97. static int poutline=0;
  98. static int help=1;
  99. static int showcheckmap=1;
  100. static int showreflectmap=1;
  101. static int joyavailable=0;
  102. static int joyactive=0;
  104. static float gettime(void)
  105. {
  106.   static float told=0.0f;
  107.   float tnew,ris;
  109.   tnew=glutGet(GLUT_ELAPSED_TIME);
  111.   ris=tnew-told;
  113.   told=tnew;
  115.   return ris/1000.0;
  116. }
  118. static void calcposobs(void)
  119. {
  120.   dir[0]=sin(alpha*M_PI/180.0);
  121.   dir[1]=cos(alpha*M_PI/180.0)*sin(beta*M_PI/180.0);
  122.   dir[2]=cos(beta*M_PI/180.0);
  124.   obs[0]+=v*dir[0];
  125.   obs[1]+=v*dir[1];
  126.   obs[2]+=v*dir[2];
  127. }
  129. /* ARGSUSED1 */
  130. static void special(int k, int x, int y)
  131. {
  132.   switch(k) {
  133.   case GLUT_KEY_LEFT:
  134.     alpha-=2.0;
  135.     break;
  136.   case GLUT_KEY_RIGHT:
  137.     alpha+=2.0;
  138.     break;
  139.   case GLUT_KEY_DOWN:
  140.     beta-=2.0;
  141.     break;
  142.   case GLUT_KEY_UP:
  143.     beta+=2.0;
  144.     break;
  145.   }
  146. }
  148. /* ARGSUSED1 */
  149. static void key(unsigned char k, int x, int y)
  150. {
  151.   switch(k) {
  152.   case 27:
  153.     exit(0);
  154.     break;
  156.   case 's':
  157.     lightpos[1]-=0.1;
  158.     break;
  159.   case 'd':
  160.     lightpos[1]+=0.1;
  161.     break;
  162.   case 'e':
  163.     lightpos[0]-=0.1;
  164.     break;
  165.   case 'x':
  166.     lightpos[0]+=0.1;
  167.     break;
  168.   case 'w':
  169.     lightpos[2]-=0.1;
  170.     break;
  171.   case 'r':
  172.     lightpos[2]+=0.1;
  173.     break;
  175.   case 'j':
  176.     objpos[1]-=0.1;
  177.     break;
  178.   case 'k':
  179.     objpos[1]+=0.1;
  180.     break;
  181.   case 'i':
  182.     objpos[0]-=0.1;
  183.     break;
  184.   case 'm':
  185.     objpos[0]+=0.1;
  186.     break;
  187.   case 'u':
  188.     objpos[2]-=0.1;
  189.     break;
  190.   case 'o':
  191.     objpos[2]+=0.1;
  192.     break;
  194.   case 'a':
  195.     v+=0.005;
  196.     break;
  197.   case 'z':
  198.     v-=0.005;
  199.     break;
  201.   case 'g':
  202.     joyactive=(!joyactive);
  203.     break;
  204.   case 'h':
  205.     help=(!help);
  206.     break;
  207.   case 'f':
  208.     fog=(!fog);
  209.     break;
  211.   case '1':
  212.     showcheckmap=(!showcheckmap);
  213.     break;
  214.   case '2':
  215.     showreflectmap=(!showreflectmap);
  216.     break;
  218.   case 'b':
  219.     if(bfcull) {
  220.       glDisable(GL_CULL_FACE);
  221.       bfcull=0;
  222.     } else {
  223.       glEnable(GL_CULL_FACE);
  224.       bfcull=1;
  225.     }
  226.     break;
  227.   case 'p':
  228.     if(poutline) {
  229.       glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  230.       poutline=0;
  231.     } else {
  232.       glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  233.       poutline=1;
  234.     }
  235.     break;
  236.   }
  237. }
  239. static void reshape(int w, int h) 
  240. {
  241.   WIDTH=w;
  242.   HEIGHT=h;
  243.   glViewport(0,0,w,h);
  244.   glMatrixMode(GL_PROJECTION);
  245.   glLoadIdentity();
  246.   gluPerspective(45.0,w/(float)h,0.8,40.0);
  247.   glMatrixMode(GL_MODELVIEW);
  248.   glLoadIdentity();
  249. }
  251. static void printstring(void *font, char *string)
  252. {
  253.   int len,i;
  255.   len=(int)strlen(string);
  256.   for(i=0;i<len;i++)
  257.     glutBitmapCharacter(font,string[i]);
  258. }
  260. static void printhelp(void)
  261. {
  262.   glEnable(GL_BLEND);
  263.   glColor4f(0.5,0.5,0.5,0.5);
  264.   glRecti(40,40,600,440);
  265.   glDisable(GL_BLEND);
  267.   glColor3f(0.0,0.0,1.0);
  268.   glRasterPos2i(300,420);
  269.   printstring(GLUT_BITMAP_HELVETICA_18,"Help");
  271.   glRasterPos2i(60,390);
  272.   printstring(GLUT_BITMAP_HELVETICA_12,"h - Togle Help");
  273.   glRasterPos2i(60,370);
  274.   printstring(GLUT_BITMAP_HELVETICA_12,"f - Togle Fog");
  275.   glRasterPos2i(60,350);
  276.   printstring(GLUT_BITMAP_HELVETICA_12,"b - Togle Back face culling");
  277.   glRasterPos2i(60,330);
  278.   printstring(GLUT_BITMAP_HELVETICA_12,"p - Togle Wire frame");
  279.   glRasterPos2i(60,310);
  280.   printstring(GLUT_BITMAP_HELVETICA_12,"Arrow Keys - Rotate");
  281.   glRasterPos2i(60,290);
  282.   printstring(GLUT_BITMAP_HELVETICA_12,"a - Increase velocity");
  283.   glRasterPos2i(60,270);
  284.   printstring(GLUT_BITMAP_HELVETICA_12,"z - Decrease velocity");
  286.   glRasterPos2i(60,250);
  287.   if(joyavailable)
  288.     printstring(GLUT_BITMAP_HELVETICA_12,"j - Togle jostick control (Joystick control available)");
  289.   else
  290.     printstring(GLUT_BITMAP_HELVETICA_12,"(No Joystick control available)");
  292.   glRasterPos2i(60,230);
  293.   printstring(GLUT_BITMAP_HELVETICA_12,"To move the light source: s - left,  d - right,  e - far,  x - near,  w - down r - up");
  294.   glRasterPos2i(60,210);
  295.   printstring(GLUT_BITMAP_HELVETICA_12,"To move the mirror sphere: j - left,  k - right,  i - far,  m - near,  u - down o - up");
  297.   glRasterPos2i(60,190);
  298.   printstring(GLUT_BITMAP_HELVETICA_12,"1 - Togle the plane texture map window");
  300.   glRasterPos2i(60,170);
  301.   printstring(GLUT_BITMAP_HELVETICA_12,"2 - Togle the sphere texture map window");
  302. }
  304. static GLboolean seelight(float p[3],float dir[3])
  305. {
  306.   float c[3],b,a,d,t,dist[3];
  308.   vsub(c,p,objpos);
  309.   b=-dprod(c,dir);
  310.   a=dprod(c,c)-SPHERE_RADIUS*SPHERE_RADIUS;
  312.   if((d=b*b-a)<0.0 || (b<0.0 && a>0.0))
  313.     return GL_FALSE;
  315.   d=sqrt(d);
  317.   t=b-d;
  319.   if(t<EPSILON) {
  320.     t=b+d;
  321.     if(t<EPSILON)
  322.       return GL_FALSE;
  323.   }
  325.   vsub(dist,lightpos,p);
  326.   if(dprod(dist,dist)<t*t)
  327.       return GL_FALSE;
  329.   return GL_TRUE;
  330. }
  332. static int colorcheckmap(float ppos[3], float c[3])
  333. {
  334.   static float norm[3]={0.0f,0.0f,1.0f};
  335.   float ldir[3],vdir[3],h[3],dfact,kfact,r,g,b;
  336.   int x,y;
  338.   x=(int)((ppos[0]+BASESIZE/2)*(10.0f/BASESIZE));
  339.   if((x<0) || (x>10))
  340.     return GL_FALSE;
  342.   y=(int)((ppos[1]+BASESIZE/2)*(10.0f/BASESIZE));
  343.   if((y<0) || (y>10))
  344.     return GL_FALSE;
  346.   r=255.0f;
  347.   if(y & 1) {
  348.     if(x & 1)
  349.       g=255.0f;
  350.     else
  351.       g=0.0f;
  352.   } else {
  353.     if(x & 1)
  354.       g=0.0f;
  355.     else
  356.       g=255.0f;
  357.   }
  358.   b=0.0f;
  360.   vsub(ldir,lightpos,ppos);
  361.   vnormalize(ldir,ldir);
  363.   if(seelight(ppos,ldir)) {
  364.     c[0]=r*0.05f;
  365.     c[1]=g*0.05f;
  366.     c[2]=b*0.05f;
  368.     return GL_TRUE;
  369.   }
  371.   dfact=dprod(ldir,norm);
  372.   if(dfact<0.0f)
  373.     dfact=0.0f;
  375.   vsub(vdir,obs,ppos);
  376.   vnormalize(vdir,vdir);
  377.   h[0]=0.5f*(vdir[0]+ldir[0]);
  378.   h[1]=0.5f*(vdir[1]+ldir[1]);
  379.   h[2]=0.5f*(vdir[2]+ldir[2]);
  380.   kfact=dprod(h,norm);
  381.   kfact=kfact*kfact*kfact*kfact*kfact*kfact*kfact*7.0f*255.0f;
  383.   r=r*dfact+kfact;
  384.   g=g*dfact+kfact;
  385.   b=b*dfact+kfact;
  386.   
  387.   c[0]=clamp255(r);
  388.   c[1]=clamp255(g);
  389.   c[2]=clamp255(b);
  391.   return GL_TRUE;
  392. }
  394. static void updatecheckmap(int slot)
  395. {
  396.   float c[3],ppos[3];
  397.   int x,y;
  399.   glBindTexture(GL_TEXTURE_2D,checkid);
  401.   ppos[2]=0.0f;
  402.   for(y=slot*TEX_CHECK_SLOT_SIZE;y<(slot+1)*TEX_CHECK_SLOT_SIZE;y++) {
  403.     ppos[1]=(y/(float)TEX_CHECK_HEIGHT)*BASESIZE-BASESIZE/2;
  405.     for(x=0;x<TEX_CHECK_WIDTH;x++) {
  406.       ppos[0]=(x/(float)TEX_CHECK_WIDTH)*BASESIZE-BASESIZE/2;
  408.       colorcheckmap(ppos,c);
  409.       checkmap[y][x][0]=(GLubyte)c[0];
  410.       checkmap[y][x][1]=(GLubyte)c[1];
  411.       checkmap[y][x][2]=(GLubyte)c[2];
  412.     }
  413.   }
  415.   glTexSubImage2D(GL_TEXTURE_2D,0,0,slot*TEX_CHECK_SLOT_SIZE,TEX_CHECK_WIDTH,
  416.   TEX_CHECK_SLOT_SIZE,GL_RGB,GL_UNSIGNED_BYTE,
  417.   &checkmap[slot*TEX_CHECK_SLOT_SIZE][0][0]);
  419. }
  421. static void updatereflectmap(int slot)
  422. {
  423.   float rf,r,g,b,t,dfact,kfact,rdir[3];
  424.   float rcol[3],ppos[3],norm[3],ldir[3],h[3],vdir[3],planepos[3];
  425.   int x,y;
  427.   glBindTexture(GL_TEXTURE_2D,reflectid);
  429.   for(y=slot*TEX_REFLECT_SLOT_SIZE;y<(slot+1)*TEX_REFLECT_SLOT_SIZE;y++)
  430.     for(x=0;x<TEX_REFLECT_WIDTH;x++) {
  431.       ppos[0]=sphere_pos[y][x][0]+objpos[0];
  432.       ppos[1]=sphere_pos[y][x][1]+objpos[1];
  433.       ppos[2]=sphere_pos[y][x][2]+objpos[2];
  435.       vsub(norm,ppos,objpos);
  436.       vnormalize(norm,norm);
  438.       vsub(ldir,lightpos,ppos);
  439.       vnormalize(ldir,ldir);
  440.       vsub(vdir,obs,ppos);
  441.       vnormalize(vdir,vdir);
  443.       rf=2.0f*dprod(norm,vdir);
  444.       if(rf>EPSILON) {
  445. rdir[0]=rf*norm[0]-vdir[0];
  446. rdir[1]=rf*norm[1]-vdir[1];
  447. rdir[2]=rf*norm[2]-vdir[2];
  449. t=-objpos[2]/rdir[2];
  451. if(t>EPSILON) {
  452.   planepos[0]=objpos[0]+t*rdir[0];
  453.   planepos[1]=objpos[1]+t*rdir[1];
  454.   planepos[2]=0.0f;
  455.   
  456.   if(!colorcheckmap(planepos,rcol))
  457.     rcol[0]=rcol[1]=rcol[2]=0.0f;
  458. } else
  459.   rcol[0]=rcol[1]=rcol[2]=0.0f;
  460.       } else
  461. rcol[0]=rcol[1]=rcol[2]=0.0f;
  463.       dfact=0.1f*dprod(ldir,norm);
  465.       if(dfact<0.0f) {
  466. dfact=0.0f;
  467. kfact=0.0f;
  468.       } else {
  469. h[0]=0.5f*(vdir[0]+ldir[0]);
  470. h[1]=0.5f*(vdir[1]+ldir[1]);
  471. h[2]=0.5f*(vdir[2]+ldir[2]);
  472. kfact=dprod(h,norm);
  473. kfact*=kfact;
  474. kfact*=kfact;
  475. kfact*=kfact;
  476. kfact*=kfact;
  477. kfact*=10.0f;
  478.       }
  480.       r=dfact+kfact;
  481.       g=dfact+kfact;
  482.       b=dfact+kfact;
  484.       r*=255.0f;
  485.       g*=255.0f;
  486.       b*=255.0f;
  488.       r+=rcol[0];
  489.       g+=rcol[1];
  490.       b+=rcol[2];
  492.       r=clamp255(r);
  493.       g=clamp255(g);
  494.       b=clamp255(b);
  496.       reflectmap[y][x][0]=(GLubyte)r;
  497.       reflectmap[y][x][1]=(GLubyte)g;
  498.       reflectmap[y][x][2]=(GLubyte)b;
  499.     }
  501.   glTexSubImage2D(GL_TEXTURE_2D,0,0,slot*TEX_REFLECT_SLOT_SIZE,TEX_REFLECT_WIDTH,
  502.   TEX_REFLECT_SLOT_SIZE,GL_RGB,GL_UNSIGNED_BYTE,
  503.   &reflectmap[slot*TEX_REFLECT_SLOT_SIZE][0][0]);
  504. }
  506. static void drawbase(void)
  507. {
  508.   glColor3f(0.0,0.0,0.0);
  509.   glBindTexture(GL_TEXTURE_2D,checkid);
  510.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
  512.   glBegin(GL_QUADS);
  513.   glTexCoord2f(0.0f,0.0f);
  514.   glVertex3f(-BASESIZE/2.0f,-BASESIZE/2.0f,0.0f);
  516.   glTexCoord2f(1.0f,0.0f);
  517.   glVertex3f(BASESIZE/2.0f,-BASESIZE/2.0f,0.0f);
  519.   glTexCoord2f(1.0f,1.0f);
  520.   glVertex3f(BASESIZE/2.0f,BASESIZE/2.0f,0.0f);
  522.   glTexCoord2f(0.0f,1.0f);
  523.   glVertex3f(-BASESIZE/2.0f,BASESIZE/2.0f,0.0f);
  525.   glEnd();
  526. }
  528. static void drawobj(void)
  529. {
  530.   glColor3f(0.0,0.0,0.0);
  531.   glBindTexture(GL_TEXTURE_2D,reflectid);
  532.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
  534.   glPushMatrix();
  535.   glTranslatef(objpos[0],objpos[1],objpos[2]);
  536.   glCallList(objdlist);
  537.   glPopMatrix();
  538. }
  540. static void dojoy(void)
  541. {
  542. #ifdef _WIN32
  543.   static UINT max[2]={0,0};
  544.   static UINT min[2]={0xffffffff,0xffffffff},center[2];
  545.   MMRESULT res;
  546.   JOYINFO joy;
  548.   res=joyGetPos(JOYSTICKID1,&joy);
  550.   if(res==JOYERR_NOERROR) {
  551.     joyavailable=1;
  553.     if(max[0]<joy.wXpos)
  554.       max[0]=joy.wXpos;
  555.     if(min[0]>joy.wXpos)
  556.       min[0]=joy.wXpos;
  557.     center[0]=(max[0]+min[0])/2;
  559.     if(max[1]<joy.wYpos)
  560.       max[1]=joy.wYpos;
  561.     if(min[1]>joy.wYpos)
  562.       min[1]=joy.wYpos;
  563.     center[1]=(max[1]+min[1])/2;
  565.     if(joyactive) {
  566.       if(fabs(center[0]-(float)joy.wXpos)>0.1*(max[0]-min[0]))
  567. alpha-=2.5*(center[0]-(float)joy.wXpos)/(max[0]-min[0]);
  568.       if(fabs(center[1]-(float)joy.wYpos)>0.1*(max[1]-min[1]))
  569. beta+=2.5*(center[1]-(float)joy.wYpos)/(max[1]-min[1]);
  571.       if(joy.wButtons & JOY_BUTTON1)
  572. v+=0.005;
  573.       if(joy.wButtons & JOY_BUTTON2)
  574. v-=0.005;
  575.     }
  576.   } else
  577.     joyavailable=0;
  578. #endif
  579. }
  581. static void updatemaps(void)
  582. {
  583.   updatecheckmap(checkmap_currentslot);
  584.   checkmap_currentslot=(checkmap_currentslot+1) % TEX_CHECK_NUMSLOT;
  586.   updatereflectmap(reflectmap_currentslot);
  587.   reflectmap_currentslot=(reflectmap_currentslot+1) % TEX_REFLECT_NUMSLOT;
  588. }
  590. static void draw(void)
  591. {
  592.   static int count=0;
  593.   static char frbuf[80];
  594.   float fr;
  596.   dojoy();
  598.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  600.   glEnable(GL_TEXTURE_2D);
  601.   glEnable(GL_DEPTH_TEST);
  602.   if(fog)
  603.     glEnable(GL_FOG);
  604.   else
  605.     glDisable(GL_FOG);
  607.   glPushMatrix();
  608.   calcposobs();
  610.   gluLookAt(obs[0],obs[1],obs[2],
  611.     obs[0]+dir[0],obs[1]+dir[1],obs[2]+dir[2],
  612.     0.0,0.0,1.0);
  614.   drawbase();
  615.   drawobj();
  617.   glColor3f(1.0,1.0,1.0);
  618.   glDisable(GL_TEXTURE_2D);
  620.   glPushMatrix();
  621.   glTranslatef(lightpos[0],lightpos[1],lightpos[2]);
  622.   glCallList(lightdlist);
  623.   glPopMatrix();
  625.   glPopMatrix();
  626.   
  627.   if((count % FRAME)==0) {
  628.     fr=gettime();
  629.     sprintf(frbuf,"Frame rate: %f",FRAME/fr);
  630.   }
  632.   glDisable(GL_DEPTH_TEST);
  633.   glDisable(GL_FOG);
  635.   glMatrixMode(GL_PROJECTION);
  636.   glPushMatrix();
  637.   glLoadIdentity();
  638.   glOrtho(-0.5,639.5,-0.5,479.5,-1.0,1.0);
  639.   glMatrixMode(GL_MODELVIEW);
  641.   glColor3f(0.0f,0.3f,1.0f);
  643.   if(showcheckmap) {
  644.     glEnable(GL_TEXTURE_2D);
  645.     glBindTexture(GL_TEXTURE_2D,checkid);
  646.     glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
  648.     glBegin(GL_QUADS);
  649.     glTexCoord2f(1.0f,0.0f);
  650.     glVertex2i(10,30);
  651.     glTexCoord2f(1.0f,1.0f);
  652.     glVertex2i(10+90,30);
  653.     glTexCoord2f(0.0f,1.0f);
  654.     glVertex2i(10+90,30+90);
  655.     glTexCoord2f(0.0f,0.0f);
  656.     glVertex2i(10,30+90);
  657.     glEnd();
  659.     glDisable(GL_TEXTURE_2D);
  660.     glBegin(GL_LINE_LOOP);
  661.     glVertex2i(10,30);
  662.     glVertex2i(10+90,30);
  663.     glVertex2i(10+90,30+90);
  664.     glVertex2i(10,30+90);
  665.     glEnd();
  666.     glRasterPos2i(105,65);
  667.     printstring(GLUT_BITMAP_HELVETICA_18,"Plane Texture Map");
  668.   }
  670.   if(showreflectmap) {
  671.     glEnable(GL_TEXTURE_2D);
  672.     glBindTexture(GL_TEXTURE_2D,reflectid);
  673.     glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
  675.     glBegin(GL_QUADS);
  676.     glTexCoord2f(1.0f,0.0f);
  677.     glVertex2i(540,30);
  678.     glTexCoord2f(1.0f,1.0f);
  679.     glVertex2i(540+90,30);
  680.     glTexCoord2f(0.0f,1.0f);
  681.     glVertex2i(540+90,30+90);
  682.     glTexCoord2f(0.0f,0.0f);
  683.     glVertex2i(540,30+90);
  684.     glEnd();
  686.     glDisable(GL_TEXTURE_2D);
  687.     glBegin(GL_LINE_LOOP);
  688.     glVertex2i(540,30);
  689.     glVertex2i(540+90,30);
  690.     glVertex2i(540+90,30+90);
  691.     glVertex2i(540,30+90);
  692.     glEnd();
  693.     glRasterPos2i(360,65);
  694.     printstring(GLUT_BITMAP_HELVETICA_18,"Sphere Texture Map");
  695.   }
  697.   glDisable(GL_TEXTURE_2D);
  699.   glRasterPos2i(10,10);
  700.   printstring(GLUT_BITMAP_HELVETICA_18,frbuf);
  701.   glRasterPos2i(360,470);
  702.   printstring(GLUT_BITMAP_HELVETICA_10,"Ray V1.0 Written by David Bucciarelli (tech.hmw@plus.it)");
  704.   if(help)
  705.     printhelp();
  707.   glMatrixMode(GL_PROJECTION);
  708.   glPopMatrix();
  709.   glMatrixMode(GL_MODELVIEW);
  711.   updatemaps();
  713.   glutSwapBuffers();
  715.   count++;
  716. }
  718. static void inittextures(void)
  719. {
  720.   int y;
  722.   glGenTextures(1,&checkid);
  723.   glBindTexture(GL_TEXTURE_2D,checkid);
  725.   for(y=0;y<TEX_CHECK_NUMSLOT;y++)
  726.     updatecheckmap(y);
  728.   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  729.   glTexImage2D(GL_TEXTURE_2D,0,3,TEX_CHECK_WIDTH,TEX_CHECK_HEIGHT,
  730.        0,GL_RGB,GL_UNSIGNED_BYTE,checkmap);
  732.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  733.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  734.   
  735.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  736.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  738.   glGenTextures(1,&reflectid);
  739.   glBindTexture(GL_TEXTURE_2D,reflectid);
  741.   for(y=0;y<TEX_REFLECT_NUMSLOT;y++)
  742.     updatereflectmap(y);
  744.   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  745.   glTexImage2D(GL_TEXTURE_2D,0,3,TEX_REFLECT_WIDTH,TEX_REFLECT_HEIGHT,
  746.        0,GL_RGB,GL_UNSIGNED_BYTE,reflectmap);
  748.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  749.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  750.   
  751.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  752.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  753. }
  755. static void initspherepos(void)
  756. {
  757.   float alpha,beta,sa,ca,sb,cb;
  758.   int x,y;
  760.   for(y=0;y<TEX_REFLECT_HEIGHT;y++) {
  761.     beta=M_PI-y*(M_PI/TEX_REFLECT_HEIGHT);
  763.     for(x=0;x<TEX_REFLECT_WIDTH;x++) {
  764.       alpha=-x*(2.0f*M_PI/TEX_REFLECT_WIDTH);
  766.       sa=sin(alpha);
  767.       ca=cos(alpha);
  769.       sb=sin(beta);
  770.       cb=cos(beta);
  772.       sphere_pos[y][x][0]=SPHERE_RADIUS*sa*sb;
  773.       sphere_pos[y][x][1]=SPHERE_RADIUS*ca*sb;
  774.       sphere_pos[y][x][2]=SPHERE_RADIUS*cb;
  775.     }
  776.   }
  777. }
  779. static void initdlists(void)
  780. {
  781.   GLUquadricObj *obj;
  783.   obj=gluNewQuadric();
  785.   lightdlist=glGenLists(1);
  786.   glNewList(lightdlist,GL_COMPILE);
  787.   gluQuadricDrawStyle(obj,GLU_FILL);
  788.   gluQuadricNormals(obj,GLU_NONE);
  789.   gluQuadricTexture(obj,GL_TRUE);
  790.   gluSphere(obj,0.25f,6,6);
  791.   glEndList();
  793.   objdlist=glGenLists(1);
  794.   glNewList(objdlist,GL_COMPILE);
  795.   gluQuadricDrawStyle(obj,GLU_FILL);
  796.   gluQuadricNormals(obj,GLU_NONE);
  797.   gluQuadricTexture(obj,GL_TRUE);
  798.   gluSphere(obj,SPHERE_RADIUS,16,16);
  799.   glEndList();
  800. }
  802. int main(int ac, char **av)
  803. {
  804.   fprintf(stderr,"Ray V1.0nWritten by David Bucciarelli (tech.hmw@plus.it)n");
  806.   /*
  807.     if(!SetPriorityClass(GetCurrentProcess(),REALTIME_PRIORITY_CLASS)) {
  808.     fprintf(stderr,"Error setting the process class.n");
  809.     return 0;
  810.     }
  812.     if(!SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_TIME_CRITICAL)) {
  813.     fprintf(stderr,"Error setting the process priority.n");
  814.     return 0;
  815.     }
  816.     */
  818.   glutInitWindowPosition(0,0);
  819.   glutInitWindowSize(WIDTH,HEIGHT);
  820.   glutInit(&ac,av);
  822.   glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
  824.   glutCreateWindow("Ray");
  826.   reshape(WIDTH,HEIGHT);
  828.   glShadeModel(GL_FLAT);
  829.   glEnable(GL_DEPTH_TEST);
  830.   glDepthFunc(GL_LEQUAL);
  831.   glEnable(GL_CULL_FACE);
  832.   glEnable(GL_TEXTURE_2D);
  833.   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  835.   glEnable(GL_FOG);
  836.   glFogi(GL_FOG_MODE,GL_EXP2);
  837.   glFogfv(GL_FOG_COLOR,fogcolor);
  839.   glFogf(GL_FOG_DENSITY,0.01);
  840. #ifdef FX
  841.   glHint(GL_FOG_HINT,GL_NICEST);
  842. #endif
  844.   calcposobs();
  846.   initspherepos();
  848.   inittextures();
  849.   initdlists();
  851.   glClearColor(fogcolor[0],fogcolor[1],fogcolor[2],fogcolor[3]);
  853.   glutReshapeFunc(reshape);
  854.   glutDisplayFunc(draw);
  855.   glutKeyboardFunc(key);
  856.   glutSpecialFunc(special);
  857.   glutIdleFunc(draw);
  859.   glutMainLoop();
  861.   return 0;             /* ANSI C requires main to return int. */
  862. }