git.hungrycats.org Git - xscreensaver/blob - hacks/glx/endgame.c

   1 /*
   2  * endgame.c
   3  * plays through a chess game ending.  enjoy.
   4  *
   5  * version 1.0 - June 6, 2002
   6  *
   7  * Copyright (C) 2002-2008 Blair Tennessy (tennessb@unbc.ca)
   8  *
   9  * Permission to use, copy, modify, distribute, and sell this software and its
  10  * documentation for any purpose is hereby granted without fee, provided that
  11  * the above copyright notice appear in all copies and that both that
  12  * copyright notice and this permission notice appear in supporting
  13  * documentation.  No representations are made about the suitability of this
  14  * software for any purpose.  It is provided "as is" without express or
  15  * implied warranty.
  16  */
  17
  18 #ifdef STANDALONE
  19 #define DEFAULTS       "*delay:     20000 \n" \
  20                        "*showFPS:   False \n" \
  21                        "*wireframe: False \n" \
  22
  23 # define refresh_chess 0
  24 # include "xlockmore.h"
  25
  26 #else
  27 # include "xlock.h"
  28 #endif
  29
  30 #ifdef USE_GL
  31
  32 #define BOARDSIZE 8
  33 #define WHITES 5
  34
  35 #include "gltrackball.h"
  36 #include "chessmodels.h"
  37 #include "chessgames.h"
  38
  39 #undef countof
  40 #define countof(x) (sizeof((x))/sizeof((*x)))
  41
  42 #define DEF_ROTATE      "True"
  43 #define DEF_REFLECTIONS "True"
  44 #define DEF_SHADOWS     "True"
  45 #define DEF_SMOOTH      "True"
  46 #define DEF_CLASSIC     "False"
  47
  48
  49 static XrmOptionDescRec opts[] = {
  50   {"+rotate", ".chess.rotate", XrmoptionNoArg, "false" },
  51   {"-rotate", ".chess.rotate", XrmoptionNoArg, "true" },
  52   {"+reflections", ".chess.reflections", XrmoptionNoArg, "false" },
  53   {"-reflections", ".chess.reflections", XrmoptionNoArg, "true" },
  54   {"+shadows", ".chess.shadows", XrmoptionNoArg, "false" },
  55   {"-shadows", ".chess.shadows", XrmoptionNoArg, "true" },
  56   {"+smooth", ".chess.smooth", XrmoptionNoArg, "false" },
  57   {"-smooth", ".chess.smooth", XrmoptionNoArg, "true" },
  58   {"+classic", ".chess.classic", XrmoptionNoArg, "false" },
  59   {"-classic", ".chess.classic", XrmoptionNoArg, "true" },
  60 };
  61
  62 static int rotate, reflections, smooth, shadows, classic;
  63
  64 static argtype vars[] = {
  65   {&rotate,      "rotate",      "Rotate",      DEF_ROTATE, t_Bool},
  66   {&reflections, "reflections", "Reflections", DEF_REFLECTIONS, t_Bool},
  67   {&shadows,     "shadows",      "Shadows",    DEF_SHADOWS, t_Bool},
  68   {&smooth,      "smooth",      "Smooth",      DEF_SMOOTH, t_Bool},
  69   {&classic,     "classic",     "Classic",     DEF_CLASSIC, t_Bool},
  70 };
  71
  72 ENTRYPOINT ModeSpecOpt chess_opts = {countof(opts), opts, countof(vars), vars, NULL};
  73
  74 #ifdef USE_MODULES
  75 ModStruct   chess_description =
  76 {"chess", "init_chess", "draw_chess", "release_chess",
  77  "draw_chess", "init_chess", NULL, &chess_opts,
  78  1000, 1, 2, 1, 4, 1.0, "",
  79  "Chess", 0, NULL};
  80
  81 #endif
  82
  83 #define checkImageWidth 16
  84 #define checkImageHeight 16
  85
  86 typedef struct {
  87   GLXContext *glx_context;
  88   Window window;
  89   trackball_state *trackball;
  90   Bool button_down_p;
  91
  92   ChessGame game;
  93   int oldwhite;
  94
  95   /** definition of white/black (orange/gray) colors */
  96   GLfloat colors[2][3];
  97
  98   GLubyte checkImage[checkImageWidth][checkImageHeight][3];
  99   GLuint piecetexture, boardtexture;
 100
 101   int mpiece, tpiece, steps, done;
 102   double from[2], to[2];
 103   double dx, dz;
 104   int moving, take, mc, count, wire;
 105   double theta;
 106
 107   GLfloat position[4];
 108   GLfloat position2[4];
 109
 110   GLfloat mod;
 111
 112   GLfloat ground[4];
 113
 114   int oldgame;
 115
 116   int poly_counts[PIECES];  /* polygon count of each type of piece */
 117
 118
 119 } Chesscreen;
 120
 121 static Chesscreen *qs = NULL;
 122
 123 static const GLfloat MaterialShadow[] =   {0.0, 0.0, 0.0, 0.3};
 124
 125
 126 /* i prefer silvertip */
 127 static const GLfloat whites[WHITES][3] =
 128   {
 129     {1.0, 0.55, 0.1},
 130     {0.8, 0.52, 0.8},
 131     {0.43, 0.54, 0.76},
 132     {0.2, 0.2, 0.2},
 133     {0.35, 0.60, 0.35},
 134   };
 135
 136 static void build_colors(Chesscreen *cs)
 137 {
 138
 139   /* find new white */
 140   int newwhite = cs->oldwhite;
 141   while(newwhite == cs->oldwhite)
 142     newwhite = random()%WHITES;
 143   cs->oldwhite = newwhite;
 144
 145   cs->colors[0][0] = whites[cs->oldwhite][0];
 146   cs->colors[0][1] = whites[cs->oldwhite][1];
 147   cs->colors[0][2] = whites[cs->oldwhite][2];
 148 }
 149
 150 /* build piece texture */
 151 static void make_piece_texture(Chesscreen *cs)
 152 {
 153   int i, j, c;
 154
 155   for (i = 0; i < checkImageWidth; i++) {
 156     for (j = 0; j < checkImageHeight; j++) {
 157       c = ((j%2) == 0 || i%2 == 0) ? 240 : 180+random()%16;
 158       cs->checkImage[i][j][0] = (GLubyte) c;
 159       cs->checkImage[i][j][1] = (GLubyte) c;
 160       cs->checkImage[i][j][2] = (GLubyte) c;
 161     }
 162   }
 163
 164   glGenTextures(1, &cs->piecetexture);
 165   glBindTexture(GL_TEXTURE_2D, cs->piecetexture);
 166
 167   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 168   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 169   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
 170   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 171   glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
 172                checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
 173                &cs->checkImage[0][0]);
 174 }
 175
 176 /* build board texture (uniform noise in [180,180+50]) */
 177 static void make_board_texture(Chesscreen *cs)
 178 {
 179   int i, j, c;
 180
 181   for (i = 0; i < checkImageWidth; i++) {
 182     for (j = 0; j < checkImageHeight; j++) {
 183       c = 180 + random()%51;
 184       cs->checkImage[i][j][0] = (GLubyte) c;
 185       cs->checkImage[i][j][1] = (GLubyte) c;
 186       cs->checkImage[i][j][2] = (GLubyte) c;
 187     }
 188   }
 189
 190   glGenTextures(1, &cs->boardtexture);
 191   glBindTexture(GL_TEXTURE_2D, cs->boardtexture);
 192
 193   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 194   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 195   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
 196   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 197   glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
 198                checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
 199                &cs->checkImage[0][0]);
 200 }
 201
 202 /** handle X event (trackball) */
 203 ENTRYPOINT Bool chess_handle_event (ModeInfo *mi, XEvent *event)
 204 {
 205   Chesscreen *cs = &qs[MI_SCREEN(mi)];
 206
 207   if(event->xany.type == ButtonPress && event->xbutton.button == Button1) {
 208     cs->button_down_p = True;
 209     gltrackball_start (cs->trackball,
 210                        event->xbutton.x, event->xbutton.y,
 211                        MI_WIDTH (mi), MI_HEIGHT (mi));
 212     return True;
 213   }
 214   else if(event->xany.type == ButtonRelease
 215           && event->xbutton.button == Button1) {
 216     cs->button_down_p = False;
 217     return True;
 218   }
 219   else if (event->xany.type == ButtonPress &&
 220            (event->xbutton.button == Button4 ||
 221             event->xbutton.button == Button5 ||
 222             event->xbutton.button == Button6 ||
 223             event->xbutton.button == Button7))
 224     {
 225       gltrackball_mousewheel (cs->trackball, event->xbutton.button, 5,
 226                               !event->xbutton.state);
 227       return True;
 228     }
 229   else if(event->xany.type == MotionNotify && cs->button_down_p) {
 230     gltrackball_track (cs->trackball,
 231                        event->xmotion.x, event->xmotion.y,
 232                        MI_WIDTH (mi), MI_HEIGHT (mi));
 233     return True;
 234   }
 235
 236   return False;
 237 }
 238
 239 static const GLfloat diffuse2[] = {1.0, 1.0, 1.0, 1.0};
 240 /*static const GLfloat ambient2[] = {0.7, 0.7, 0.7, 1.0};*/
 241 static const GLfloat shininess[] = {60.0};
 242 static const GLfloat specular[] = {0.4, 0.4, 0.4, 1.0};
 243
 244 /* configure lighting */
 245 static void setup_lights(Chesscreen *cs)
 246 {
 247   glEnable(GL_LIGHTING);
 248   glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
 249   glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse2);
 250   glEnable(GL_LIGHT0);
 251
 252 /*   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient2); */
 253
 254   glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
 255   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
 256
 257   glLightfv(GL_LIGHT1, GL_SPECULAR, diffuse2);
 258   glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse2);
 259   glEnable(GL_LIGHT1);
 260 }
 261
 262 /* draw pieces */
 263 static void drawPieces(ModeInfo *mi, Chesscreen *cs)
 264 {
 265   int i, j;
 266
 267   for(i = 0; i < BOARDSIZE; ++i) {
 268     for(j = 0; j < BOARDSIZE; ++j) {
 269       if(cs->game.board[i][j]) {
 270         int c = cs->game.board[i][j]/PIECES;
 271         glColor3fv(cs->colors[c]);
 272         glCallList(cs->game.board[i][j]%PIECES);
 273         mi->polygon_count += cs->poly_counts[cs->game.board[i][j]%PIECES];
 274       }
 275
 276       glTranslatef(1.0, 0.0, 0.0);
 277     }
 278
 279     glTranslatef(-1.0*BOARDSIZE, 0.0, 1.0);
 280   }
 281
 282   glTranslatef(0.0, 0.0, -1.0*BOARDSIZE);
 283 }
 284
 285 /* draw pieces */
 286 static void drawPiecesShadow(ModeInfo *mi, Chesscreen *cs)
 287 {
 288   int i, j;
 289
 290   for(i = 0; i < BOARDSIZE; ++i) {
 291     for(j = 0; j < BOARDSIZE; ++j) {
 292       if(cs->game.board[i][j]) {
 293         glColor4f(0.0, 0.0, 0.0, 0.4);
 294         glCallList(cs->game.board[i][j]%PIECES);
 295         mi->polygon_count += cs->poly_counts[cs->game.board[i][j]%PIECES];
 296       }
 297
 298       glTranslatef(1.0, 0.0, 0.0);
 299     }
 300
 301     glTranslatef(-1.0*BOARDSIZE, 0.0, 1.0);
 302   }
 303
 304   glTranslatef(0.0, 0.0, -1.0*BOARDSIZE);
 305 }
 306
 307 /* draw a moving piece */
 308 static void drawMovingPiece(ModeInfo *mi, Chesscreen *cs, int shadow)
 309 {
 310   int piece = cs->mpiece % PIECES;
 311
 312   glPushMatrix();
 313
 314   if(shadow) glColor4fv(MaterialShadow);
 315   else glColor3fv(cs->colors[cs->mpiece/PIECES]);
 316
 317   /** assume a queening.  should be more general */
 318   if((cs->mpiece == PAWN  && fabs(cs->to[0]) < 0.01) ||
 319      (cs->mpiece == BPAWN && fabs(cs->to[0]-7.0) < 0.01)) {
 320     glTranslatef(cs->from[1]+cs->steps*cs->dx, 0.0, cs->from[0]+cs->steps*cs->dz);
 321
 322     glColor4f(shadow ? MaterialShadow[0] : cs->colors[cs->mpiece/7][0],
 323               shadow ? MaterialShadow[1] : cs->colors[cs->mpiece/7][1],
 324               shadow ? MaterialShadow[2] : cs->colors[cs->mpiece/7][2],
 325               (fabs(50.0-cs->steps))/50.0);
 326
 327     piece = cs->steps < 50 ? PAWN : QUEEN;
 328
 329     /* what a kludge */
 330     if(cs->steps == 99)
 331       cs->mpiece = cs->mpiece == PAWN ? QUEEN : BQUEEN;
 332   }
 333   else if(cs->mpiece % PIECES == KNIGHT) {
 334     GLfloat shine[1];
 335     GLfloat spec[4];
 336     GLfloat mult;
 337     glTranslatef(cs->steps < 50 ? cs->from[1] : cs->to[1], 0.0,
 338                  cs->steps < 50 ? cs->from[0] : cs->to[0]);
 339
 340     mult = cs->steps < 10
 341       ? (1.0 - cs->steps / 10.0) : 100 - cs->steps < 10
 342       ? (1.0 - (100 - cs->steps) / 10.0) : 0.0;
 343
 344     shine[0] = mult*shininess[0];
 345     spec[0] = mult*specular[0];
 346     spec[1] = mult*specular[1];
 347     spec[2] = mult*specular[2];
 348     spec[3] = 1.0;
 349     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shine);
 350     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spec);
 351
 352     glColor4f(shadow ? MaterialShadow[0] : cs->colors[cs->mpiece/7][0],
 353               shadow ? MaterialShadow[1] : cs->colors[cs->mpiece/7][1],
 354               shadow ? MaterialShadow[2] : cs->colors[cs->mpiece/7][2],
 355               fabs(49-cs->steps)/49.0);
 356
 357     glScalef(fabs(49-cs->steps)/49.0, fabs(49-cs->steps)/49.0, fabs(49-cs->steps)/49.0);
 358   }
 359   else
 360     glTranslatef(cs->from[1]+cs->steps*cs->dx, 0.0, cs->from[0]+cs->steps*cs->dz);
 361
 362   if(!cs->wire)
 363     glEnable(GL_BLEND);
 364
 365   glCallList(piece);
 366   mi->polygon_count += cs->poly_counts[cs->mpiece % PIECES];
 367
 368   glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
 369   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
 370
 371   glPopMatrix();
 372
 373   if(!cs->wire)
 374     glDisable(GL_BLEND);
 375 }
 376
 377 /** code to squish a taken piece */
 378 static void drawTakePiece(ModeInfo *mi, Chesscreen *cs, int shadow)
 379 {
 380   if(!cs->wire)
 381     glEnable(GL_BLEND);
 382
 383   glColor4f(shadow ? MaterialShadow[0] : cs->colors[cs->tpiece/7][0],
 384             shadow ? MaterialShadow[1] : cs->colors[cs->tpiece/7][1],
 385             shadow ? MaterialShadow[2] : cs->colors[cs->tpiece/7][2],
 386             (100-1.6*cs->steps)/100.0);
 387
 388   glTranslatef(cs->to[1], 0.0, cs->to[0]);
 389
 390   if(cs->mpiece % PIECES == KNIGHT)
 391     glScalef(1.0+cs->steps/100.0, 1.0, 1.0+cs->steps/100.0);
 392   else
 393     glScalef(1.0, 1 - cs->steps/50.0 > 0.01 ? 1 - cs->steps/50.0 : 0.01, 1.0);
 394   glCallList(cs->tpiece % 7);
 395   mi->polygon_count += cs->poly_counts[cs->tpiece % PIECES];
 396
 397   if(!cs->wire)
 398     glDisable(GL_BLEND);
 399 }
 400
 401 /** draw board */
 402 static void drawBoard(ModeInfo *mi, Chesscreen *cs)
 403 {
 404   int i, j;
 405
 406   glBegin(GL_QUADS);
 407
 408   for(i = 0; i < BOARDSIZE; ++i)
 409     for(j = 0; j < BOARDSIZE; ++j) {
 410       double ma1 = (i+j)%2 == 0 ? cs->mod*i : 0.0;
 411       double mb1 = (i+j)%2 == 0 ? cs->mod*j : 0.0;
 412       double ma2 = (i+j)%2 == 0 ? cs->mod*(i+1.0) : 0.01;
 413       double mb2 = (i+j)%2 == 0 ? cs->mod*(j+1.0) : 0.01;
 414
 415       /*glColor3fv(colors[(i+j)%2]);*/
 416       glColor4f(cs->colors[(i+j)%2][0], cs->colors[(i+j)%2][1],
 417                 cs->colors[(i+j)%2][2], 0.65);
 418
 419       glNormal3f(0.0, 1.0, 0.0);
 420 /*       glTexCoord2f(mod*i, mod*(j+1.0)); */
 421       glTexCoord2f(ma1, mb2);
 422       glVertex3f(i, 0.0, j + 1.0);
 423 /*       glTexCoord2f(mod*(i+1.0), mod*(j+1.0)); */
 424       glTexCoord2f(ma2, mb2);
 425       glVertex3f(i + 1.0, 0.0, j + 1.0);
 426       glTexCoord2f(ma2, mb1);
 427 /*       glTexCoord2f(mod*(i+1.0), mod*j); */
 428       glVertex3f(i + 1.0, 0.0, j);
 429       glTexCoord2f(ma1, mb1);
 430 /*       glTexCoord2f(mod*i, mod*j); */
 431       glVertex3f(i, 0.0, j);
 432
 433       mi->polygon_count++;
 434     }
 435
 436   /* chop underneath board */
 437 /*   glColor3f(0, 0, 0); */
 438 /*   glNormal3f(0, -1, 0); */
 439 /*   glVertex3f(0,         0,  BOARDSIZE); */
 440 /*   glVertex3f(0,         0,  0); */
 441 /*   glVertex3f(BOARDSIZE, 0,  0); */
 442 /*   glVertex3f(BOARDSIZE, 0,  BOARDSIZE); */
 443   glEnd();
 444 }
 445
 446 static void draw_pieces(ModeInfo *mi, Chesscreen *cs, int wire)
 447 {
 448   if (!cs->wire) {
 449     glEnable(GL_TEXTURE_2D);
 450     glBindTexture(GL_TEXTURE_2D, cs->piecetexture);
 451     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 452
 453     glColor4f(0.5, 0.5, 0.5, 1.0);
 454     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialShadow);
 455   }
 456
 457   drawPieces(mi, cs);
 458   if(cs->moving) drawMovingPiece(mi, cs, 0);
 459   if(cs->take) drawTakePiece(mi, cs, 0);
 460   glDisable(GL_TEXTURE_2D);
 461 }
 462
 463 static void draw_shadow_pieces(ModeInfo *mi, Chesscreen *cs, int wire)
 464 {
 465   if (!cs->wire) {
 466     glEnable(GL_TEXTURE_2D);
 467     glBindTexture(GL_TEXTURE_2D, cs->piecetexture);
 468     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 469   }
 470
 471   /* use the stencil */
 472   glDisable(GL_LIGHTING);
 473   glDisable(GL_COLOR_MATERIAL);
 474   glDisable(GL_DEPTH_TEST);
 475   glDisable(GL_TEXTURE_2D);
 476   glDisable(GL_BLEND);
 477
 478   glClear(GL_STENCIL_BUFFER_BIT);
 479   glColorMask(0,0,0,0);
 480   glEnable(GL_STENCIL_TEST);
 481
 482   glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFFL);
 483   glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
 484
 485
 486   glPushMatrix();
 487   glTranslatef(0.0, 0.001, 0.0);
 488
 489   /* draw the pieces */
 490   drawPiecesShadow(mi, cs);
 491   if(cs->moving) drawMovingPiece(mi, cs, shadows);
 492   if(cs->take) drawTakePiece(mi, cs, shadows);
 493
 494   glPopMatrix();
 495
 496
 497   /* turn on drawing into colour buffer */
 498   glColorMask(1,1,1,1);
 499
 500   /* programming with effect */
 501   glDisable(GL_LIGHTING);
 502   glDisable(GL_COLOR_MATERIAL);
 503   glDisable(GL_TEXTURE_2D);
 504
 505   /* now draw the union of the shadows */
 506
 507   /*
 508      <todo>
 509      want to keep alpha values (alpha is involved in transition
 510      effects of the active pieces).
 511      </todo>
 512   */
 513   glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFFL);
 514   glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 515
 516   glEnable(GL_BLEND);
 517
 518   glColor4fv(MaterialShadow);
 519
 520   /* draw the board generously to fill the shadows */
 521   glBegin(GL_QUADS);
 522
 523   glVertex3f(-1.0, 0.0, -1.0);
 524   glVertex3f(-1.0, 0.0, BOARDSIZE + 1.0);
 525   glVertex3f(1.0 + BOARDSIZE, 0.0, BOARDSIZE + 1.0);
 526   glVertex3f(1.0 + BOARDSIZE, 0.0, -1.0);
 527
 528   glEnd();
 529
 530   glDisable(GL_STENCIL_TEST);
 531
 532   /* "pop" attributes */
 533   glEnable(GL_TEXTURE_2D);
 534   glEnable(GL_COLOR_MATERIAL);
 535   glEnable(GL_LIGHTING);
 536   glEnable(GL_CULL_FACE);
 537
 538
 539
 540 }
 541
 542 enum {X, Y, Z, W};
 543 enum {A, B, C, D};
 544
 545 /* create a matrix that will project the desired shadow */
 546 static void shadowmatrix(GLfloat shadowMat[4][4],
 547                   GLfloat groundplane[4],
 548                   GLfloat lightpos[4])
 549 {
 550   GLfloat dot;
 551
 552   /* find dot product between light position vector and ground plane normal */
 553   dot = groundplane[X] * lightpos[X] +
 554         groundplane[Y] * lightpos[Y] +
 555         groundplane[Z] * lightpos[Z] +
 556         groundplane[W] * lightpos[W];
 557
 558   shadowMat[0][0] = dot - lightpos[X] * groundplane[X];
 559   shadowMat[1][0] = 0.f - lightpos[X] * groundplane[Y];
 560   shadowMat[2][0] = 0.f - lightpos[X] * groundplane[Z];
 561   shadowMat[3][0] = 0.f - lightpos[X] * groundplane[W];
 562
 563   shadowMat[X][1] = 0.f - lightpos[Y] * groundplane[X];
 564   shadowMat[1][1] = dot - lightpos[Y] * groundplane[Y];
 565   shadowMat[2][1] = 0.f - lightpos[Y] * groundplane[Z];
 566   shadowMat[3][1] = 0.f - lightpos[Y] * groundplane[W];
 567
 568   shadowMat[X][2] = 0.f - lightpos[Z] * groundplane[X];
 569   shadowMat[1][2] = 0.f - lightpos[Z] * groundplane[Y];
 570   shadowMat[2][2] = dot - lightpos[Z] * groundplane[Z];
 571   shadowMat[3][2] = 0.f - lightpos[Z] * groundplane[W];
 572
 573   shadowMat[X][3] = 0.f - lightpos[W] * groundplane[X];
 574   shadowMat[1][3] = 0.f - lightpos[W] * groundplane[Y];
 575   shadowMat[2][3] = 0.f - lightpos[W] * groundplane[Z];
 576   shadowMat[3][3] = dot - lightpos[W] * groundplane[W];
 577 }
 578
 579 /** reflectionboard */
 580 static void draw_reflections(ModeInfo *mi, Chesscreen *cs)
 581 {
 582   int i, j;
 583
 584   glEnable(GL_STENCIL_TEST);
 585   glStencilFunc(GL_ALWAYS, 1, 1);
 586   glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 587   glColorMask(0,0,0,0);
 588   glDisable(GL_CULL_FACE);
 589
 590   glDisable(GL_DEPTH_TEST);
 591   glBegin(GL_QUADS);
 592
 593   /* only draw white squares */
 594   for(i = 0; i < BOARDSIZE; ++i) {
 595     for(j = (BOARDSIZE+i) % 2; j < BOARDSIZE; j += 2) {
 596       glVertex3f(i, 0.0, j + 1.0);
 597       glVertex3f(i + 1.0, 0.0, j + 1.0);
 598       glVertex3f(i + 1.0, 0.0, j);
 599       glVertex3f(i, 0.0, j);
 600       mi->polygon_count++;
 601     }
 602   }
 603   glEnd();
 604   glEnable(GL_DEPTH_TEST);
 605
 606   glColorMask(1, 1, 1, 1);
 607   glStencilFunc(GL_EQUAL, 1, 1);
 608   glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 609
 610   glPushMatrix();
 611   glScalef(1.0, -1.0, 1.0);
 612   glTranslatef(0.5, 0.0, 0.5);
 613
 614   glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
 615   draw_pieces(mi, cs, cs->wire);
 616   glPopMatrix();
 617
 618   glDisable(GL_STENCIL_TEST);
 619   glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
 620
 621   glEnable(GL_CULL_FACE);
 622   glCullFace(GL_BACK);
 623   glColorMask(1,1,1,1);
 624 }
 625
 626 /** draws the scene */
 627 static void display(ModeInfo *mi, Chesscreen *cs)
 628 {
 629   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 630
 631   mi->polygon_count = 0;
 632
 633   glMatrixMode(GL_MODELVIEW);
 634   glLoadIdentity();
 635
 636   /** setup perspectiv */
 637   glTranslatef(0.0, 0.0, -1.5*BOARDSIZE);
 638   glRotatef(30.0, 1.0, 0.0, 0.0);
 639   gltrackball_rotate (cs->trackball);
 640   glRotatef(cs->theta*100, 0.0, 1.0, 0.0);
 641   glTranslatef(-0.5*BOARDSIZE, 0.0, -0.5*BOARDSIZE);
 642
 643 /*   cs->position[0] = 4.0 + 1.0*-sin(cs->theta*100*M_PI/180.0); */
 644 /*   cs->position[2] = 4.0 + 1.0* cos(cs->theta*100*M_PI/180.0); */
 645 /*   cs->position[1] = 5.0; */
 646
 647   /* this is the lone light that the shadow matrix is generated from */
 648   cs->position[0] = 1.0;
 649   cs->position[2] = 1.0;
 650   cs->position[1] = 16.0;
 651
 652   cs->position2[0] = 4.0 + 8.0*-sin(cs->theta*100*M_PI/180.0);
 653   cs->position2[2] = 4.0 + 8.0* cos(cs->theta*100*M_PI/180.0);
 654
 655   if (!cs->wire) {
 656     glEnable(GL_LIGHTING);
 657     glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
 658     glLightfv(GL_LIGHT1, GL_POSITION, cs->position2);
 659     glEnable(GL_LIGHT0);
 660   }
 661
 662   /** draw board, pieces */
 663   if(!cs->wire) {
 664     glEnable(GL_LIGHTING);
 665     glEnable(GL_COLOR_MATERIAL);
 666
 667     if(reflections && !cs->wire) {
 668       draw_reflections(mi, cs);
 669       glEnable(GL_BLEND);
 670     }
 671
 672     glEnable(GL_TEXTURE_2D);
 673     glBindTexture(GL_TEXTURE_2D, cs->boardtexture);
 674     drawBoard(mi, cs);
 675     glDisable(GL_TEXTURE_2D);
 676
 677     if(shadows) {
 678       /* render shadows */
 679       GLfloat m[4][4];
 680       shadowmatrix(m, cs->ground, cs->position);
 681
 682       glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialShadow);
 683       glEnable(GL_BLEND);
 684       glDisable(GL_LIGHTING);
 685       glDisable(GL_DEPTH_TEST);
 686
 687       /* display ant shadow */
 688       glPushMatrix();
 689       glTranslatef(0.0, 0.001, 0.0);
 690       glMultMatrixf(m[0]);
 691       glTranslatef(0.5, 0.01, 0.5);
 692       draw_shadow_pieces(mi, cs, cs->wire);
 693       glPopMatrix();
 694
 695       glEnable(GL_LIGHTING);
 696       glDisable(GL_BLEND);
 697       glEnable(GL_DEPTH_TEST);
 698     }
 699
 700     if(reflections)
 701       glDisable(GL_BLEND);
 702   }
 703   else
 704     drawBoard(mi, cs);
 705
 706   glTranslatef(0.5, 0.0, 0.5);
 707   draw_pieces(mi, cs, cs->wire);
 708
 709   if(!cs->wire) {
 710     glDisable(GL_COLOR_MATERIAL);
 711     glDisable(GL_LIGHTING);
 712   }
 713
 714   if (!cs->button_down_p)
 715     cs->theta += .002;
 716 }
 717
 718 /** reshape handler */
 719 ENTRYPOINT void reshape_chess(ModeInfo *mi, int width, int height)
 720 {
 721   GLfloat h = (GLfloat) height / (GLfloat) width;
 722   glViewport(0,0, width, height);
 723   glMatrixMode(GL_PROJECTION);
 724   glLoadIdentity();
 725   gluPerspective(45, 1/h, 2.0, 30.0);
 726   glMatrixMode(GL_MODELVIEW);
 727 }
 728
 729 /** initialization handler */
 730 ENTRYPOINT void init_chess(ModeInfo *mi)
 731 {
 732   Chesscreen *cs;
 733   int screen = MI_SCREEN(mi);
 734
 735   if(!qs &&
 736      !(qs = (Chesscreen *) calloc(MI_NUM_SCREENS(mi), sizeof(Chesscreen))))
 737     return;
 738
 739   cs = &qs[screen];
 740   cs->window = MI_WINDOW(mi);
 741   cs->wire = MI_IS_WIREFRAME(mi);
 742   cs->trackball = gltrackball_init ();
 743
 744   cs->oldwhite = -1;
 745
 746   cs->colors[0][0] = 1.0;
 747   cs->colors[0][1] = 0.5;
 748   cs->colors[0][2] = 0.0;
 749
 750   cs->colors[1][0] = 0.6;
 751   cs->colors[1][1] = 0.6;
 752   cs->colors[1][2] = 0.6;
 753
 754   cs->done = 1;
 755   cs->count = 99;
 756   cs->mod = 1.4;
 757
 758 /*   cs->position[0] = 0.0; */
 759 /*   cs->position[1] = 5.0; */
 760 /*   cs->position[2] = 5.0; */
 761 /*   cs->position[3] = 1.0; */
 762
 763   cs->position[0] = 0.0;
 764   cs->position[1] = 24.0;
 765   cs->position[2] = 2.0;
 766   cs->position[3] = 1.0;
 767
 768
 769   cs->position2[0] = 5.0;
 770   cs->position2[1] = 5.0;
 771   cs->position2[2] = 5.0;
 772   cs->position2[3] = 1.0;
 773
 774   cs->ground[0] = 0.0;
 775   cs->ground[1] = 1.0;
 776   cs->ground[2] = 0.0;
 777   cs->ground[3] = -0.00001;
 778
 779   cs->oldgame = -1;
 780
 781
 782   if((cs->glx_context = init_GL(mi)))
 783     reshape_chess(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 784   else
 785     MI_CLEARWINDOW(mi);
 786
 787   glClearColor(0.0, 0.0, 0.0, 0.0);
 788
 789   if (!cs->wire) {
 790     glDepthFunc(GL_LEQUAL);
 791     glClearStencil(0);
 792     glEnable(GL_CULL_FACE);
 793     glCullFace(GL_BACK);
 794
 795     make_piece_texture(cs);
 796     make_board_texture(cs);
 797   }
 798   gen_model_lists( classic, cs->poly_counts);
 799
 800   if(!cs->wire) {
 801     setup_lights(cs);
 802     glColorMaterial(GL_FRONT, GL_DIFFUSE);
 803     glShadeModel(smooth ? GL_SMOOTH : GL_FLAT);
 804     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 805     glEnable(GL_DEPTH_TEST);
 806   }
 807   else
 808     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 809 }
 810
 811 /** does dirty work drawing scene, moving pieces */
 812 ENTRYPOINT void draw_chess(ModeInfo *mi)
 813 {
 814   Chesscreen *cs = &qs[MI_SCREEN(mi)];
 815   Window w = MI_WINDOW(mi);
 816   Display *disp = MI_DISPLAY(mi);
 817
 818   if(!cs->glx_context)
 819     return;
 820
 821   glXMakeCurrent(disp, w, *(cs->glx_context));
 822
 823   /** code for moving a piece */
 824   if(cs->moving && ++cs->steps == 100) {
 825     cs->moving = cs->count = cs->steps = cs->take = 0;
 826     cs->game.board[cs->game.moves[cs->mc][2]][cs->game.moves[cs->mc][3]] = cs->mpiece;
 827     ++cs->mc;
 828
 829     if(cs->mc == cs->game.movecount) {
 830       cs->done = 1;
 831       cs->mc = 0;
 832     }
 833   }
 834
 835   if(++cs->count == 100) {
 836     if(!cs->done) {
 837       cs->mpiece = cs->game.board[cs->game.moves[cs->mc][0]][cs->game.moves[cs->mc][1]];
 838       cs->game.board[cs->game.moves[cs->mc][0]][cs->game.moves[cs->mc][1]] = NONE;
 839
 840       if((cs->tpiece = cs->game.board[cs->game.moves[cs->mc][2]][cs->game.moves[cs->mc][3]])) {
 841         cs->game.board[cs->game.moves[cs->mc][2]][cs->game.moves[cs->mc][3]] = NONE;
 842         cs->take = 1;
 843       }
 844
 845       cs->from[0] = cs->game.moves[cs->mc][0];
 846       cs->from[1] = cs->game.moves[cs->mc][1];
 847       cs->to[0] = cs->game.moves[cs->mc][2];
 848       cs->to[1] = cs->game.moves[cs->mc][3];
 849
 850       cs->dz = (cs->to[0] - cs->from[0]) / 100;
 851       cs->dx = (cs->to[1] - cs->from[1]) / 100;
 852       cs->steps = 0;
 853       cs->moving = 1;
 854     }
 855     else if(cs->done == 1) {
 856       int newgame = cs->oldgame;
 857       while(newgame == cs->oldgame)
 858         newgame = random()%GAMES;
 859
 860       /* mod the mod */
 861       cs->mod = 0.6 + (random()%20)/10.0;
 862
 863       /* same old game */
 864       cs->oldgame = newgame;
 865       cs->game = games[cs->oldgame];
 866       build_colors(cs);
 867       cs->done = 2;
 868       cs->count = 0;
 869     }
 870     else {
 871       cs->done = 0;
 872       cs->count = 0;
 873     }
 874   }
 875
 876   /* set lighting */
 877   if(cs->done) {
 878     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION,
 879              cs->done == 1 ? 1.0+0.1*cs->count : 100.0/cs->count);
 880     glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION,
 881              cs->done == 1 ? 1.0+0.1*cs->count : 100.0/cs->count);
 882     glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.14);
 883     glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.14);
 884   }
 885
 886   display(mi, cs);
 887
 888   if(mi->fps_p) do_fps(mi);
 889   glFinish();
 890   glXSwapBuffers(disp, w);
 891 }
 892
 893 /** bust it */
 894 ENTRYPOINT void release_chess(ModeInfo *mi)
 895 {
 896   if(qs)
 897     free((void *) qs);
 898   qs = 0;
 899
 900   FreeAllGL(mi);
 901 }
 902
 903 XSCREENSAVER_MODULE_2 ("Endgame", endgame, chess)
 904
 905 #endif