Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 1 | /* |
| 2 | * This program is under the GNU GPL. |
| 3 | * Use at your own risk. |
| 4 | * |
| 5 | * You need TWO Voodoo Graphics boards in order to run |
| 6 | * this demo ! |
| 7 | * |
| 8 | * written by David Bucciarelli (tech.hmw@plus.it) |
| 9 | * Humanware s.r.l. |
| 10 | */ |
| 11 | |
| 12 | #include <stdio.h> |
| 13 | #include <stdlib.h> |
| 14 | #include <math.h> |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 15 | #include <string.h> |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 16 | |
| 17 | #ifdef WIN32 |
| 18 | #include <windows.h> |
| 19 | #endif |
| 20 | |
| 21 | #include <GL/glut.h> |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 22 | #include "readtex.h" |
Brian Paul | 0a355dc | 2001-03-27 17:30:51 +0000 | [diff] [blame] | 23 | #include "tunneldat.h" |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 24 | |
| 25 | #ifdef FX |
| 26 | #endif |
| 27 | |
| 28 | #ifdef XMESA |
| 29 | #include "GL/xmesa.h" |
| 30 | static int fullscreen = 1; |
| 31 | #endif |
| 32 | |
| 33 | #ifdef FX |
Daniel Borca | e9e9840 | 2003-12-19 11:26:46 +0000 | [diff] [blame] | 34 | GLint fxMesaSelectCurrentBoard(int); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 35 | #endif |
| 36 | |
| 37 | static int WIDTHC0 = 640; |
| 38 | static int HEIGHTC0 = 480; |
| 39 | |
| 40 | static int WIDTHC1 = 640; |
| 41 | static int HEIGHTC1 = 480; |
| 42 | |
Brian Paul | d49b34a | 2000-09-12 18:44:45 +0000 | [diff] [blame] | 43 | static GLint T0 = 0; |
| 44 | static GLint Frames = 0; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 45 | |
| 46 | #define NUMBLOC 5 |
| 47 | |
| 48 | #ifndef M_PI |
| 49 | #define M_PI 3.1415926535 |
| 50 | #endif |
| 51 | |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 52 | static float obs[3] = { 1000.0, 0.0, 2.0 }; |
| 53 | static float dir[3]; |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 54 | static float v = 30.; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 55 | static float alpha = 90.0; |
| 56 | static float beta = 90.0; |
| 57 | |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 58 | static int fog = 1; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 59 | static int bfcull = 1; |
| 60 | static int usetex = 1; |
| 61 | static int cstrip = 0; |
| 62 | static int help = 1; |
| 63 | static int joyavailable = 0; |
| 64 | static int joyactive = 0; |
| 65 | |
| 66 | static int channel[2]; |
| 67 | |
| 68 | static GLuint t1id, t2id; |
| 69 | |
| 70 | static void |
| 71 | inittextures(void) |
| 72 | { |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 73 | glGenTextures(1, &t1id); |
| 74 | glBindTexture(GL_TEXTURE_2D, t1id); |
| 75 | |
| 76 | if (!LoadRGBMipmaps("../images/tile.rgb", GL_RGB)) { |
| 77 | fprintf(stderr, "Error reading a texture.\n"); |
| 78 | exit(-1); |
| 79 | } |
| 80 | |
| 81 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); |
| 82 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); |
| 83 | |
| 84 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, |
| 85 | GL_LINEAR_MIPMAP_NEAREST); |
| 86 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| 87 | |
| 88 | glGenTextures(1, &t2id); |
| 89 | glBindTexture(GL_TEXTURE_2D, t2id); |
| 90 | |
| 91 | if (!LoadRGBMipmaps("../images/bw.rgb", GL_RGB)) { |
| 92 | fprintf(stderr, "Error reading a texture.\n"); |
| 93 | exit(-1); |
| 94 | } |
| 95 | |
| 96 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); |
| 97 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); |
| 98 | |
| 99 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 100 | GL_LINEAR_MIPMAP_LINEAR); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 101 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| 102 | |
| 103 | glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); |
| 104 | } |
| 105 | |
| 106 | static void |
Brian Paul | 0a355dc | 2001-03-27 17:30:51 +0000 | [diff] [blame] | 107 | drawobjs(const int *l, const float *f) |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 108 | { |
| 109 | int mend, j; |
| 110 | |
| 111 | if (cstrip) { |
| 112 | float r = 0.33, g = 0.33, b = 0.33; |
| 113 | |
| 114 | for (; (*l) != 0;) { |
| 115 | mend = *l++; |
| 116 | |
| 117 | r += 0.33; |
| 118 | if (r > 1.0) { |
| 119 | r = 0.33; |
| 120 | g += 0.33; |
| 121 | if (g > 1.0) { |
| 122 | g = 0.33; |
| 123 | b += 0.33; |
| 124 | if (b > 1.0) |
| 125 | b = 0.33; |
| 126 | } |
| 127 | } |
| 128 | |
| 129 | glColor3f(r, g, b); |
| 130 | glBegin(GL_TRIANGLE_STRIP); |
| 131 | for (j = 0; j < mend; j++) { |
| 132 | f += 4; |
| 133 | glTexCoord2fv(f); |
| 134 | f += 2; |
| 135 | glVertex3fv(f); |
| 136 | f += 3; |
| 137 | } |
| 138 | glEnd(); |
| 139 | } |
| 140 | } |
| 141 | else |
| 142 | for (; (*l) != 0;) { |
| 143 | mend = *l++; |
| 144 | |
| 145 | glBegin(GL_TRIANGLE_STRIP); |
| 146 | for (j = 0; j < mend; j++) { |
| 147 | glColor4fv(f); |
| 148 | f += 4; |
| 149 | glTexCoord2fv(f); |
| 150 | f += 2; |
| 151 | glVertex3fv(f); |
| 152 | f += 3; |
| 153 | } |
| 154 | glEnd(); |
| 155 | } |
| 156 | } |
| 157 | |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 158 | static void |
| 159 | calcposobs(void) |
| 160 | { |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 161 | static double t0 = -1.; |
| 162 | double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0; |
| 163 | if (t0 < 0.0) |
| 164 | t0 = t; |
| 165 | dt = t - t0; |
| 166 | t0 = t; |
| 167 | |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 168 | dir[0] = sin(alpha * M_PI / 180.0); |
| 169 | dir[1] = cos(alpha * M_PI / 180.0) * sin(beta * M_PI / 180.0); |
| 170 | dir[2] = cos(beta * M_PI / 180.0); |
| 171 | |
Brian Paul | a41edc3 | 2001-05-09 20:02:28 +0000 | [diff] [blame] | 172 | if (dir[0] < 1.0e-5 && dir[0] > -1.0e-5) |
| 173 | dir[0] = 0; |
| 174 | if (dir[1] < 1.0e-5 && dir[1] > -1.0e-5) |
| 175 | dir[1] = 0; |
| 176 | if (dir[2] < 1.0e-5 && dir[2] > -1.0e-5) |
| 177 | dir[2] = 0; |
| 178 | |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 179 | obs[0] += v * dir[0] * dt; |
| 180 | obs[1] += v * dir[1] * dt; |
| 181 | obs[2] += v * dir[2] * dt; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | static void |
| 185 | special(int k, int x, int y) |
| 186 | { |
| 187 | switch (k) { |
| 188 | case GLUT_KEY_LEFT: |
| 189 | alpha -= 2.0; |
| 190 | break; |
| 191 | case GLUT_KEY_RIGHT: |
| 192 | alpha += 2.0; |
| 193 | break; |
| 194 | case GLUT_KEY_DOWN: |
| 195 | beta -= 2.0; |
| 196 | break; |
| 197 | case GLUT_KEY_UP: |
| 198 | beta += 2.0; |
| 199 | break; |
| 200 | } |
| 201 | } |
| 202 | |
| 203 | static void |
Shuang He | e326600 | 2009-04-27 07:13:33 -0600 | [diff] [blame] | 204 | cleanup(void) |
| 205 | { |
| 206 | glDeleteTextures(1, &t1id); |
| 207 | glDeleteTextures(1, &t2id); |
| 208 | } |
| 209 | |
| 210 | static void |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 211 | key(unsigned char k, int x, int y) |
| 212 | { |
| 213 | switch (k) { |
| 214 | case 27: |
Brian Paul | 547e487 | 2008-07-09 15:52:04 -0600 | [diff] [blame] | 215 | glutDestroyWindow(channel[0]); |
| 216 | glutDestroyWindow(channel[1]); |
Shuang He | e326600 | 2009-04-27 07:13:33 -0600 | [diff] [blame] | 217 | cleanup(); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 218 | exit(0); |
| 219 | break; |
| 220 | |
| 221 | case 'a': |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 222 | v += 5.; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 223 | break; |
| 224 | case 'z': |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 225 | v -= 5.; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 226 | break; |
| 227 | |
| 228 | #ifdef XMESA |
| 229 | case ' ': |
| 230 | fullscreen = (!fullscreen); |
| 231 | |
| 232 | glutSetWindow(channel[0]); |
| 233 | XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW); |
| 234 | |
| 235 | glutSetWindow(channel[1]); |
| 236 | XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW); |
| 237 | break; |
| 238 | #endif |
| 239 | |
| 240 | case 'j': |
| 241 | joyactive = (!joyactive); |
| 242 | break; |
| 243 | case 'h': |
| 244 | help = (!help); |
| 245 | break; |
| 246 | case 'f': |
| 247 | fog = (!fog); |
| 248 | break; |
| 249 | case 't': |
| 250 | usetex = (!usetex); |
| 251 | break; |
| 252 | case 'b': |
| 253 | if (bfcull) { |
| 254 | glDisable(GL_CULL_FACE); |
| 255 | bfcull = 0; |
| 256 | } |
| 257 | else { |
| 258 | glEnable(GL_CULL_FACE); |
| 259 | bfcull = 1; |
| 260 | } |
| 261 | break; |
| 262 | case 'm': |
| 263 | cstrip = (!cstrip); |
| 264 | break; |
| 265 | |
| 266 | case 'd': |
| 267 | fprintf(stderr, "Deleting textures...\n"); |
| 268 | glDeleteTextures(1, &t1id); |
| 269 | glDeleteTextures(1, &t2id); |
| 270 | fprintf(stderr, "Loading textures...\n"); |
| 271 | inittextures(); |
| 272 | fprintf(stderr, "Done.\n"); |
| 273 | break; |
| 274 | } |
| 275 | } |
| 276 | |
| 277 | static void |
| 278 | reshapechannel0(int w, int h) |
| 279 | { |
| 280 | float ratio; |
| 281 | |
| 282 | WIDTHC0 = w; |
| 283 | HEIGHTC0 = h; |
| 284 | glMatrixMode(GL_PROJECTION); |
| 285 | glLoadIdentity(); |
| 286 | |
| 287 | ratio = 0.5f * w / (float) h; |
| 288 | |
| 289 | glFrustum(-2.0, 0.0, -1.0 * ratio, 1.0 * ratio, 1.0, 60.0); |
| 290 | |
| 291 | glMatrixMode(GL_MODELVIEW); |
| 292 | glLoadIdentity(); |
| 293 | glViewport(0, 0, w, h); |
| 294 | } |
| 295 | |
| 296 | static void |
| 297 | reshapechannel1(int w, int h) |
| 298 | { |
| 299 | float ratio; |
| 300 | |
| 301 | WIDTHC1 = w; |
| 302 | HEIGHTC1 = h; |
| 303 | glMatrixMode(GL_PROJECTION); |
| 304 | glLoadIdentity(); |
| 305 | |
| 306 | ratio = 0.5f * w / (float) h; |
| 307 | |
| 308 | glFrustum(0.0, 2.0, -1.0 * ratio, 1.0 * ratio, 1.0, 60.0); |
| 309 | |
| 310 | glMatrixMode(GL_MODELVIEW); |
| 311 | glLoadIdentity(); |
| 312 | glViewport(0, 0, w, h); |
| 313 | } |
| 314 | |
| 315 | static void |
| 316 | printstring(void *font, char *string) |
| 317 | { |
| 318 | int len, i; |
| 319 | |
| 320 | len = (int) strlen(string); |
| 321 | for (i = 0; i < len; i++) |
| 322 | glutBitmapCharacter(font, string[i]); |
| 323 | } |
| 324 | |
| 325 | static void |
| 326 | printhelp(void) |
| 327 | { |
| 328 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
| 329 | glColor4f(0.0, 0.0, 0.0, 0.5); |
| 330 | glRecti(40, 40, 600, 440); |
| 331 | |
| 332 | glColor3f(1.0, 0.0, 0.0); |
| 333 | glRasterPos2i(300, 420); |
| 334 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "Help"); |
| 335 | |
| 336 | glRasterPos2i(60, 390); |
Brian Paul | c39a4bc | 2005-04-04 20:06:40 +0000 | [diff] [blame] | 337 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "h - Toggle Help"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 338 | glRasterPos2i(60, 360); |
Brian Paul | c39a4bc | 2005-04-04 20:06:40 +0000 | [diff] [blame] | 339 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "t - Toggle Textures"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 340 | glRasterPos2i(60, 330); |
Brian Paul | c39a4bc | 2005-04-04 20:06:40 +0000 | [diff] [blame] | 341 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "f - Toggle Fog"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 342 | glRasterPos2i(60, 300); |
Brian Paul | c39a4bc | 2005-04-04 20:06:40 +0000 | [diff] [blame] | 343 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "m - Toggle strips"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 344 | glRasterPos2i(60, 270); |
Brian Paul | c39a4bc | 2005-04-04 20:06:40 +0000 | [diff] [blame] | 345 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "b - Toggle Back face culling"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 346 | glRasterPos2i(60, 240); |
| 347 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "Arrow Keys - Rotate"); |
| 348 | glRasterPos2i(60, 210); |
| 349 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "a - Increase velocity"); |
| 350 | glRasterPos2i(60, 180); |
| 351 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, "z - Decrease velocity"); |
| 352 | |
| 353 | glRasterPos2i(60, 150); |
| 354 | if (joyavailable) |
| 355 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, |
Brian Paul | c39a4bc | 2005-04-04 20:06:40 +0000 | [diff] [blame] | 356 | "j - Toggle jostick control (Joystick control available)"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 357 | else |
| 358 | printstring(GLUT_BITMAP_TIMES_ROMAN_24, |
| 359 | "(No Joystick control available)"); |
| 360 | } |
| 361 | |
| 362 | static void |
| 363 | dojoy(void) |
| 364 | { |
| 365 | #ifdef WIN32 |
| 366 | static UINT max[2] = { 0, 0 }; |
| 367 | static UINT min[2] = { 0xffffffff, 0xffffffff }, center[2]; |
| 368 | MMRESULT res; |
| 369 | JOYINFO joy; |
| 370 | |
| 371 | res = joyGetPos(JOYSTICKID1, &joy); |
| 372 | |
| 373 | if (res == JOYERR_NOERROR) { |
| 374 | joyavailable = 1; |
| 375 | |
| 376 | if (max[0] < joy.wXpos) |
| 377 | max[0] = joy.wXpos; |
| 378 | if (min[0] > joy.wXpos) |
| 379 | min[0] = joy.wXpos; |
| 380 | center[0] = (max[0] + min[0]) / 2; |
| 381 | |
| 382 | if (max[1] < joy.wYpos) |
| 383 | max[1] = joy.wYpos; |
| 384 | if (min[1] > joy.wYpos) |
| 385 | min[1] = joy.wYpos; |
| 386 | center[1] = (max[1] + min[1]) / 2; |
| 387 | |
| 388 | if (joyactive) { |
| 389 | if (fabs(center[0] - (float) joy.wXpos) > 0.1 * (max[0] - min[0])) |
| 390 | alpha -= |
| 391 | 2.0 * (center[0] - (float) joy.wXpos) / (max[0] - min[0]); |
| 392 | if (fabs(center[1] - (float) joy.wYpos) > 0.1 * (max[1] - min[1])) |
| 393 | beta += 2.0 * (center[1] - (float) joy.wYpos) / (max[1] - min[1]); |
| 394 | |
| 395 | if (joy.wButtons & JOY_BUTTON1) |
| 396 | v += 0.01; |
| 397 | if (joy.wButtons & JOY_BUTTON2) |
| 398 | v -= 0.01; |
| 399 | } |
| 400 | } |
| 401 | else |
| 402 | joyavailable = 0; |
| 403 | #endif |
| 404 | } |
| 405 | |
| 406 | static void |
| 407 | draw(void) |
| 408 | { |
Brian Paul | d49b34a | 2000-09-12 18:44:45 +0000 | [diff] [blame] | 409 | static char frbuf[80] = ""; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 410 | int i; |
Brian Paul | d49b34a | 2000-09-12 18:44:45 +0000 | [diff] [blame] | 411 | float base, offset; |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 412 | |
| 413 | dojoy(); |
| 414 | |
| 415 | glClear(GL_COLOR_BUFFER_BIT); |
| 416 | |
| 417 | glClear(GL_COLOR_BUFFER_BIT); |
| 418 | |
| 419 | if (usetex) |
| 420 | glEnable(GL_TEXTURE_2D); |
| 421 | else |
| 422 | glDisable(GL_TEXTURE_2D); |
| 423 | |
| 424 | if (fog) |
| 425 | glEnable(GL_FOG); |
| 426 | else |
| 427 | glDisable(GL_FOG); |
| 428 | |
| 429 | glShadeModel(GL_SMOOTH); |
| 430 | |
| 431 | glPushMatrix(); |
| 432 | calcposobs(); |
| 433 | gluLookAt(obs[0], obs[1], obs[2], |
| 434 | obs[0] + dir[0], obs[1] + dir[1], obs[2] + dir[2], |
| 435 | 0.0, 0.0, 1.0); |
| 436 | |
| 437 | if (dir[0] > 0) { |
| 438 | offset = 8.0; |
| 439 | base = obs[0] - fmod(obs[0], 8.0); |
| 440 | } |
| 441 | else { |
| 442 | offset = -8.0; |
| 443 | base = obs[0] + (8.0 - fmod(obs[0], 8.0)); |
| 444 | } |
| 445 | |
| 446 | glPushMatrix(); |
| 447 | glTranslatef(base - offset / 2.0, 0.0, 0.0); |
| 448 | for (i = 0; i < NUMBLOC; i++) { |
| 449 | glTranslatef(offset, 0.0, 0.0); |
| 450 | glBindTexture(GL_TEXTURE_2D, t1id); |
| 451 | drawobjs(striplength_skin_11, stripdata_skin_11); |
| 452 | glBindTexture(GL_TEXTURE_2D, t2id); |
| 453 | drawobjs(striplength_skin_12, stripdata_skin_12); |
| 454 | drawobjs(striplength_skin_9, stripdata_skin_9); |
| 455 | drawobjs(striplength_skin_13, stripdata_skin_13); |
| 456 | } |
| 457 | glPopMatrix(); |
| 458 | glPopMatrix(); |
| 459 | |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 460 | glDisable(GL_TEXTURE_2D); |
| 461 | glDisable(GL_FOG); |
| 462 | glShadeModel(GL_FLAT); |
| 463 | |
| 464 | glMatrixMode(GL_PROJECTION); |
| 465 | glPushMatrix(); |
| 466 | glLoadIdentity(); |
| 467 | glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0); |
| 468 | |
| 469 | glMatrixMode(GL_MODELVIEW); |
| 470 | glLoadIdentity(); |
| 471 | |
| 472 | glColor3f(1.0, 0.0, 0.0); |
| 473 | glRasterPos2i(10, 10); |
| 474 | printstring(GLUT_BITMAP_HELVETICA_18, frbuf); |
| 475 | glRasterPos2i(350, 470); |
| 476 | printstring(GLUT_BITMAP_HELVETICA_10, |
| 477 | "Tunnel2 V1.0 Written by David Bucciarelli (tech.hmw@plus.it)"); |
| 478 | |
| 479 | if (help) |
| 480 | printhelp(); |
| 481 | |
| 482 | glMatrixMode(GL_PROJECTION); |
| 483 | glPopMatrix(); |
| 484 | glMatrixMode(GL_MODELVIEW); |
| 485 | |
Brian Paul | d49b34a | 2000-09-12 18:44:45 +0000 | [diff] [blame] | 486 | Frames++; |
| 487 | { |
| 488 | GLint t = glutGet(GLUT_ELAPSED_TIME); |
| 489 | if (t - T0 >= 2000) { |
| 490 | GLfloat seconds = (t - T0) / 1000.0; |
| 491 | GLfloat fps = Frames / seconds; |
| 492 | sprintf(frbuf, "Frame rate: %f", fps); |
| 493 | T0 = t; |
| 494 | Frames = 0; |
| 495 | } |
| 496 | } |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 497 | } |
| 498 | |
| 499 | static void |
| 500 | drawchannel0(void) |
| 501 | { |
| 502 | glutSetWindow(channel[0]); |
| 503 | draw(); |
| 504 | glutSwapBuffers(); |
| 505 | } |
| 506 | |
| 507 | static void |
| 508 | drawchannel1(void) |
| 509 | { |
| 510 | glutSetWindow(channel[1]); |
| 511 | draw(); |
| 512 | glutSwapBuffers(); |
| 513 | } |
| 514 | |
| 515 | static void |
| 516 | drawall(void) |
| 517 | { |
| 518 | glutSetWindow(channel[0]); |
| 519 | draw(); |
| 520 | glutSetWindow(channel[1]); |
| 521 | draw(); |
| 522 | |
| 523 | glutSetWindow(channel[0]); |
| 524 | glutSwapBuffers(); |
| 525 | glutSetWindow(channel[1]); |
| 526 | glutSwapBuffers(); |
| 527 | } |
| 528 | |
| 529 | static void |
| 530 | init(void) |
| 531 | { |
| 532 | float fogcolor[4] = { 0.7, 0.7, 0.7, 1.0 }; |
| 533 | |
| 534 | glShadeModel(GL_SMOOTH); |
| 535 | glDisable(GL_DEPTH_TEST); |
| 536 | glEnable(GL_CULL_FACE); |
| 537 | glEnable(GL_TEXTURE_2D); |
| 538 | |
| 539 | glEnable(GL_FOG); |
| 540 | glFogi(GL_FOG_MODE, GL_EXP2); |
| 541 | glFogfv(GL_FOG_COLOR, fogcolor); |
| 542 | |
| 543 | glFogf(GL_FOG_DENSITY, 0.06); |
| 544 | glHint(GL_FOG_HINT, GL_NICEST); |
| 545 | |
| 546 | glEnable(GL_BLEND); |
| 547 | /* |
| 548 | glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE); |
| 549 | glEnable(GL_POLYGON_SMOOTH); |
| 550 | */ |
| 551 | |
| 552 | glClearColor(fogcolor[0], fogcolor[1], fogcolor[2], fogcolor[3]); |
| 553 | glClear(GL_COLOR_BUFFER_BIT); |
| 554 | } |
| 555 | |
| 556 | int |
| 557 | main(int ac, char **av) |
| 558 | { |
| 559 | fprintf(stderr, |
| 560 | "Tunnel2 V1.0\nWritten by David Bucciarelli (tech.hmw@plus.it)\n"); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 561 | |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 562 | glutInitWindowSize(WIDTHC0, HEIGHTC0); |
| 563 | glutInit(&ac, av); |
| 564 | |
Brian Paul | d49b34a | 2000-09-12 18:44:45 +0000 | [diff] [blame] | 565 | glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 566 | |
| 567 | #ifdef FX |
Daniel Borca | e9e9840 | 2003-12-19 11:26:46 +0000 | [diff] [blame] | 568 | if (fxMesaSelectCurrentBoard(0) < 0) { |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 569 | fprintf(stderr, "The first Voodoo Graphics board is missing !?!?\n"); |
| 570 | return -1; |
| 571 | } |
| 572 | #endif |
| 573 | if (!(channel[0] = glutCreateWindow("Channel 0"))) { |
| 574 | fprintf(stderr, "Error, couldn't open window\n"); |
| 575 | return -1; |
| 576 | } |
| 577 | |
| 578 | reshapechannel0(WIDTHC0, HEIGHTC0); |
| 579 | init(); |
| 580 | inittextures(); |
| 581 | glutDisplayFunc(drawchannel0); |
| 582 | glutReshapeFunc(reshapechannel0); |
| 583 | glutKeyboardFunc(key); |
| 584 | glutSpecialFunc(special); |
| 585 | |
| 586 | #ifdef FX |
Daniel Borca | e9e9840 | 2003-12-19 11:26:46 +0000 | [diff] [blame] | 587 | if (fxMesaSelectCurrentBoard(1) < 0) { |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 588 | fprintf(stderr, "The second Voodoo Graphics board is missing !\n"); |
| 589 | exit(-1); |
| 590 | } |
| 591 | #endif |
| 592 | glutInitWindowPosition(WIDTHC0, 0); |
| 593 | glutInitWindowSize(WIDTHC1, HEIGHTC1); |
| 594 | if (!(channel[1] = glutCreateWindow("Channel 1"))) { |
| 595 | fprintf(stderr, "Error, couldn't open window\n"); |
| 596 | exit(-1); |
| 597 | } |
| 598 | |
| 599 | reshapechannel1(WIDTHC1, HEIGHTC1); |
| 600 | init(); |
| 601 | inittextures(); |
| 602 | glutDisplayFunc(drawchannel1); |
| 603 | glutReshapeFunc(reshapechannel1); |
| 604 | glutKeyboardFunc(key); |
| 605 | glutSpecialFunc(special); |
| 606 | |
| 607 | glutIdleFunc(drawall); |
| 608 | |
| 609 | calcposobs(); |
| 610 | |
| 611 | glutMainLoop(); |
Shuang He | e326600 | 2009-04-27 07:13:33 -0600 | [diff] [blame] | 612 | cleanup(); |
Brian Paul | 5b0a7f3 | 2000-06-27 16:52:38 +0000 | [diff] [blame] | 613 | |
| 614 | return 0; |
| 615 | } |