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

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

GIS编程

开发平台：

Visual C++

bubble.c：源码内容
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <GL/glut.h>
  5. #include "texture.h"
  7. /* Some <math.h> files do not define M_PI... */
  8. #ifndef M_PI
  9. #define M_PI 3.14159265358979323846
  10. #endif
  12. #ifndef __sgi
  13. /* Most math.h's do not define float versions of the trig functions. */
  14. #define sinf(x) ((float)sin((x)))
  15. #define cosf(x) ((float)cos((x)))
  16. #endif
  18. static float transp = .5f;
  19. static int normals;
  20. static float phase = .05;
  21. static int tess = 10;
  22. static float freq = 10.f, scale = .03;
  23. static float transx = 1.0, transy, rotx, roty;
  24. static int ox = -1, oy = -1;
  25. static int mot = 0;
  26. #define PAN 1
  27. #define ROT 2
  29. void
  30. pan(const int x, const int y) {
  31.     transx +=  (x-ox)/5.;
  32.     transy -= (y-oy)/5.;
  33.     ox = x; oy = y;
  34.     glutPostRedisplay();
  35. }
  37. void
  38. rotate(const int x, const int y) {
  39.     rotx += x-ox;
  40.     if (rotx > 360.) rotx -= 360.;
  41.     else if (rotx < -360.) rotx += 360.;
  42.     roty += y-oy;
  43.     if (roty > 360.) roty -= 360.;
  44.     else if (roty < -360.) roty += 360.;
  45.     ox = x; oy = y;
  46.     glutPostRedisplay();
  47. }
  49. void
  50. motion(int x, int y) {
  51.     if (mot == PAN) pan(x, y);
  52.     else if (mot == ROT) rotate(x,y);
  53. }
  55. void
  56. mouse(int button, int state, int x, int y) {
  57.     if(state == GLUT_DOWN) {
  58. switch(button) {
  59. case GLUT_LEFT_BUTTON:
  60.     mot = PAN;
  61.     motion(ox = x, oy = y);
  62.     break;
  63. case GLUT_MIDDLE_BUTTON:
  64.     mot = ROT;
  65.     motion(ox = x, oy = y);
  66.     break;
  67. case GLUT_RIGHT_BUTTON:
  68.     break;
  69. }
  70.     } else if (state == GLUT_UP) {
  71. mot = 0;
  72.     }
  73. }
  75. void init(char *fname) {
  76.     int width, height, components;
  77.     GLubyte *image;
  79.     glClearColor(0.0, 0.0, 0.0, 0.0);
  80.     glEnable(GL_DEPTH_TEST);
  81.     glShadeModel(GL_SMOOTH);
  83.     if (!(image = (GLubyte *)read_texture(fname, &width, &height, &components))) {
  84. perror(fname);
  85. exit(EXIT_FAILURE);
  86.     }
  87.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  89.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  90.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  91.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  92.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  93.     glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0,
  94. GL_RGBA, GL_UNSIGNED_BYTE, image);
  96.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  97.     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  98.     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  100.     glEnable(GL_TEXTURE_GEN_S);
  101.     glEnable(GL_TEXTURE_GEN_T);
  102.     glEnable(GL_TEXTURE_2D);
  103.     glEnable(GL_CULL_FACE);
  104.     glEnable(GL_LIGHTING);
  105.     glEnable(GL_LIGHT0);
  106.     glEnable(GL_NORMALIZE);
  107.     glFrontFace(GL_CW);
  108.     glCullFace(GL_BACK);
  109.     glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
  110.     glEnable(GL_COLOR_MATERIAL);
  111. #if 1
  112.     glMaterialf (GL_FRONT, GL_SHININESS, 64.0);
  113.     glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
  114.     {
  115.     GLfloat pos[4] = { 0, 0, 1, 1};
  116.     glLightfv(GL_LIGHT0, GL_POSITION, pos);
  117.     }
  118. #endif
  119.     { int e; if (e = glGetError()) printf("error %xn", e); }
  121. #if 0
  122.     glClearColor(.2,.2f,.58f,1.f);
  123. #endif
  124.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  125.     glEnable(GL_BLEND);
  126. }
  128. #if 0
  129. cube(void) {
  130.     glBegin(GL_QUAD_STRIP);
  131. glVertex3f(-1.,-1.,-1.);
  132. glVertex3f(-1., 1.,-1.);
  133. glVertex3f( 1.,-1.,-1.);
  134. glVertex3f( 1., 1.,-1.);
  135. glVertex3f(-1.,-1.,-1.);
  136. glVertex3f(-1.,-1.,-1.);
  137. glVertex3f(-1.,-1.,-1.);
  138.     glEnd();
  139. }
  140. #endif
  142. /*
  143.  * bilinear (longitude/lattitude) tesselation
  144.  * x = cos(theta)*cos(phi)
  145.  * y = sin(phi)
  146.  * z = sin(theta)*cos(phi)
  147.  */
  149. float *normalize(float *v) {
  150.     static float vv[3];
  151.     float len;
  153.     len = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
  154.     vv[0] = v[0]/len; vv[1] = v[1]/len; vv[2] = v[2]/len;
  155.     return vv;
  156. }
  158. void
  159. bubble(float rad) {
  160.     float v[3],s;
  161.     float phi, mod;
  162.     static float off;
  163.     int i, j;
  164. #define N tess
  165.     off += phase;
  166. #if 0
  167.     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  168. #endif
  169. #if 1
  170.     /* top cap */
  171.     glBegin(GL_TRIANGLE_FAN);
  172.     glNormal3f(0.f, 1.f, 0.f);
  173.     glVertex3f(0.f, 1.f, 0.f);
  174.     v[1] = rad*sinf(phi = M_PI*(N+2)/(2*N));
  175.     mod = 1+scale*sinf(freq*v[1]+off);
  176.     s = cosf(phi)*rad*mod;
  177.     for(i = 0; i <= 2*N; i++) {
  178. v[0] = s*cosf((M_PI/N)*i);
  179. v[2] = s*sinf((M_PI/N)*i);
  180. glNormal3fv(v);
  181. glVertex3fv(v);
  182.     }
  183.     glEnd();
  184. #endif
  185. #if 1
  186.     for(i = 1; i < N-1; i++) {
  187. float v0[3], v1[3], s0, s1;
  188. v0[1] = rad*sinf(phi=M_PI/2+M_PI/N*i); s0 = rad*cosf(phi);
  189. mod = mod = 1+scale*sin(freq*v0[1]+off); s0 *= mod;
  190. v1[1] = rad*sinf(phi=M_PI/2+M_PI/N*(i+1)); s1 = rad*cosf(phi);
  191. mod = mod = 1+scale*sin(freq*v1[1]+off); s1 *= mod;
  192. glBegin(GL_TRIANGLE_STRIP);
  193. for(j = 0; j <= 2*N; j++) {
  194.     float x, z;
  195.     v0[0] = s0*(x = sinf(M_PI/N*j));
  196.     v0[2] = s0*(z = cosf(M_PI/N*j));
  197.     v1[0] = s1*x; v1[2] = s1*z;
  198.     glNormal3fv(normalize(v1));
  199.     glVertex3fv(v1);
  200.     glNormal3fv(normalize(v0));
  201.     glVertex3fv(v0);
  202. }
  203. glEnd();
  204. #if 1
  205. if (normals) {
  206. float nscale = 1.2;
  207. /*glDisable(GL_LIGHTING);*/
  208. glBegin(GL_LINES);
  209. /*glColor3f(1.f, 1.f, 0.f);*/
  210. for(j = 0; j <= 2*N; j++) {
  211.     GLfloat x[3], x1, z1, *vv;
  212.     v0[0] = s0*(x1 = sinf(M_PI/N*j));
  213.     v0[2] = s0*(z1 = cosf(M_PI/N*j));
  214.     glVertex3fv(vv = normalize(v0));
  215.     x[0] = nscale*vv[0]; x[1] = nscale*vv[1]; x[2] = nscale*vv[2];
  216.     glVertex3fv(x);
  218.     v1[0] = s1*x1; v1[2] = s1*z1;
  219.     glVertex3fv(vv = normalize(v1));
  220.     x[0] = nscale*vv[0]; x[1] = nscale*vv[1]; x[2] = nscale*vv[2];
  221.     glVertex3fv(x);
  222. }
  223. glEnd();
  224. /*glEnable(GL_LIGHTING);*/
  225. }
  226. #endif
  227.     }
  228. #endif
  229. #if 1
  230.     /* bottom cap */
  231.     glBegin(GL_TRIANGLE_FAN);
  232.     glNormal3f(0.f, -1.f, 0.f);
  233.     glVertex3f(0.f, -1.f, 0.f);
  234.     v[1] = -rad*sinf(phi=M_PI*(N+2)/(2*N));
  235.     mod = 1+scale*sin(freq*v[1]+off);
  236.     s = cosf(phi)*rad*mod;
  237.     for(i = 2*N; i >= 0; --i) {
  238. v[0] = s*cosf((M_PI/N)*i);
  239. v[2] = s*sinf((M_PI/N)*i);
  240. glNormal3fv(v);
  241. glVertex3fv(v);
  242.     }
  243.     glEnd();
  244. #endif
  245. }
  247. void display(void) {
  248. #if 0
  249.     static float phase;
  250. #endif
  252.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  254. #if 0
  255.     glMatrixMode(GL_TEXTURE);
  256.     glPushMatrix();
  257.     s = sinf(phase); t = s; phase += M_PI/25.f;
  258.     if (phase > 2*M_PI) phase -= 2*M_PI;
  259.     glTranslatef(.5f, -0.5f, 0.f);
  260.     glScalef(.1f, .1f, 1.f);
  261.     glTranslatef(s, t, 0.f);
  262.     glMatrixMode(GL_MODELVIEW);
  263. #endif
  265.     glPushMatrix();
  266.     glTranslatef(0., 0., -100.+transx);
  267.     glRotatef(roty, 1.0, 0.0, 0.0);
  268.     glScalef(10.f, 10.f, 10.f);
  269.     glColor4f(1.f,1.f,1.f,transp);
  270.     bubble(1.0f);
  271.     glPopMatrix ();
  272. #if 0
  273.     glMatrixMode(GL_TEXTURE);
  274.     glPopMatrix();
  275.     glMatrixMode(GL_MODELVIEW);
  276. #endif
  277.     glutSwapBuffers();
  278. }
  280. void reshape(int w, int h) {
  281.     glViewport(0, 0, (GLsizei) w, (GLsizei) h);
  282.     glMatrixMode(GL_PROJECTION);
  283.     glLoadIdentity();
  284. #if 0
  285.     if (w <= h)
  286.        glOrtho (-3.5, 3.5, -3.5*(GLfloat)h/(GLfloat)w, 
  287.                 3.5*(GLfloat)h/(GLfloat)w, -3.5, 10.5);
  288.     else
  289.        glOrtho (-3.5*(GLfloat)w/(GLfloat)h, 
  290.                 3.5*(GLfloat)w/(GLfloat)h, -3.5, 3.5, -3.5, 10.5);
  291. #endif
  292.     gluPerspective(40., 1.0, 10.0, 200000.);
  293.     glMatrixMode(GL_MODELVIEW);
  294.     glLoadIdentity();
  295. }
  297. void ffunc(void) {
  298.     static int state = 1;
  299.     if (state ^= 1)
  300. glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA);
  301.     else
  302. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  303. }
  305. void tfunc(void) {
  306.     static int state = 1;
  307.     if (state ^= 1)
  308. glEnable(GL_TEXTURE_2D);
  309.     else
  310. glDisable(GL_TEXTURE_2D);
  311. }
  313. void lfunc(void) {
  314.     static int state = 1;
  315.     if (state ^= 1)
  316. glEnable(GL_LIGHTING);
  317.     else
  318. glDisable(GL_LIGHTING);
  319.     glEnable(GL_COLOR_MATERIAL);
  320. }
  322. void bfunc(void) {
  323.     static int state = 1;
  324.     if (state ^= 1) {
  325. glEnable(GL_BLEND);
  326. glDisable(GL_DEPTH_TEST);
  327.     } else {
  328. glDisable(GL_BLEND);
  329. glEnable(GL_DEPTH_TEST);
  330.     }
  331. }
  333. void cfunc(void) {
  334.     static int state = 1;
  335.     if (state ^= 1)
  336. glEnable(GL_CULL_FACE);
  337.     else
  338. glDisable(GL_CULL_FACE);
  339. }
  341. void wfunc(void) {
  342.     static int state;
  343.     glPolygonMode(GL_FRONT_AND_BACK, (state ^= 1) ? GL_LINE : GL_FILL);
  344. }
  346. void ufunc(void) {
  347. tess *= 2;
  348. if (tess > 160) tess = 160;
  349. }
  350. void Ufunc(void) {
  351. tess /= 2;
  352. if (tess < 10) tess = 10;
  353. }
  355. void pfunc(void) {
  356.     phase += .01;
  357. }
  359. void Pfunc(void) {
  360.     phase -= .01;
  361. }
  363. void nfunc(void) {
  364.     normals ^= 1;
  365. }
  367. void xfunc(void) {
  368.     transp += .1;
  369. }
  371. void Xfunc(void) {
  372.     transp -= .1;
  373. }
  375. void yfunc(void) {
  376.     static int state;
  377.     if (state ^= 1)
  378. /*glClearColor(.2,.2f,.58f,0.f);*/
  379. glClearColor(.0,.0f,.65,0.f);
  380.     else
  381. glClearColor(0.f, 0.f, 0.f, 0.f);
  382. }
  384. void up(void) {
  385.     scale += .01f;
  386. }
  387. void down(void) {
  388.     scale -= .01f;
  389. }
  390. void left(void) {
  391.     freq -= 1.f;
  392. }
  393. void right(void) {
  394.     freq += 1.f;
  395. }
  397. /*ARGSUSED1*/
  398. void key (unsigned char key, int x, int y) {
  399.     switch (key) {
  400.     case 'b': bfunc(); break;
  401.     case 'c': cfunc(); break;
  402.     case 'l': lfunc(); break;
  403.     case 't': tfunc(); break;
  404.     case 'f': ffunc(); break;
  405.     case 'n': nfunc(); break;
  406.     case 'u': ufunc(); break;
  407.     case 'U': Ufunc(); break;
  408.     case 'p': pfunc(); break;
  409.     case 'P': Pfunc(); break;
  410.     case 'w': wfunc(); break;
  411.     case 'x': xfunc(); break;
  412.     case 'X': Xfunc(); break;
  413.     case 'y': yfunc(); break;
  414.     case '33': exit(EXIT_SUCCESS); break;
  415.     default: break;
  416.     }
  417. }
  419. /*ARGSUSED1*/
  420. void
  421. special(int key, int x, int y) {
  422.     switch(key) {
  423.     case GLUT_KEY_UP: up(); break;
  424.     case GLUT_KEY_DOWN: down(); break;
  425.     case GLUT_KEY_LEFT: left(); break;
  426.     case GLUT_KEY_RIGHT:right(); break;
  427.     }
  428. }
  430. void animate(void) {
  431.     glutPostRedisplay();
  432. }
  434. int main(int argc, char** argv) {
  435.     glutInitWindowSize(256, 256);
  436.     glutInit(&argc, argv);
  437.     glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  438.     glutInitWindowPosition(100, 100);
  439.     glutCreateWindow (argv[0]);
  440.     init(argc > 1 ? argv[1] : "../data/spheremap.rgb");
  441.     glutDisplayFunc(display);
  442.     glutReshapeFunc(reshape);
  443.     glutKeyboardFunc(key);
  444.     glutSpecialFunc(special);
  445.     glutIdleFunc(animate);
  446.     glutMouseFunc(mouse);
  447.     glutMotionFunc(motion);
  448.     glutMainLoop();
  449.     return 0;
  450. }