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

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

GIS编程

开发平台：

Visual C++

skyfly.c：源码内容
  2. /*
  3.  * skyfly.c     $Revision: 1.5 $
  4.  */
  6. #include <assert.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <time.h>
  10. #include <errno.h>
  11. #include <GL/glut.h>
  12. #include <math.h>
  13. #include "skyfly.h"
  15. #if !defined(GL_VERSION_1_1)
  16. #if defined(GL_EXT_texture_object)
  17. #define glBindTexture(A,B)     glBindTextureEXT(A,B)
  18. #define glGenTextures(A,B)     glGenTexturesEXT(A,B)
  19. #define glDeleteTextures(A,B)  glDeleteTexturesEXT(A,B)
  20. #else
  21. #define glBindTexture(A,B)
  22. #define glGenTextures(A,B)
  23. #define glDeleteTextures(A,B)
  24. #endif
  25. #if defined(GL_EXT_texture)
  26. #define GL_RGB5 GL_RGB5_EXT
  27. #else
  28. #define GL_RGB5 GL_RGB
  29. #endif
  30. #endif
  32. #define ERR_WARNING                     0x1
  33. #define ERR_FATAL                       0x2
  34. #define ERR_SYSERR                      0x4
  36. #define AMALLOC(a, type, num, func)     {                     
  37. if((int)(a = (type*)malloc(sizeof(type)*(num))) <= 0)     
  38. err_msg(ERR_FATAL, func, "amalloc failed");           
  39. }
  41. float   ScaleZ   = 2.3;     /* Terrain height scale factor */
  42. int     CellDim = 4;        /* Terrain cell is CellDim X Celldim quads */
  43. int     NumCells = 36;      /* Terrain grid is NumCells X NumCells cells */
  44. int     GridDim;            /* Terrain grid is GridDim X GridDim quads */
  45. float   XYScale;            /* Conversion from world-space to grid index */
  46. float   CellSize;           /* World-space size of cell */
  48. int     Init_pos;           /* if true, set initial position and kbd mode */
  49. float   Init_x, Init_y, Init_z, Init_azimuth;
  50. int     rgbmode = GL_TRUE;
  52. /* Color index ramp info */
  53. int sky_base, terr_base;
  54. int plane_colors[3];
  56. /*
  57.  * Data that changes from frame to frame needs to be double-buffered because
  58.  * two processes may be working on two different frames at the same time.
  59.  */
  60. typedef struct buffered_data_struct {
  62.         /* objects */
  63.         perfobj_t       paper_plane_pos_obj[NUM_PLANES];
  64.         perfobj_t       viewer_pos_obj;
  66.         /* flags */
  67.         unsigned int   paper_plane_pos_flags[2];
  68.         unsigned int   viewer_pos_flags[2];
  70.         /* data */
  71.         float  paper_plane_position[NUM_PLANES][6];
  72.         float  viewer_position[4];
  74. } buffered_data;
  76. /*
  77.  * This is the per-pipe data structure which holds pipe id, semaphores,
  78.  * and variable data buffers. Both gfxpipe and buffer structures live in
  79.  * shared memory so the sim can communicate with its forked children.
  80.  */
  81. typedef struct gfxpipe_data_struct {
  82.         int             gfxpipenum;
  83. buffered_data   **buffers;
  85. } gfxpipe_data;
  87. static gfxpipe_data     *gfxpipe;       /* A processes' gfxpipe struct */
  88. static gfxpipe_data     *gfxpipes[1];   /* Maximum of 1 graphics pipe */
  89. static int              num_pipes;
  90. float            fog_params[4];  /* Fog and clear color */
  91. static float            fog_density = 0.025*2;
  92. float            far_cull  = 31.;    /* Far clip distance from eye */
  93. int mipmap = 0;
  94. static int              texmode = GL_NEAREST;
  96. static int              threecomp = 1;
  98. int  dither = GL_TRUE, fog = GL_TRUE;
  99. int     Wxsize = 320, Wysize = 240; /* Default to 320x240 window */
  101. /*
  102.  * All non-variable data like geometry is stored in shared memory. This way
  103.  * forked processes avoid duplicating data unnecessarily.
  104.  */
  105. shared_data     *SharedData;
  107. /* //////////////////////////////////////////////////////////////////////// */
  109. void sim_proc(void);
  110. void sim_cyclops(void);
  111. void sim_dualchannel(void);
  112. void sim_singlechannel(void);
  113. void cull_proc(void);
  114. void draw_proc(void);
  115. void sim_exit(void);
  116. void init_misc(void); 
  117. void init_shmem(void); 
  118. void init_terrain(void);
  119. void init_clouds(void);
  120. void init_paper_planes(void);
  121. void init_positions(void);
  122. void init_gfxpipes(void);
  123. void init_gl(int gfxpipenum);
  124. void err_msg(int type, char* func, char* error);
  125. void fly(perfobj_t *viewer_pos);
  126. void fly_paper_planes(perfobj_t *paper_plane_pos);
  127. float terrain_height(void);
  129. void init_skyfly(void)
  130. {
  131.     init_shmem();
  132.     init_gfxpipes();
  133.     init_clouds();
  134.     init_terrain();
  135.     init_paper_planes();
  136.     init_positions();
  138.     gfxpipe = gfxpipes[0];
  139.     init_gl(gfxpipe->gfxpipenum);
  140. }
  142. /*
  143.  * This is a single-channel version of the dual-channel simulation
  144.  * described above.
  145.  */
  146. void sim_singlechannel(void)
  147. {
  148. buffered_data  **buffered = gfxpipes[0]->buffers;
  150. fly(&(buffered[0]->viewer_pos_obj));
  151. fly_paper_planes(buffered[0]->paper_plane_pos_obj);
  152. }
  154. /*-------------------------------------- Cull ------------------------------*/
  156. /*
  157.  *   The cull and draw processes operate in a classic producer/consumer, 
  158.  * write/read configuration using a ring buffer. The ring consists of pointers
  159.  * to perfobj's instead of actual geometric data. This is important because
  160.  * you want to minimize the amount of data 'shared' between two processes that
  161.  * run on different processors in order to reduce cache invalidations.
  162.  *   enter_in_ring and get_from_ring spin on ring full and ring empty 
  163.  * conditions respectively.
  164.  *   Since cull/draw are shared group processes(sproc), the ring buffer is
  165.  * in the virtual address space of both processes and shared memory is not
  166.  * necessary.
  167. */
  169. #define RING_SIZE   1000    /* Size of ring */
  171. typedef struct render_ring_struct {
  172.     volatile unsigned int      head, tail;
  173.     perfobj_t                   **ring;
  174. } render_ring;
  176. render_ring ringbuffer;
  178. void        enter_in_ring(perfobj_t *perfobj);
  179. perfobj_t*  get_from_ring(void);
  181. void cull_proc(void)
  182. {
  184.     static struct cull {
  185.         perfobj_t       **cells;
  186.         perfobj_t       viewer_pos_obj[2];
  187.         unsigned int   viewer_pos_flags[4];
  188.         float           viewer_position[2][4];
  189.         float           fovx, side, farr, epsilon, plane_epsilon;
  190.     } cull;
  192.     static int init = 0;
  194.     if (!init) {
  195.         int             x, y;
  197.         cull.fovx = FOV *(float) Wxsize /(float) Wysize;
  198.         cull.side = far_cull / cosf(cull.fovx / 2.);
  199.         cull.farr = 2.* cull.side * sinf(cull.fovx / 2.);
  200.         cull.epsilon = sqrtf(2.) * CellSize / 2.;
  201.         cull.plane_epsilon = .5;
  203.         cull.cells = (perfobj_t **) malloc(NumCells * NumCells * sizeof(perfobj_t *));
  204.         for (x = 0; x < NumCells; x++)
  205.             for (y = 0; y < NumCells; y++)
  206.                 cull.cells[x * NumCells + y] =
  207.                     &(SharedData->terrain_cells[x * NumCells + y]);
  209.         ringbuffer.ring = malloc(RING_SIZE * sizeof(perfobj_t *));
  210.         ringbuffer.head = ringbuffer.tail = 0;
  212.         cull.viewer_pos_obj[0].flags = cull.viewer_pos_flags;
  213.         cull.viewer_pos_obj[0].vdata = cull.viewer_position[0];
  214.         cull.viewer_pos_obj[1].flags = cull.viewer_pos_flags;
  215.         cull.viewer_pos_obj[1].vdata = cull.viewer_position[1];
  217.         *(cull.viewer_pos_flags) = PD_VIEWER_POS;
  218.         *(cull.viewer_pos_flags + 1) = PD_END;
  219.         init = 1;
  220.     }
  222. {
  223. float           *viewer;
  224. float           vX, vY, vazimuth, px, py;
  225. float           left_area, right_area;
  226. float           left_dx, left_dy, right_dx, right_dy;
  227. float           ax, ay, bx, by, cx, cy;
  228. float           minx, maxx, miny, maxy;
  229. int             i, buffer = 0;
  230. int             x, y, x0, y0, x1, y1;
  231. perfobj_t      *viewer_pos, *paper_plane_pos;
  232. buffered_data  *buffered;
  233. perfobj_t      *terrain_texture = &(SharedData->terrain_texture_obj);
  234. perfobj_t      *paper_plane = &(SharedData->paper_plane_obj);
  235. perfobj_t      *paper_plane_start = &(SharedData->paper_plane_start_obj);
  236. perfobj_t      *paper_plane_end = &(SharedData->paper_plane_end_obj);
  237. perfobj_t      *clouds_texture = &(SharedData->clouds_texture_obj);
  238. perfobj_t      *clouds = &(SharedData->clouds_obj);
  240. buffered = gfxpipe->buffers[buffer];
  242. viewer_pos = &(buffered->viewer_pos_obj);
  243. paper_plane_pos = buffered->paper_plane_pos_obj;
  245. vX = *((float *) viewer_pos->vdata + 0);
  246. vY = *((float *) viewer_pos->vdata + 1);
  247. vazimuth = *((float *) viewer_pos->vdata + 3);
  249. viewer = cull.viewer_position[buffer];
  251. viewer[0] = vX;
  252. viewer[1] = vY;
  253. viewer[2] = *((float *) viewer_pos->vdata + 2);
  254. viewer[3] = vazimuth;
  256. /*
  257.  * Begin cull to viewing frustrum
  258.  */
  259. ax = (vX - sinf(-vazimuth + cull.fovx *.5) * cull.side);
  260. ay = (vY + cosf(-vazimuth + cull.fovx *.5) * cull.side);
  261. bx = vX;
  262. by = vY;
  263. cx = (vX + sinf(vazimuth + cull.fovx *.5) * cull.side);
  264. cy = (vY + cosf(vazimuth + cull.fovx *.5) * cull.side);
  266. minx = MIN(MIN(ax, bx), cx);
  267. miny = MIN(MIN(ay, by), cy);
  268. maxx = MAX(MAX(ax, bx), cx);
  269. maxy = MAX(MAX(ay, by), cy);
  271. x0 = MAX((int) (minx / CellSize), 0);
  272. x1 = MIN((int) (maxx / CellSize) + 1, NumCells);
  273. y0 = MAX((int) (miny / CellSize), 0);
  274. y1 = MIN((int) (maxy / CellSize) + 1, NumCells);
  276. left_dx = ax - bx;
  277. left_dy = ay - by;
  278. right_dx = cx - bx;
  279. right_dy = cy - by;
  281. enter_in_ring(&cull.viewer_pos_obj[buffer]);
  283. if (viewer[2]<SKY_HIGH) {
  284.    /* draw clouds first */
  285.    enter_in_ring(clouds_texture);
  286.    enter_in_ring(clouds);
  287. }
  289. enter_in_ring(terrain_texture);
  290. /*
  291.  * Add visible cells to ring buffer 
  292.  */
  293. for (x = x0; x < x1; x++) {
  294. for (y = y0; y < y1; y++) {
  295. float           cntrx =(x +.5) * CellSize;
  296. float           cntry =(y +.5) * CellSize;
  298. left_area = left_dx * (cntry - by) - left_dy * (cntrx - bx);
  299. right_area = right_dx * (cntry - by) - right_dy * (cntrx - bx);
  301. if ((left_area < cull.epsilon * cull.side && right_area > -cull.epsilon * cull.side)) {
  302. enter_in_ring(cull.cells[x * NumCells + y]);
  303. }
  304. }
  305. }
  307. enter_in_ring(paper_plane_start);
  308. /*
  309.  * Add visible planes to ring buffer
  310. */
  311. for (i = 0; i < NUM_PLANES; i++) {
  313. px = *((float *) paper_plane_pos[i].vdata + 0);
  314. py = *((float *) paper_plane_pos[i].vdata + 1);
  315. left_area = left_dx * (py - by) - left_dy * (px - bx);
  316. right_area = right_dx * (py - by) - right_dy * (px - bx);
  318. if (left_area < cull.plane_epsilon * cull.side && right_area > -cull.plane_epsilon * cull.side) {
  319. enter_in_ring(&paper_plane_pos[i]);
  320. enter_in_ring(paper_plane);
  321. }
  322. }
  324. enter_in_ring(paper_plane_end);
  326. if (viewer[2]>SKY_HIGH) {
  327.    /* draw clouds after everything else */
  328.    enter_in_ring(clouds_texture);
  329.    enter_in_ring(clouds);
  330. }
  332. enter_in_ring((perfobj_t *) 0);     /* 0 indicates end of frame */
  334. buffer = !buffer;
  335. }
  336. }
  338. void enter_in_ring(perfobj_t *perfobj)
  339. {
  340. while (ringbuffer.head == RING_SIZE+ringbuffer.tail-1) {}
  341. ringbuffer.ring[ringbuffer.head % RING_SIZE] = perfobj;
  342. ringbuffer.head++;
  343. }
  345. perfobj_t* get_from_ring(void)
  346. {
  347.     static perfobj_t *pobj;
  349.     while(ringbuffer.tail == ringbuffer.head) {}
  350.     pobj = ringbuffer.ring[ringbuffer.tail % RING_SIZE];
  351.     ringbuffer.tail++;
  352.     return pobj;        
  353. }
  355. /*-------------------------------------- Draw ------------------------------*/
  357. void draw_proc(void)
  358. {
  359. perfobj_t      *too_draw;
  361. glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  363. while ((too_draw = get_from_ring())) {
  364. drawperfobj(too_draw);
  365. }
  366. }
  369. /*------------------------------- Init -----------------------------------*/
  371. void init_texture_and_lighting(void);
  372. void init_buffered_data(buffered_data *buffered);
  374. void init_misc(void)
  375. {
  376. float   density;
  378. threecomp = rgbmode;
  380. /*
  381.  * Compute fog and clear color to be linear interpolation between blue
  382.  * and white.
  383.  */
  384. density = 1.- expf(-5.5 * fog_density * fog_density *
  385.   far_cull * far_cull);
  386. density = MAX(MIN(density, 1.), 0.);
  388. fog_params[0] = .23 + density *.57;
  389. fog_params[1] = .35 + density *.45;
  390. fog_params[2] = .78 + density *.22;
  391. fog_params[3] = 1.0f;
  392. }
  394. void init_shmem(void)
  395. {
  396. int    i;
  397.     unsigned int  *flagsptr;
  398.     perfobj_vert_t *vertsptr;
  399.     int             nflags, nverts;
  401.     AMALLOC(SharedData, shared_data, 1, "init_shmem");
  402.     AMALLOC(SharedData->terrain_cells, perfobj_t,
  403.             NumCells * NumCells, "init_shmem");
  404.     AMALLOC(SharedData->terrain_cell_flags, unsigned int *,
  405.             NumCells * NumCells, "init_shmem");
  406.     AMALLOC(SharedData->terrain_cell_verts, perfobj_vert_t *,
  407.             NumCells * NumCells, "init_shmem");
  409.     /*
  410.      * Allocate the flags and vertices of all terrain cells in 2 big chunks
  411.      * to improve data locality and consequently, cache hits 
  412.      */
  413.     nflags = 2 * CellDim + 1;
  414. AMALLOC(flagsptr, unsigned int, nflags * NumCells * NumCells, "init_shmem");
  415. nverts = (CellDim + 1) * 2 * CellDim;
  416. AMALLOC(vertsptr, perfobj_vert_t, nverts * NumCells * NumCells, "init_shmem");
  418. for (i = 0; i < NumCells * NumCells; i++) {
  419. SharedData->terrain_cell_flags[i] = flagsptr;
  420. flagsptr += nflags;
  421. SharedData->terrain_cell_verts[i] = vertsptr;
  422. vertsptr += nverts;
  423. }
  424. }
  426. /*
  427.  * Initialize gfxpipe data structures. There is one set of semaphores
  428.  * per pipe.
  429.  */
  430. void init_gfxpipes(void)
  431. {
  432. int             i, j;
  434. num_pipes = 1;
  436. for (i = 0; i < num_pipes; i++) {
  438. AMALLOC(gfxpipes[i], gfxpipe_data, 1, "initgfxpipes");
  439. AMALLOC(gfxpipes[i]->buffers, buffered_data *, NBUFFERS,
  440. "init_gfxpipes");
  441. gfxpipes[i]->gfxpipenum = i;
  442. }
  444. for (j = 0; j < NBUFFERS; j++) {
  445. AMALLOC(gfxpipes[0]->buffers[j], buffered_data, 1,
  446. "init_gfxpipes");
  447. init_buffered_data(gfxpipes[0]->buffers[j]);
  448. }
  449. }
  451. void init_buffered_data(buffered_data *buffered)
  452. {
  453.     int             i;
  454.     perfobj_t      *pobj;
  456.     pobj = &(buffered->viewer_pos_obj);
  457.     pobj->flags = buffered->viewer_pos_flags;
  458.     pobj->vdata = buffered->viewer_position;
  460.     *(buffered->viewer_pos_flags) = PD_VIEWER_POS;
  461.     *(buffered->viewer_pos_flags + 1) = PD_END;
  463.     for (i = 0; i < NUM_PLANES; i++) {
  464.         pobj = &(buffered->paper_plane_pos_obj[i]);
  465.         pobj->flags = buffered->paper_plane_pos_flags;
  466.         pobj->vdata = buffered->paper_plane_position[i];
  467.     }
  468.     *(buffered->paper_plane_pos_flags) = PD_PAPER_PLANE_POS;
  469.     *(buffered->paper_plane_pos_flags + 1) = PD_END;
  470. }
  472. /* ARGSUSED */
  473. void init_gl(int gfxpipenum)
  474. {
  475. glDrawBuffer(GL_BACK);
  476. glClear(GL_COLOR_BUFFER_BIT);
  477. if (!rgbmode)
  478. glIndexi(0);
  480. set_fog(fog);
  482. glEnable(GL_CULL_FACE);
  483. glEnable(GL_DEPTH_TEST);
  485.     set_dither(dither);
  487. glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
  489. init_texture_and_lighting();
  491. glMatrixMode(GL_PROJECTION);
  492. gluPerspective(FOV * RAD_TO_DEG, (float)Wxsize/(float)Wysize,
  493.  .1, far_cull *.95);
  494. glMatrixMode(GL_MODELVIEW);
  495. glHint(GL_FOG_HINT, GL_FASTEST);
  496. glFogi(GL_FOG_MODE, GL_EXP2);
  497. glFogf(GL_FOG_DENSITY, fog_density);
  499. if (rgbmode) {
  500. glFogfv(GL_FOG_COLOR, fog_params);
  501. if (fog && fog_density > 0)
  502. glEnable(GL_FOG);
  503. } else if (FOG_LEVELS > 1) {
  504. glFogi(GL_FOG_INDEX, FOG_LEVELS-1);
  505. if (fog)
  506. glEnable(GL_FOG);
  507. }
  508. }
  510. unsigned char* read_bwimage(char *name, int *w, int *h);
  512. void init_texture_and_lighting(void)
  513. {
  515.     unsigned char  *bwimage256, *bwimage128;
  516.     int             w, h;
  518.     if(!(bwimage256 = (unsigned char*) read_bwimage("terrain.bw", &w, &h)))
  519.        if(!(bwimage256 = (unsigned char *) 
  520.                 read_bwimage("/usr/demos/data/textures/terrain.bw", &w, &h)))
  521. err_msg(ERR_FATAL, "init_texture_and_lighting()",
  522. "Can't open terrain.bw");
  524. if(w != 256 || h != 256)
  525. err_msg(ERR_FATAL, "init_texture_and_lighting()",
  526. "terrain.bw must be 256x256");
  528. if (!(bwimage128 = (unsigned char *) read_bwimage("clouds.bw", &w, &h)))
  529. if (!(bwimage128 = (unsigned char *)
  530.   read_bwimage("/usr/demos/data/textures/clouds.bw", &w, &h)))
  531. err_msg(ERR_FATAL, "init_misc()", "Can't open clouds.bw");
  533. if (w != 128 || h != 128)
  534. err_msg(ERR_FATAL, "init_misc()", "clouds.bw must be 128x128");
  536. if (mipmap)
  537. texmode = GL_LINEAR_MIPMAP_LINEAR;
  538. else
  539. texmode = GL_NEAREST;
  541. if (!threecomp) {
  542. /*
  543.  * 1 and 2-component textures offer the highest performance on SkyWriter
  544.  * so they are the most recommended.
  545.  */
  546. glBindTexture(GL_TEXTURE_2D, 1);
  547. if (!mipmap)
  548. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texmode);
  549. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texmode);
  550. if (mipmap)
  551. gluBuild2DMipmaps(GL_TEXTURE_2D, /*0,*/ 1, 256, 256, /*0,*/ GL_LUMINANCE, GL_UNSIGNED_BYTE, bwimage256);
  552. else if (rgbmode)
  553. glTexImage2D(GL_TEXTURE_2D, 0, 1, 256, 256, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, bwimage256);
  554. else {
  555. #define TXSIZE 128
  556. GLubyte buf[TXSIZE*TXSIZE];
  557. int ii;
  558. gluScaleImage(GL_LUMINANCE, 256, 256, GL_UNSIGNED_BYTE, bwimage256,
  559.   TXSIZE, TXSIZE, GL_UNSIGNED_BYTE, buf);
  560. for (ii = 0; ii < TXSIZE*TXSIZE; ii++) {
  561. buf[ii] = terr_base +
  562. FOG_LEVELS * (buf[ii] >> (8-TERR_BITS));
  563. }
  564. #ifdef GL_COLOR_INDEX8_EXT  /* Requires SGI_index_texture and EXT_paletted_texture */
  565. glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, TXSIZE, TXSIZE,
  566.  0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, buf);
  567. #endif
  568. #undef TXSIZE
  569. }
  571. glBindTexture(GL_TEXTURE_2D, 2);
  572. if (!mipmap)
  573. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texmode);
  574. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texmode);
  575. if (mipmap)
  576. gluBuild2DMipmaps(GL_TEXTURE_2D, /*0,*/ 1, 128, 128, /*0,*/ GL_LUMINANCE, GL_UNSIGNED_BYTE, bwimage128);
  577. else if (rgbmode)
  578. glTexImage2D(GL_TEXTURE_2D, 0, 1, 128, 128, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, bwimage128);
  579. else {
  580. #define TXSIZE 64
  581. GLubyte buf[TXSIZE*TXSIZE];
  582. int ii;
  583. gluScaleImage(GL_LUMINANCE, 128, 128, GL_UNSIGNED_BYTE, bwimage128,
  584.   TXSIZE, TXSIZE, GL_UNSIGNED_BYTE, buf);
  585. for (ii = 0; ii < TXSIZE*TXSIZE; ii++) {
  586. buf[ii] = sky_base +
  587. FOG_LEVELS * (buf[ii] >> (8-SKY_BITS));
  588. }
  589. #ifdef GL_COLOR_INDEX8_EXT  /* Requires SGI_index_texture and EXT_paletted_texture */
  590. glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, TXSIZE, TXSIZE,
  591.  0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, buf);
  592. #endif
  593. #undef TXSIZE
  594. }
  595. } else {
  596. float r0, r1, g0, g1, b0, b1;
  597. int i;
  598. unsigned char *t256 = (unsigned char *)malloc(256*256*3);
  600. /* terrain */
  601. r0 = 0.40f;   r1 = 0.30f;
  602. g0 = 0.30f;   g1 = 0.70f;
  603. b0 = 0.15f;   b1 = 0.10f;
  605. for(i = 0; i < 256*256; i++) {
  606. float t = bwimage256[i] / 255.0f;
  607. t256[3*i+0] = (unsigned char) (255.0f * (r0 + t*t * (r1-r0)));
  608. t256[3*i+1] = (unsigned char) (255.0f * (g0 + t * (g1-g0)));
  609. t256[3*i+2] = (unsigned char) (255.0f * (b0 + t*t * (b1-b0)));
  610. }
  611. glBindTexture(GL_TEXTURE_2D, 1);
  612. if (!mipmap)
  613. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texmode);
  614. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texmode);
  615. if (mipmap)
  616. gluBuild2DMipmaps(GL_TEXTURE_2D, /*0,*/ 3, 256, 256, /*0,*/ GL_RGB, GL_UNSIGNED_BYTE, t256);
  617. else
  618. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, t256);
  621. /* sky without fog */
  622. r0 = 0.23;  r1 = 1.0f;
  623. g0 = 0.35;  g1 = 1.0f;
  624. b0 = 0.78;  b1 = 1.0f;
  625. for(i = 0; i < 128*128; i++) {
  626. float t = bwimage128[i] / 255.0f;
  627. t256[3*i+0] = (unsigned char) (255.0f * (r0 + t * (r1-r0)));
  628. t256[3*i+1] = (unsigned char) (255.0f * (g0 + t * (g1-g0)));
  629. t256[3*i+2] = (unsigned char) (255.0f * (b0 + t * (b1-b0)));
  630. }
  631. glBindTexture(GL_TEXTURE_2D, 2);
  632. if (!mipmap)
  633. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texmode);
  634. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texmode);
  635. if (mipmap)
  636. gluBuild2DMipmaps(GL_TEXTURE_2D, /*0,*/ 3, 128, 128, /*0,*/ GL_RGB, GL_UNSIGNED_BYTE, t256);
  637. else
  638. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 128, 128, 0, GL_RGB, GL_UNSIGNED_BYTE, t256);
  640. /* sky with fog */
  641. r0 = fog_params[0];  r1 = 1.0f;
  642. g0 = fog_params[1];  g1 = 1.0f;
  643. b0 = fog_params[2];  b1 = 1.0f;
  644. for(i = 0; i < 128*128; i++) {
  645. float t = bwimage128[i] / 255.0f;
  646. t256[3*i+0] = (unsigned char) (255.0f * (r0 + t * (r1-r0)));
  647. t256[3*i+1] = (unsigned char) (255.0f * (g0 + t * (g1-g0)));
  648. t256[3*i+2] = (unsigned char) (255.0f * (b0 + t * (b1-b0)));
  649. }
  650. glBindTexture(GL_TEXTURE_2D, 3);
  651. if (!mipmap)
  652. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texmode);
  653. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texmode);
  654. if (mipmap)
  655. gluBuild2DMipmaps(GL_TEXTURE_2D, /*0,*/ 3, 128, 128, /*0,*/ GL_RGB, GL_UNSIGNED_BYTE, t256);
  656. else
  657. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 128, 128, 0, GL_RGB, GL_UNSIGNED_BYTE, t256);
  658. free(t256);
  659. }
  661. free(bwimage256);
  662. free(bwimage128);
  664. /* both textures use BLEND environment */
  665. if (rgbmode) {
  666.             if (threecomp) {
  667.                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  668.             }
  669.             else {
  670.                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
  671.             }
  672. } else if (FOG_LEVELS > 1) {
  673.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
  674. } else {
  675.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  676. }
  678. {
  679.             GLfloat position[] = { LX, LY, LZ, 0., };
  680.             GLfloat one[] = { 1.0, 1.0, 1.0, 1.0 };
  682.             if (rgbmode)
  683.                 glLightfv(GL_LIGHT0, GL_AMBIENT, one);
  684.             glLightfv(GL_LIGHT0, GL_POSITION, position);
  685.             glLightfv(GL_LIGHT0, GL_DIFFUSE, one);
  686.             glLightfv(GL_LIGHT0, GL_SPECULAR, one);
  687. }
  689. if (rgbmode) {
  690. GLfloat ambient[] = { 0.3, 0.3, 0.1, 0.0 };
  691. GLfloat diffuse[] = { 0.7, 0.7, 0.1, 0.0 };
  692. GLfloat zero[] = { 0.0, 0.0, 0.0, 0.0 };
  694. glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
  695. glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
  696. glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero);
  697. } else {
  698. glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, plane_colors);
  699. }
  701. {
  702. glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
  703. glEnable(GL_LIGHT0);
  704. }
  705. }
  707. void lightpos(void)
  708. {
  709.     GLfloat position[] = { LX, LY, LZ, 0., };
  710.     glLightfv(GL_LIGHT0, GL_POSITION, position);
  711. }
  713. void texenv(int env)
  714. {
  715.     GLfloat colors[3][4] = { { 0., 0., 0., 0., },
  716.                              { .1, .1, .1, 0., },       /* terrain */
  717.                              { 1., 1., 1., 0., }, };    /* sky */
  718.     glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, colors[env]);
  719. }
  721. /*-------------------------------- Utility ---------------------------------*/
  723. void err_msg(int type, char* func, char* error)
  724. {
  725. char    msg[512];
  727. if (type & ERR_WARNING) {
  728. fprintf(stderr, "Warning:  ");
  729. sprintf(msg, "Warning:  %s", error);
  730. }
  731. else if (type & ERR_FATAL) {
  732. fprintf(stderr, "FATAL:  ");
  733. sprintf(msg, "FATAL:  %s", error);
  734. }
  736. fprintf(stderr, "%s: %sn", func, error);
  737. if (type & ERR_SYSERR) {
  738. perror("perror() = ");
  739. fprintf(stderr, "errno = %dn", errno);
  740. }
  741. fflush(stderr);
  743. if (type & ERR_FATAL) {
  744. exit(-1);
  745. }
  746. }
  748. void set_fog(int enable)
  749. {
  750.     fog = enable;
  751.     if (fog) {
  752.         glEnable(GL_FOG);
  753.         if (rgbmode)
  754.             glClearColor(fog_params[0], fog_params[1], fog_params[2], 1.0);
  755.         else {
  756.             glClearIndex(sky_base + FOG_LEVELS - 1);
  757.         }
  758.     } else {
  759.         glDisable(GL_FOG);
  760.         if (rgbmode)
  761.             glClearColor(0.23, 0.35, 0.78, 1.0);
  762.         else {
  763.             glClearIndex(sky_base);
  764.         }
  765.     }
  766. }
  768. void set_dither(int enable)
  769. {
  770.     dither = enable;
  771.     if (dither) {
  772.         glEnable(GL_DITHER);
  773.     } else {
  774.         glDisable(GL_DITHER);
  775.     }
  776. }