progs/demos/reflect.c

   1 /*
   2  * Demo of a reflective, texture-mapped surface with OpenGL.
   3  * Brian Paul   August 14, 1995   This file is in the public domain.
   4  *
   5  * Hardware texture mapping is highly recommended!
   6  *
   7  * The basic steps are:
   8  *    1. Render the reflective object (a polygon) from the normal viewpoint,
   9  *       setting the stencil planes = 1.
  10  *    2. Render the scene from a special viewpoint:  the viewpoint which
  11  *       is on the opposite side of the reflective plane.  Only draw where
  12  *       stencil = 1.  This draws the objects in the reflective surface.
  13  *    3. Render the scene from the original viewpoint.  This draws the
  14  *       objects in the normal fashion.  Use blending when drawing
  15  *       the reflective, textured surface.
  16  *
  17  * This is a very crude demo.  It could be much better.
  18  */
  19
  20 /*
  21  * Authors:
  22  *   Brian Paul
  23  *   Dirk Reiners (reiners@igd.fhg.de) made some modifications to this code.
  24  *   Mark Kilgard (April 1997)
  25  *   Brian Paul (April 2000 - added keyboard d/s options)
  26  *   Brian Paul (August 2005 - added multi window feature)
  27  */
  28
  29
  30 #include <assert.h>
  31 #include <math.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include "GL/glut.h"
  35 #include "showbuffer.h"
  36 #include "readtex.h"
  37
  38
  39 #define DEG2RAD (3.14159/180.0)
  40 #define TABLE_TEXTURE "../images/tile.rgb"
  41 #define MAX_OBJECTS 2
  42 #define INIT_WIDTH 400
  43 #define INIT_HEIGHT 300
  44
  45 #ifdef _WIN32
  46 #undef CreateWindowA
  47 #endif
  48
  49 struct window {
  50    int id;               /* returned by glutCreateWindow() */
  51    int width, height;
  52    GLboolean anim;
  53    GLfloat xrot, yrot;
  54    GLfloat spin;
  55    GLenum showBuffer;
  56    GLenum drawBuffer;
  57    GLuint table_list;
  58    GLuint objects_list[MAX_OBJECTS];
  59    double t0;
  60    struct window *next;
  61 };
  62
  63
  64 static struct window *FirstWindow = NULL;
  65
  66
  67 static void
  68 CreateWindow(void);
  69
  70
  71 static struct window *
  72 CurrentWindow(void)
  73 {
  74    int id = glutGetWindow();
  75    struct window *w;
  76    for (w = FirstWindow; w; w = w->next) {
  77       if (w->id == id)
  78          return w;
  79    }
  80    return NULL;
  81 }
  82
  83
  84 static GLboolean
  85 AnyAnimating(void)
  86 {
  87    struct window *w;
  88    for (w = FirstWindow; w; w = w->next) {
  89       if (w->anim)
  90          return 1;
  91    }
  92    return 0;
  93 }
  94
  95
  96 static void
  97 KillWindow(struct window *w)
  98 {
  99    struct window *win, *prev = NULL;
 100    for (win = FirstWindow; win; win = win->next) {
 101       if (win == w) {
 102          if (prev) {
 103             prev->next = win->next;
 104          }
 105          else {
 106             FirstWindow = win->next;
 107          }
 108          glutDestroyWindow(win->id);
 109          win->next = NULL;
 110          free(win);
 111          return;
 112       }
 113       prev = win;
 114    }
 115 }
 116
 117
 118 static void
 119 KillAllWindows(void)
 120 {
 121    while (FirstWindow)
 122       KillWindow(FirstWindow);
 123 }
 124
 125
 126 static GLuint
 127 MakeTable(void)
 128 {
 129    static GLfloat table_mat[] = { 1.0, 1.0, 1.0, 0.6 };
 130    static GLfloat gray[] = { 0.4, 0.4, 0.4, 1.0 };
 131    GLuint table_list;
 132
 133    table_list = glGenLists(1);
 134    glNewList( table_list, GL_COMPILE );
 135
 136    /* load table's texture */
 137    glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, table_mat );
 138    /*glMaterialfv( GL_FRONT, GL_EMISSION, gray );*/
 139    glMaterialfv( GL_FRONT, GL_DIFFUSE, table_mat );
 140    glMaterialfv( GL_FRONT, GL_AMBIENT, gray );
 141
 142    /* draw textured square for the table */
 143    glPushMatrix();
 144    glScalef( 4.0, 4.0, 4.0 );
 145    glBegin( GL_POLYGON );
 146    glNormal3f( 0.0, 1.0, 0.0 );
 147    glTexCoord2f( 0.0, 0.0 );   glVertex3f( -1.0, 0.0,  1.0 );
 148    glTexCoord2f( 1.0, 0.0 );   glVertex3f(  1.0, 0.0,  1.0 );
 149    glTexCoord2f( 1.0, 1.0 );   glVertex3f(  1.0, 0.0, -1.0 );
 150    glTexCoord2f( 0.0, 1.0 );   glVertex3f( -1.0, 0.0, -1.0 );
 151    glEnd();
 152    glPopMatrix();
 153
 154    glDisable( GL_TEXTURE_2D );
 155
 156    glEndList();
 157    return table_list;
 158 }
 159
 160
 161 static void
 162 MakeObjects(GLuint *objects_list)
 163 {
 164    GLUquadricObj *q;
 165
 166    static GLfloat cyan[] = { 0.0, 1.0, 1.0, 1.0 };
 167    static GLfloat green[] = { 0.2, 1.0, 0.2, 1.0 };
 168    static GLfloat black[] = { 0.0, 0.0, 0.0, 0.0 };
 169
 170    q = gluNewQuadric();
 171    gluQuadricDrawStyle( q, GLU_FILL );
 172    gluQuadricNormals( q, GLU_SMOOTH );
 173
 174    objects_list[0] = glGenLists(1);
 175    glNewList( objects_list[0], GL_COMPILE );
 176    glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cyan );
 177    glMaterialfv( GL_FRONT, GL_EMISSION, black );
 178    gluCylinder( q, 0.5, 0.5,  1.0, 15, 1 );
 179    glEndList();
 180
 181    objects_list[1] = glGenLists(1);
 182    glNewList( objects_list[1], GL_COMPILE );
 183    glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green );
 184    glMaterialfv( GL_FRONT, GL_EMISSION, black );
 185    gluCylinder( q, 1.5, 0.0,  2.5, 15, 1 );
 186    glEndList();
 187
 188    gluDeleteQuadric(q);
 189 }
 190
 191
 192 static void
 193 InitWindow(struct window *w)
 194 {
 195    GLint imgWidth, imgHeight;
 196    GLenum imgFormat;
 197    GLubyte *image = NULL;
 198
 199    w->table_list = MakeTable();
 200    MakeObjects(w->objects_list);
 201
 202    image = LoadRGBImage( TABLE_TEXTURE, &imgWidth, &imgHeight, &imgFormat );
 203    if (!image) {
 204       printf("Couldn't read %s\n", TABLE_TEXTURE);
 205       exit(0);
 206    }
 207
 208    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, imgWidth, imgHeight,
 209                      imgFormat, GL_UNSIGNED_BYTE, image);
 210    free(image);
 211
 212    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
 213    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
 214    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
 215    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 216
 217    glShadeModel( GL_FLAT );
 218
 219    glEnable( GL_LIGHT0 );
 220    glEnable( GL_LIGHTING );
 221
 222    glClearColor( 0.5, 0.5, 0.9, 0.0 );
 223
 224    glEnable( GL_NORMALIZE );
 225 }
 226
 227
 228 static void
 229 Reshape(int width, int height)
 230 {
 231    struct window *w = CurrentWindow();
 232    GLfloat yAspect = 2.5;
 233    GLfloat xAspect = yAspect * (float) width / (float) height;
 234    w->width = width;
 235    w->height = height;
 236    glViewport(0, 0, width, height);
 237    glMatrixMode(GL_PROJECTION);
 238    glLoadIdentity();
 239    glFrustum( -xAspect, xAspect, -yAspect, yAspect, 10.0, 30.0 );
 240    glMatrixMode(GL_MODELVIEW);
 241    glLoadIdentity();
 242 }
 243
 244
 245 static void
 246 DrawObjects(struct window *w, GLfloat eyex, GLfloat eyey, GLfloat eyez)
 247 {
 248    (void) eyex;
 249    (void) eyey;
 250    (void) eyez;
 251 #ifndef USE_ZBUFFER
 252    if (eyex<0.5) {
 253 #endif
 254       glPushMatrix();
 255       glTranslatef( 1.0, 1.5, 0.0 );
 256       glRotatef( w->spin, 1.0, 0.5, 0.0 );
 257       glRotatef( 0.5*w->spin, 0.0, 0.5, 1.0 );
 258       glCallList( w->objects_list[0] );
 259       glPopMatrix();
 260
 261       glPushMatrix();
 262       glTranslatef( -1.0, 0.85+3.0*fabs( cos(0.01*w->spin) ), 0.0 );
 263       glRotatef( 0.5*w->spin, 0.0, 0.5, 1.0 );
 264       glRotatef( w->spin, 1.0, 0.5, 0.0 );
 265       glScalef( 0.5, 0.5, 0.5 );
 266       glCallList( w->objects_list[1] );
 267       glPopMatrix();
 268 #ifndef USE_ZBUFFER
 269    }
 270    else {
 271       glPushMatrix();
 272       glTranslatef( -1.0, 0.85+3.0*fabs( cos(0.01*w->spin) ), 0.0 );
 273       glRotatef( 0.5*w->spin, 0.0, 0.5, 1.0 );
 274       glRotatef( w->spin, 1.0, 0.5, 0.0 );
 275       glScalef( 0.5, 0.5, 0.5 );
 276       glCallList( w->objects_list[1] );
 277       glPopMatrix();
 278
 279       glPushMatrix();
 280       glTranslatef( 1.0, 1.5, 0.0 );
 281       glRotatef( w->spin, 1.0, 0.5, 0.0 );
 282       glRotatef( 0.5*w->spin, 0.0, 0.5, 1.0 );
 283       glCallList( w->objects_list[0] );
 284       glPopMatrix();
 285    }
 286 #endif
 287 }
 288
 289
 290 static void
 291 DrawTable(struct window *w)
 292 {
 293    glCallList(w->table_list);
 294 }
 295
 296
 297 static void
 298 DrawWindow(void)
 299 {
 300    struct window *w = CurrentWindow();
 301    static GLfloat light_pos[] = { 0.0, 20.0, 0.0, 1.0 };
 302    GLfloat dist = 20.0;
 303    GLfloat eyex, eyey, eyez;
 304
 305    if (w->drawBuffer == GL_NONE) {
 306       glDrawBuffer(GL_BACK);
 307       glReadBuffer(GL_BACK);
 308    }
 309    else {
 310       glDrawBuffer(w->drawBuffer);
 311       glReadBuffer(w->drawBuffer);
 312    }
 313
 314    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 315
 316    if (w->drawBuffer == GL_NONE) {
 317       glDrawBuffer(GL_NONE);
 318    }
 319
 320    eyex = dist  *  cos(w->yrot * DEG2RAD)  *  cos(w->xrot * DEG2RAD);
 321    eyez = dist  *  sin(w->yrot * DEG2RAD)  *  cos(w->xrot * DEG2RAD);
 322    eyey = dist  *  sin(w->xrot * DEG2RAD);
 323
 324    /* view from top */
 325    glPushMatrix();
 326    gluLookAt( eyex, eyey, eyez, 0.0, 0.0, 0.0,  0.0, 1.0, 0.0 );
 327
 328    glLightfv( GL_LIGHT0, GL_POSITION, light_pos );
 329
 330    /* draw table into stencil planes */
 331    glDisable( GL_DEPTH_TEST );
 332    glEnable( GL_STENCIL_TEST );
 333    glStencilFunc( GL_ALWAYS, 1, 0xffffffff );
 334    glStencilOp( GL_REPLACE, GL_REPLACE, GL_REPLACE );
 335    glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
 336    DrawTable(w);
 337    glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
 338
 339    glEnable( GL_DEPTH_TEST );
 340
 341    /* render view from below (reflected viewport) */
 342    /* only draw where stencil==1 */
 343    if (eyey>0.0) {
 344       glPushMatrix();
 345
 346       glStencilFunc( GL_EQUAL, 1, 0xffffffff );  /* draw if ==1 */
 347       glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
 348       glScalef( 1.0, -1.0, 1.0 );
 349
 350       /* Reposition light in reflected space. */
 351       glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
 352
 353       DrawObjects(w, eyex, eyey, eyez);
 354       glPopMatrix();
 355
 356       /* Restore light's original unreflected position. */
 357       glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
 358    }
 359
 360    glDisable( GL_STENCIL_TEST );
 361
 362    glEnable( GL_BLEND );
 363    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 364
 365    glEnable( GL_TEXTURE_2D );
 366    DrawTable(w);
 367    glDisable( GL_TEXTURE_2D );
 368    glDisable( GL_BLEND );
 369
 370    /* view from top */
 371    glPushMatrix();
 372
 373    DrawObjects(w, eyex, eyey, eyez);
 374
 375    glPopMatrix();
 376
 377    glPopMatrix();
 378
 379    if (w->showBuffer == GL_DEPTH) {
 380       ShowDepthBuffer(w->width, w->height, 1.0, 0.0);
 381    }
 382    else if (w->showBuffer == GL_STENCIL) {
 383       ShowStencilBuffer(w->width, w->height, 255.0, 0.0);
 384    }
 385    else if (w->showBuffer == GL_ALPHA) {
 386       ShowAlphaBuffer(w->width, w->height);
 387    }
 388
 389    if (w->drawBuffer == GL_FRONT)
 390       glFinish();
 391    else
 392       glutSwapBuffers();
 393
 394    /* calc/show frame rate */
 395    {
 396       static GLint t0 = 0;
 397       static GLint frames = 0;
 398       GLint t = glutGet(GLUT_ELAPSED_TIME);
 399       frames++;
 400       if (t - t0 >= 5000) {
 401          GLfloat seconds = (t - t0) / 1000.0;
 402          GLfloat fps = frames / seconds;
 403          printf("%d frames in %g seconds = %g FPS\n", frames, seconds, fps);
 404          t0 = t;
 405          frames = 0;
 406       }
 407    }
 408 }
 409
 410
 411 static void
 412 Idle(void)
 413 {
 414    double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
 415    struct window *w;
 416    for (w = FirstWindow; w; w = w->next) {
 417       if (w->anim) {
 418          double dt;
 419          if (w->t0 < 0.0)
 420             w->t0 = t;
 421          dt = t - w->t0;
 422          w->t0 = t;
 423          w->spin += 60.0 * dt;
 424          w->yrot += 90.0 * dt;
 425          assert(w->id);
 426          glutSetWindow(w->id);
 427          glutPostRedisplay();
 428       }
 429    }
 430 }
 431
 432
 433 static void
 434 UpdateIdleFunc(void)
 435 {
 436    if (AnyAnimating())
 437       glutIdleFunc(Idle);
 438    else
 439       glutIdleFunc(NULL);
 440 }
 441
 442 static void
 443 Key(unsigned char key, int x, int y)
 444 {
 445    struct window *w = CurrentWindow();
 446    (void) x;
 447    (void) y;
 448
 449    switch (key) {
 450    case 'd':
 451       w->showBuffer = GL_DEPTH;
 452       glutPostRedisplay();
 453       break;
 454    case 's':
 455       w->showBuffer = GL_STENCIL;
 456       glutPostRedisplay();
 457       break;
 458    case 'a':
 459       w->showBuffer = GL_ALPHA;
 460       glutPostRedisplay();
 461       break;
 462    case 'c':
 463       w->showBuffer = GL_NONE;
 464       glutPostRedisplay();
 465       break;
 466    case 'f':
 467       if (w->drawBuffer == GL_FRONT)
 468          w->drawBuffer = GL_BACK;
 469       else
 470          w->drawBuffer = GL_FRONT;
 471       glutPostRedisplay();
 472       break;
 473    case '0':
 474       w->drawBuffer = GL_NONE;
 475       glutPostRedisplay();
 476       break;
 477    case ' ':
 478       w->anim = !w->anim;
 479       w->t0 = -1;
 480       UpdateIdleFunc();
 481       glutPostRedisplay();
 482       break;
 483    case 'n':
 484       CreateWindow();
 485       UpdateIdleFunc();
 486       break;
 487    case 'k':
 488       KillWindow(w);
 489       if (FirstWindow == NULL)
 490          exit(0);
 491       break;
 492    case 27:
 493       KillAllWindows();
 494       exit(0);
 495       break;
 496    default:
 497       ;
 498    }
 499 }
 500
 501
 502 static void
 503 SpecialKey(int key, int x, int y)
 504 {
 505    struct window *w = CurrentWindow();
 506    (void) x;
 507    (void) y;
 508    switch (key) {
 509       case GLUT_KEY_UP:
 510          w->xrot += 3.0;
 511          if (w->xrot > 85)
 512             w->xrot = 85;
 513          break;
 514       case GLUT_KEY_DOWN:
 515          w->xrot -= 3.0;
 516          if (w->xrot < 5)
 517             w->xrot = 5;
 518          break;
 519       case GLUT_KEY_LEFT:
 520          w->yrot += 3.0;
 521          break;
 522       case GLUT_KEY_RIGHT:
 523          w->yrot -= 3.0;
 524          break;
 525    }
 526    glutPostRedisplay();
 527 }
 528
 529
 530 static void
 531 CreateWindow(void)
 532 {
 533    char title[1000];
 534    struct window *w = (struct window *) calloc(1, sizeof(struct window));
 535
 536    glutInitWindowSize(INIT_WIDTH, INIT_HEIGHT);
 537    w->id = glutCreateWindow("foo");
 538    sprintf(title, "reflect window %d", w->id);
 539    glutSetWindowTitle(title);
 540    assert(w->id);
 541    w->width = INIT_WIDTH;
 542    w->height = INIT_HEIGHT;
 543    w->anim = GL_TRUE;
 544    w->xrot = 30.0;
 545    w->yrot = 50.0;
 546    w->spin = 0.0;
 547    w->showBuffer = GL_NONE;
 548    w->drawBuffer = GL_BACK;
 549
 550    InitWindow(w);
 551
 552    glutReshapeFunc(Reshape);
 553    glutDisplayFunc(DrawWindow);
 554    glutKeyboardFunc(Key);
 555    glutSpecialFunc(SpecialKey);
 556
 557    /* insert at head of list */
 558    w->next = FirstWindow;
 559    FirstWindow = w;
 560 }
 561
 562
 563 static void
 564 Usage(void)
 565 {
 566    printf("Keys:\n");
 567    printf("  a      - show alpha buffer\n");
 568    printf("  d      - show depth buffer\n");
 569    printf("  s      - show stencil buffer\n");
 570    printf("  c      - show color buffer\n");
 571    printf("  f      - toggle rendering to front/back color buffer\n");
 572    printf("  n      - create new window\n");
 573    printf("  k      - kill window\n");
 574    printf("  SPACE  - toggle animation\n");
 575    printf("  ARROWS - rotate scene\n");
 576 }
 577
 578
 579 int
 580 main(int argc, char *argv[])
 581 {
 582    glutInit(&argc, argv);
 583    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH |
 584                        GLUT_STENCIL | GLUT_ALPHA);
 585    CreateWindow();
 586    glutIdleFunc(Idle);
 587    Usage();
 588    glutMainLoop();
 589    return 0;
 590 }