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