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

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

GIS编程

开发平台：

Visual C++

texpage.c：源码内容
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <math.h>
  4. #include <GL/glut.h>
  5. #include "texture.h"
  6. #include <string.h>
  8. #if !defined(GL_VERSION_1_1) && !defined(GL_VERSION_1_2)
  9. #define glTexSubImage2D glTexSubImage2DEXT
  10. #endif
  12. static unsigned *image, *bgdtile;
  13. static int width, height, components;
  14. static int grid, zoom, texture;
  17. #define TSIZE 128
  18. #define TILES 16
  19. #define TILESIZE 32
  20. static struct tile {
  21.     void *data;
  22. } tiles[TILES][TILES];
  24. static int x = TILES*TILESIZE/2, y = TILES*TILESIZE/2;
  26. /*
  27.  * make an rgb tile for the background.
  28.  */
  29. static void
  30. background_tile(void) {
  31.     int i,j,grid;
  32.     unsigned char *ptr;
  34.     bgdtile = (unsigned *) malloc(TILESIZE*TILESIZE*sizeof(unsigned));
  35.     grid = 8;
  36.     ptr = (unsigned char *) bgdtile;
  37.     for (i=0; i<TILESIZE; i++) {
  38. for(j=0; j<TILESIZE; j++) {
  39.    if(i%grid == 0 || j%grid == 0) {
  40. *ptr++ = 0x0; *ptr++ = 0x0; *ptr++ = 0x40; ptr++;
  41.    } else {
  42. *ptr++ = 0x40; *ptr++ = 0x40; *ptr++ = 0x40; ptr++;
  43.    }
  44.         }
  45.     }
  46. }
  48. static void
  49. tile_image(unsigned *image) {
  50.     int i, j;
  51.     int w = width/TILESIZE;
  52.     int h = height/TILESIZE, w2 = w/2, h2 = h/2;
  53.     background_tile();
  55.     for(i = 0; i < TILES; i++) {
  56. for(j = 0; j < TILES; j++) {
  57.     if (i >= TILES/2-w2 && i < TILES/2-w2+w && j >= TILES/2-h2 && j < TILES/2-h2+h) {
  58. /* interior */
  59. int x, y, k;
  60. tiles[j][i].data = malloc(TILESIZE*TILESIZE*sizeof(*image));
  61. x = TILESIZE*(i-TILES/2+w2);
  62. y = TILESIZE*(j-TILES/2+h2);
  63. for(k = 0; k < TILESIZE; k++)
  64.     memcpy((unsigned *)tiles[j][i].data+k*TILESIZE,
  65.     image+width*(y+k)+x, TILESIZE*sizeof *image);
  66.     }
  67.     else
  68. tiles[j][i].data = bgdtile;
  69. }
  70.     }
  71.     for(i = 0; i < TILES; i++) {
  72. for(j = 0; j < TILES; j++) {
  73.     printf("%d ", tiles[j][i].data != bgdtile);
  74. }
  75. printf("n");
  76.     }
  77. }
  79. #define MAXMESH 64
  81. static float Ml[4*2*(MAXMESH+1)*2 * (MAXMESH+1)];
  83. static void
  84. mesh0(float x0, float x1, float y0, float y1,
  85.           float s0, float s1, float t0, float t1, float z, int nx,int ny)
  86. {
  87.     float y,x,s,t,dx,dy,ds,dt,vb[3],tb[2];
  88.     float *mp = Ml;
  90.     dx = (x1-x0)/nx;
  91.     dy = (y1-y0)/ny;
  92.     ds = (s1-s0)/nx;
  93.     dt = (t1-t0)/ny;
  94.     y = y0;
  95.     t = t0;
  96.     vb[2] = z;
  97.     while (y < y1) {
  98.         x = x0;
  99.         s = s0;
  100.         while(x <= x1) {
  101.             tb[0] = s; tb[1] = t;
  102.             vb[0] = x; vb[1] = y;
  103.             vb[2] = 0.0;
  104.             *mp++ = tb[0];
  105.             *mp++ = tb[1];
  106.             mp += 2;
  107.             *mp++ = vb[0];
  108.             *mp++ = vb[1];
  109.             *mp++ = vb[2];
  110.             mp++;
  111.             tb[1] = t+dt;
  112.             vb[1] = y+dy;
  113.             vb[2] = 0.0;
  114.             *mp++ = tb[0];
  115.             *mp++ = tb[1];
  116.             mp += 2;
  117.             *mp++ = vb[0];
  118.             *mp++ = vb[1];
  119.             *mp++ = vb[2];
  120.             mp++;
  121.             x += dx;
  122.             s += ds;
  123.         }
  124.         y += dy;
  125.         t += dt;
  126.     }
  127. }
  129. static void
  130. drawmesh(int nx,int ny) {
  131.     float *mp = Ml;
  132.     int i,j;
  134.     glPushMatrix();
  135.     if (zoom) glScalef(1.5f, 1.5f, 1.f);
  136.     glColor4f(1,1,1,1);
  137.     for (i = ny+1; i; i--) {
  138.         glBegin(GL_TRIANGLE_STRIP);
  139.         for (j = nx+1; j; j--) {
  140.             glTexCoord2fv(mp);
  141.             glVertex3fv(mp+4);
  142.             glTexCoord2fv(mp+8);
  143.             glVertex3fv(mp+12); mp += 16;
  144.         }
  145.         glEnd();
  146.     }
  147.     glPopMatrix();
  148. }
  150. static void
  151. help(void) {
  152.     printf("'h'      - helpn");
  153.     printf("'left'   - pan leftn");
  154.     printf("'right'  - pan rightn");
  155.     printf("'up'     - pan upn");
  156.     printf("'down'   - pan downn");
  157.     printf("'t'      - toggle texture memory displayn");
  158.     printf("'g'      - toggle gridn");
  159.     printf("'x'      - toggle auto pann");
  160.     printf("'z'      - toggle zoomn");
  161. }
  163. static void
  164. gfunc(void) {
  165.     grid ^= 1;
  166. }
  168. static void
  169. tfunc(void) {
  170.     texture ^= 1;
  171. }
  173. static void anim(void);
  175. static void
  176. xfunc(void) {
  177.     static int state;
  178.     glutIdleFunc((state ^= 1) ? anim : NULL);
  179. }
  181. static void
  182. zfunc(void) {
  183.     zoom ^= 1;
  184. }
  186. #define CLAMP(v) { int w = TSIZE/2; 
  187.     if (v < w) v = w; 
  188.     else if (v > TILES*TILESIZE-w) v = TILES*TILESIZE-w; }
  189. static void
  190. up(void) {
  191.     y += 8;
  192.     CLAMP(y);
  193. }
  195. static void
  196. pfunc(void) {
  197.     static int delta = -1;
  198.     int xx = x + delta;
  199.     x += delta; CLAMP(x);
  200.     y += delta; CLAMP(y);
  201.     if (x != xx) delta = -delta;
  202. }
  204. static void
  205. down(void) {
  206.     y -= 8;
  207.     CLAMP(y);
  208. }
  210. static void
  211. right(void) {
  212.     x += 8;
  213.     CLAMP(x);
  214. }
  216. static void
  217. left(void) {
  218.     x -= 8;
  219.     CLAMP(x);
  220. }
  222. static void
  223. anim(void) {
  224.     static int delta = -1;
  225.     int xx = x + delta;
  226.     x += delta;
  227.     CLAMP(x);
  228.     y += delta;
  229.     CLAMP(y);
  230.     if (x != xx) delta = -delta;
  231.     glutPostRedisplay();
  232. }
  235. static void
  236. loadtiles(void) {
  237.     int lx, rx, ty, by; /* image bounding box */
  238.     static int ox = TILES*TILESIZE/2, oy = TILES*TILESIZE/2;  /* image origin */
  239.     static int ot = 0, os = 0;
  240.     int dx = 0, dy = 0, nx = -1, ny = -1;
  241.     float trx, try;
  242. #define S_TSIZE (TSIZE-TILESIZE) /* visible portion of texture = TSIZE less one tile for slop */
  244.     /* calculate tile #'s at corners of visible region */
  245.     lx = x - S_TSIZE/2;
  246.     rx = lx + S_TSIZE;
  247.     by = y - S_TSIZE/2;
  248.     ty = by + S_TSIZE;
  249.     lx /= TILESIZE; rx /= TILESIZE;
  250.     by /= TILESIZE; ty /= TILESIZE;
  252.     dx = ((x - S_TSIZE/2)/TILESIZE) - ((ox - S_TSIZE/2)/TILESIZE);
  253.     
  254.     nx = lx; ny = by;
  255.     if (dx < 0) {
  256. /* add on left */
  257. os -= TILESIZE;
  258. if (os < 0) os += TSIZE;
  259. nx = lx;
  260.     } else if (dx > 0) {
  261. nx = rx;
  262.     }
  264.     dy = ((y - S_TSIZE/2) / TILESIZE) - ((oy - S_TSIZE/2) / TILESIZE);
  265.     if (dy > 0) {
  266. /* add on bottom */
  267. ny = ty;
  268.     } else if (dy < 0) {
  269. /* add on top */
  270. ot -= TILESIZE;
  271. if (ot < 0) ot += TSIZE;
  272. ny = by;
  273.     }
  274. if (dx || dy) printf("dx %d dy %d   lx %d rx %d   by %d ty %d   nx %d ny %d   os %d ot %dn", dx, dy, lx, rx, by, ty, nx, ny, os, ot);
  275.     if (dx) {
  276. int t;
  277. for(t = 0; t < TSIZE; t += TILESIZE) {
  278.     glTexSubImage2D(GL_TEXTURE_2D, 0, os, (t+ot) % TSIZE, TILESIZE,
  279.                  TILESIZE, GL_RGBA, GL_UNSIGNED_BYTE,
  280.                  tiles[ny+t/TILESIZE][nx].data);
  281. printf("load %d %d  %d %dn", nx, ny+t/TILESIZE, os, (t+ot) % TSIZE);
  282. }
  283.     }
  285.     if (dy) {
  286. int s;
  287. for(s = 0; s < TSIZE; s += TILESIZE) {
  288.     glTexSubImage2D(GL_TEXTURE_2D, 0, (s+os) % TSIZE, ot, TILESIZE,
  289.                  TILESIZE, GL_RGBA, GL_UNSIGNED_BYTE,
  290.                  tiles[ny][nx+s/TILESIZE].data);
  291. printf("load %d %d  %d %dn", nx+s/TILESIZE, ny, (s+os) % TSIZE, ot);
  292. }
  293.     }
  294.     if (dx > 0) {
  295. os += TILESIZE;
  296. if (os >= TSIZE) os -= TSIZE;
  297.     }
  298.     if (dy > 0) {
  299. ot += TILESIZE;
  300. if (ot >= TSIZE) ot -= TSIZE;
  301.     }
  302.     ox = x; oy = y;
  303.     glMatrixMode(GL_TEXTURE);
  304.     glLoadIdentity();
  305.     trx = (float)((x-TILES*TILESIZE/2) % TSIZE)/TSIZE;
  306.     try = (float)((y-TILES*TILESIZE/2) % TSIZE)/TSIZE;
  307.     glTranslatef(trx, try, 0.f);
  308.     glMatrixMode(GL_MODELVIEW);
  309. }
  311. static void
  312. init(char *filename) {
  313.     int i;
  315.     mesh0(-1.f,1.f,-1.f,1.f,0.f,1.f,0.f,1.f,0.f,64,64);
  316.     if (filename) {
  317. image = read_texture(filename, &width, &height, &components);
  318. if (image == NULL) {
  319.     fprintf(stderr, "Error: Can't load image file "%s".n",
  320.     filename);
  321.     exit(EXIT_FAILURE);
  322. } else {
  323.     printf("%d x %d image loadedn", width, height);
  324. }
  325. if (components < 3 || components > 4) {
  326.     printf("must be RGB or RGBA imagen");
  327.     exit(EXIT_FAILURE);
  328. }
  329.     } else {
  330. int i, j;
  331. components = 4; width = height = TSIZE;
  332. image = (unsigned *) malloc(width*height*sizeof(unsigned));
  333. for (j = 0; j < height; j++)
  334.     for (i = 0; i < width; i++) {
  335. if (i & 1)
  336.     image[i+j*width] = 0xff;
  337. else
  338.     image[i+j*width] = 0xff00;
  339. if (j&1)
  340.     image[i+j*width] |= 0xff0000;
  341.     }
  343.     }
  344.     if (width % TILESIZE || height % TILESIZE) {
  345. #define TXSIZE 192
  346. unsigned *newimage = malloc(TXSIZE*TXSIZE*sizeof *newimage);
  347. gluScaleImage(GL_RGBA, width, height, GL_UNSIGNED_BYTE, image,
  348. TXSIZE, TXSIZE, GL_UNSIGNED_BYTE, newimage);
  349. free(image);
  350. image = newimage; width = height = TXSIZE; components = 4;
  351.     }
  352.     tile_image(image);
  353.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  354.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  355.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  356.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  357.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  358.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  360.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TSIZE,
  361.                  TSIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
  362.     for(i = 0; i < TILES; i++) {
  363. int j;
  364. for(j = 0; j < TILES; j++) {
  365.     glTexSubImage2D(GL_TEXTURE_2D, 0, i*TILESIZE, j*TILESIZE, TILESIZE,
  366.  TILESIZE, GL_RGBA, GL_UNSIGNED_BYTE, 
  367.  tiles[(TILES-TSIZE/TILESIZE)/2+j][(TILES-TSIZE/TILESIZE)/2+i].data);
  368. }
  369.     }
  370.     glEnable(GL_TEXTURE_2D);
  372.     glMatrixMode(GL_PROJECTION);
  373.     glLoadIdentity();
  374.     gluPerspective(90.,1.,.1,10.);
  375.     glMatrixMode(GL_MODELVIEW);
  376.     glLoadIdentity();
  377.     glTranslatef(0.,0.,-1.0);
  378.     glLineWidth(3.0);
  379.     glClearColor(.25, .25, .25, .25);
  381.     /* start at center of image */
  382.     x = TILES*TILESIZE/2;
  383.     y = TILES*TILESIZE/2;
  384. }
  386. void
  387. showgrid(void) {
  388.     GLfloat mat[16];
  389.     int i;
  391.     glPushMatrix();
  392.     glDisable(GL_TEXTURE_2D);
  393.     glPushMatrix();
  394.     glColor3f(0.f, 0.f, 0.f);
  395.     if (!zoom) glScalef(1.f/1.5f, 1.f/1.5f, 1.f);
  396.     glBegin(GL_LINE_LOOP);
  397. glVertex2f(-1.f,-1.f);
  398. glVertex2f(-1.f, 1.f);
  399. glVertex2f( 1.f, 1.f);
  400. glVertex2f( 1.f,-1.f);
  401.     glEnd();
  402.     glPopMatrix();
  404.     glGetFloatv(GL_TEXTURE_MATRIX,mat);
  405.     glPushMatrix();
  406.     if (zoom) glScalef(1.5f,1.5f,1.f);
  407.     glTranslatef(-1.f,-1.f,-1.f);
  408.     glScalef(2.f,2.f,1.f);
  409.     glTranslatef(-mat[12], -mat[13], 1.0f);
  410. #if 1
  411.     glColor3f(1.f,1.f,1.f);
  412. #else
  413.     glColor3f(1.f,0.f,0.f);
  414. #endif
  415.     glBegin(GL_LINES);
  416.     for(i = -TSIZE; i <= 2*TSIZE; i+=TILESIZE) {
  417. GLfloat x = (GLfloat)i/(GLfloat)TSIZE;
  418. glVertex2f(-1.f,x);
  419. glVertex2f(2.f,x);
  420. glVertex2f(x,-1.f);
  421. glVertex2f(x,2.f);
  422.     }
  423.     glEnd();
  424.     glPopMatrix();
  425.     glEnable(GL_TEXTURE_2D);
  426.     glPopMatrix();
  427. }
  429. static void
  430. drawtexture(void) {
  431.     glMatrixMode(GL_TEXTURE);
  432.     glPushMatrix();
  433.     glLoadIdentity();
  434.     glColor3f(1.f,1.f,1.f);
  435.     glBegin(GL_QUADS);
  436. glTexCoord2f(0.f, 0.f); glVertex2f(-1.f, -1.f);
  437. glTexCoord2f(0.f, 1.f); glVertex2f(-1.f,  1.f);
  438. glTexCoord2f(1.f, 1.f); glVertex2f( 1.f,  1.f);
  439. glTexCoord2f(1.f, 0.f); glVertex2f( 1.f, -1.f);
  440.     glEnd();
  441.     glPopMatrix();
  442.     glMatrixMode(GL_MODELVIEW);
  443. }
  445. static void
  446. display(void) {
  447.     glClear(GL_COLOR_BUFFER_BIT);
  448.     loadtiles();
  449.     if (texture) {
  450. drawtexture();
  451.     } else {
  452. drawmesh(64,64);
  453. if (grid) showgrid();
  454.     }
  455.     glutSwapBuffers();
  456. }
  458. static void
  459. reshape(int w, int h) {
  460.     glViewport(0, 0, w, h);
  461. }
  463. /*ARGSUSED1*/
  464. static void
  465. key(unsigned char key, int x, int y) {
  466.     switch(key) {
  467.     case 'h': help(); break;
  468.     case 'g': gfunc(); break;
  469.     case 't': tfunc(); break;
  470.     case 'z': zfunc(); break;
  471.     case 'x': xfunc(); break;
  472.     case 'p': pfunc(); break;
  473.     case '33': exit(EXIT_SUCCESS); break;
  474.     default: break;
  475.     }
  476.     glutPostRedisplay();
  477. }
  479. /*ARGSUSED1*/
  480. static void
  481. special(int key, int x, int y) {
  482.     switch(key) {
  483.     case GLUT_KEY_UP: up(); break;
  484.     case GLUT_KEY_DOWN: down(); break;
  485.     case GLUT_KEY_LEFT: left(); break;
  486.     case GLUT_KEY_RIGHT:right(); break;
  487.     }
  488.     glutPostRedisplay();
  489. }
  491. int main(int argc, char* argv[]) {
  492.     glutInitWindowSize(512, 512);
  493.     glutInit(&argc, argv);
  494.     glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE);
  495.     (void)glutCreateWindow(argv[0]);
  496.     init(argv[1] ? argv[1] : "../data/fendi.rgb");
  497.     glutDisplayFunc(display);
  498.     glutKeyboardFunc(key);
  499.     glutSpecialFunc(special);
  500.     glutReshapeFunc(reshape);
  501.     glutMainLoop();
  502.     return 0;
  503. }