3 * plays through a chess game ending. enjoy.
5 * version 1.0 - June 6, 2002
7 * Copyright (C) 2002-2008 Blair Tennessy (tennessb@unbc.ca)
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
19 #define DEFAULTS "*delay: 20000 \n" \
20 "*showFPS: False \n" \
21 "*wireframe: False \n" \
23 # define refresh_chess 0
24 # include "xlockmore.h"
35 #include "gltrackball.h"
36 #include "chessmodels.h"
37 #include "chessgames.h"
40 #define countof(x) (sizeof((x))/sizeof((*x)))
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" },
55 static int rotate, reflections, smooth, shadows, classic;
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},
65 ENTRYPOINT ModeSpecOpt chess_opts = {countof(opts), opts, countof(vars), vars, NULL};
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, "",
76 #define checkImageWidth 16
77 #define checkImageHeight 16
80 GLXContext *glx_context;
82 trackball_state *trackball;
88 /** definition of white/black (orange/gray) colors */
91 GLubyte checkImage[checkImageWidth][checkImageHeight][3];
92 GLuint piecetexture, boardtexture;
94 int mpiece, tpiece, steps, done;
95 double from[2], to[2];
97 int moving, take, mc, count, wire;
101 GLfloat position2[4];
109 int poly_counts[PIECES]; /* polygon count of each type of piece */
114 static Chesscreen *qs = NULL;
116 static const GLfloat MaterialShadow[] = {0.0, 0.0, 0.0, 0.3};
119 /* i prefer silvertip */
120 static const GLfloat whites[WHITES][3] =
129 static void build_colors(Chesscreen *cs)
133 int newwhite = cs->oldwhite;
134 while(newwhite == cs->oldwhite)
135 newwhite = random()%WHITES;
136 cs->oldwhite = newwhite;
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];
143 /* build piece texture */
144 static void make_piece_texture(Chesscreen *cs)
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;
157 glGenTextures(1, &cs->piecetexture);
158 glBindTexture(GL_TEXTURE_2D, cs->piecetexture);
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]);
169 /* build board texture (uniform noise in [180,180+50]) */
170 static void make_board_texture(Chesscreen *cs)
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;
183 glGenTextures(1, &cs->boardtexture);
184 glBindTexture(GL_TEXTURE_2D, cs->boardtexture);
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]);
195 /** handle X event (trackball) */
196 ENTRYPOINT Bool chess_handle_event (ModeInfo *mi, XEvent *event)
198 Chesscreen *cs = &qs[MI_SCREEN(mi)];
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));
207 else if(event->xany.type == ButtonRelease
208 && event->xbutton.button == Button1) {
209 cs->button_down_p = False;
212 else if (event->xany.type == ButtonPress &&
213 (event->xbutton.button == Button4 ||
214 event->xbutton.button == Button5 ||
215 event->xbutton.button == Button6 ||
216 event->xbutton.button == Button7))
218 gltrackball_mousewheel (cs->trackball, event->xbutton.button, 5,
219 !event->xbutton.state);
222 else if(event->xany.type == MotionNotify && cs->button_down_p) {
223 gltrackball_track (cs->trackball,
224 event->xmotion.x, event->xmotion.y,
225 MI_WIDTH (mi), MI_HEIGHT (mi));
232 static const GLfloat diffuse2[] = {1.0, 1.0, 1.0, 1.0};
233 /*static const GLfloat ambient2[] = {0.7, 0.7, 0.7, 1.0};*/
234 static const GLfloat shininess[] = {60.0};
235 static const GLfloat specular[] = {0.4, 0.4, 0.4, 1.0};
237 /* configure lighting */
238 static void setup_lights(Chesscreen *cs)
240 glEnable(GL_LIGHTING);
241 glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
242 glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse2);
245 /* glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient2); */
247 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
248 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
250 glLightfv(GL_LIGHT1, GL_SPECULAR, diffuse2);
251 glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse2);
256 static void drawPieces(ModeInfo *mi, Chesscreen *cs)
260 for(i = 0; i < BOARDSIZE; ++i) {
261 for(j = 0; j < BOARDSIZE; ++j) {
262 if(cs->game.board[i][j]) {
263 int c = cs->game.board[i][j]/PIECES;
264 glColor3fv(cs->colors[c]);
265 glCallList(cs->game.board[i][j]%PIECES);
266 mi->polygon_count += cs->poly_counts[cs->game.board[i][j]%PIECES];
269 glTranslatef(1.0, 0.0, 0.0);
272 glTranslatef(-1.0*BOARDSIZE, 0.0, 1.0);
275 glTranslatef(0.0, 0.0, -1.0*BOARDSIZE);
279 static void drawPiecesShadow(ModeInfo *mi, Chesscreen *cs)
283 for(i = 0; i < BOARDSIZE; ++i) {
284 for(j = 0; j < BOARDSIZE; ++j) {
285 if(cs->game.board[i][j]) {
286 glColor4f(0.0, 0.0, 0.0, 0.4);
287 glCallList(cs->game.board[i][j]%PIECES);
288 mi->polygon_count += cs->poly_counts[cs->game.board[i][j]%PIECES];
291 glTranslatef(1.0, 0.0, 0.0);
294 glTranslatef(-1.0*BOARDSIZE, 0.0, 1.0);
297 glTranslatef(0.0, 0.0, -1.0*BOARDSIZE);
300 /* draw a moving piece */
301 static void drawMovingPiece(ModeInfo *mi, Chesscreen *cs, int shadow)
303 int piece = cs->mpiece % PIECES;
307 if(shadow) glColor4fv(MaterialShadow);
308 else glColor3fv(cs->colors[cs->mpiece/PIECES]);
310 /** assume a queening. should be more general */
311 if((cs->mpiece == PAWN && fabs(cs->to[0]) < 0.01) ||
312 (cs->mpiece == BPAWN && fabs(cs->to[0]-7.0) < 0.01)) {
313 glTranslatef(cs->from[1]+cs->steps*cs->dx, 0.0, cs->from[0]+cs->steps*cs->dz);
315 glColor4f(shadow ? MaterialShadow[0] : cs->colors[cs->mpiece/7][0],
316 shadow ? MaterialShadow[1] : cs->colors[cs->mpiece/7][1],
317 shadow ? MaterialShadow[2] : cs->colors[cs->mpiece/7][2],
318 (fabs(50.0-cs->steps))/50.0);
320 piece = cs->steps < 50 ? PAWN : QUEEN;
324 cs->mpiece = cs->mpiece == PAWN ? QUEEN : BQUEEN;
326 else if(cs->mpiece % PIECES == KNIGHT) {
330 glTranslatef(cs->steps < 50 ? cs->from[1] : cs->to[1], 0.0,
331 cs->steps < 50 ? cs->from[0] : cs->to[0]);
333 mult = cs->steps < 10
334 ? (1.0 - cs->steps / 10.0) : 100 - cs->steps < 10
335 ? (1.0 - (100 - cs->steps) / 10.0) : 0.0;
337 shine[0] = mult*shininess[0];
338 spec[0] = mult*specular[0];
339 spec[1] = mult*specular[1];
340 spec[2] = mult*specular[2];
342 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shine);
343 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spec);
345 glColor4f(shadow ? MaterialShadow[0] : cs->colors[cs->mpiece/7][0],
346 shadow ? MaterialShadow[1] : cs->colors[cs->mpiece/7][1],
347 shadow ? MaterialShadow[2] : cs->colors[cs->mpiece/7][2],
348 fabs(49-cs->steps)/49.0);
350 glScalef(fabs(49-cs->steps)/49.0, fabs(49-cs->steps)/49.0, fabs(49-cs->steps)/49.0);
353 glTranslatef(cs->from[1]+cs->steps*cs->dx, 0.0, cs->from[0]+cs->steps*cs->dz);
359 mi->polygon_count += cs->poly_counts[cs->mpiece % PIECES];
361 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
362 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
370 /** code to squish a taken piece */
371 static void drawTakePiece(ModeInfo *mi, Chesscreen *cs, int shadow)
376 glColor4f(shadow ? MaterialShadow[0] : cs->colors[cs->tpiece/7][0],
377 shadow ? MaterialShadow[1] : cs->colors[cs->tpiece/7][1],
378 shadow ? MaterialShadow[2] : cs->colors[cs->tpiece/7][2],
379 (100-1.6*cs->steps)/100.0);
381 glTranslatef(cs->to[1], 0.0, cs->to[0]);
383 if(cs->mpiece % PIECES == KNIGHT)
384 glScalef(1.0+cs->steps/100.0, 1.0, 1.0+cs->steps/100.0);
386 glScalef(1.0, 1 - cs->steps/50.0 > 0.01 ? 1 - cs->steps/50.0 : 0.01, 1.0);
387 glCallList(cs->tpiece % 7);
388 mi->polygon_count += cs->poly_counts[cs->tpiece % PIECES];
395 static void drawBoard(ModeInfo *mi, Chesscreen *cs)
401 for(i = 0; i < BOARDSIZE; ++i)
402 for(j = 0; j < BOARDSIZE; ++j) {
403 double ma1 = (i+j)%2 == 0 ? cs->mod*i : 0.0;
404 double mb1 = (i+j)%2 == 0 ? cs->mod*j : 0.0;
405 double ma2 = (i+j)%2 == 0 ? cs->mod*(i+1.0) : 0.01;
406 double mb2 = (i+j)%2 == 0 ? cs->mod*(j+1.0) : 0.01;
408 /*glColor3fv(colors[(i+j)%2]);*/
409 glColor4f(cs->colors[(i+j)%2][0], cs->colors[(i+j)%2][1],
410 cs->colors[(i+j)%2][2], 0.65);
412 glNormal3f(0.0, 1.0, 0.0);
413 /* glTexCoord2f(mod*i, mod*(j+1.0)); */
414 glTexCoord2f(ma1, mb2);
415 glVertex3f(i, 0.0, j + 1.0);
416 /* glTexCoord2f(mod*(i+1.0), mod*(j+1.0)); */
417 glTexCoord2f(ma2, mb2);
418 glVertex3f(i + 1.0, 0.0, j + 1.0);
419 glTexCoord2f(ma2, mb1);
420 /* glTexCoord2f(mod*(i+1.0), mod*j); */
421 glVertex3f(i + 1.0, 0.0, j);
422 glTexCoord2f(ma1, mb1);
423 /* glTexCoord2f(mod*i, mod*j); */
424 glVertex3f(i, 0.0, j);
429 /* chop underneath board */
430 /* glColor3f(0, 0, 0); */
431 /* glNormal3f(0, -1, 0); */
432 /* glVertex3f(0, 0, BOARDSIZE); */
433 /* glVertex3f(0, 0, 0); */
434 /* glVertex3f(BOARDSIZE, 0, 0); */
435 /* glVertex3f(BOARDSIZE, 0, BOARDSIZE); */
439 static void draw_pieces(ModeInfo *mi, Chesscreen *cs, int wire)
442 glEnable(GL_TEXTURE_2D);
443 glBindTexture(GL_TEXTURE_2D, cs->piecetexture);
444 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
446 glColor4f(0.5, 0.5, 0.5, 1.0);
447 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialShadow);
451 if(cs->moving) drawMovingPiece(mi, cs, 0);
452 if(cs->take) drawTakePiece(mi, cs, 0);
453 glDisable(GL_TEXTURE_2D);
456 static void draw_shadow_pieces(ModeInfo *mi, Chesscreen *cs, int wire)
459 glEnable(GL_TEXTURE_2D);
460 glBindTexture(GL_TEXTURE_2D, cs->piecetexture);
461 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
464 /* use the stencil */
465 glDisable(GL_LIGHTING);
466 glDisable(GL_COLOR_MATERIAL);
467 glDisable(GL_DEPTH_TEST);
468 glDisable(GL_TEXTURE_2D);
471 glClear(GL_STENCIL_BUFFER_BIT);
472 glColorMask(0,0,0,0);
473 glEnable(GL_STENCIL_TEST);
475 glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFFL);
476 glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
480 glTranslatef(0.0, 0.001, 0.0);
482 /* draw the pieces */
483 drawPiecesShadow(mi, cs);
484 if(cs->moving) drawMovingPiece(mi, cs, shadows);
485 if(cs->take) drawTakePiece(mi, cs, shadows);
490 /* turn on drawing into colour buffer */
491 glColorMask(1,1,1,1);
493 /* programming with effect */
494 glDisable(GL_LIGHTING);
495 glDisable(GL_COLOR_MATERIAL);
496 glDisable(GL_TEXTURE_2D);
498 /* now draw the union of the shadows */
502 want to keep alpha values (alpha is involved in transition
503 effects of the active pieces).
506 glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFFL);
507 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
511 glColor4fv(MaterialShadow);
513 /* draw the board generously to fill the shadows */
516 glVertex3f(-1.0, 0.0, -1.0);
517 glVertex3f(-1.0, 0.0, BOARDSIZE + 1.0);
518 glVertex3f(1.0 + BOARDSIZE, 0.0, BOARDSIZE + 1.0);
519 glVertex3f(1.0 + BOARDSIZE, 0.0, -1.0);
523 glDisable(GL_STENCIL_TEST);
525 /* "pop" attributes */
526 glEnable(GL_TEXTURE_2D);
527 glEnable(GL_COLOR_MATERIAL);
528 glEnable(GL_LIGHTING);
529 glEnable(GL_CULL_FACE);
538 /* create a matrix that will project the desired shadow */
539 static void shadowmatrix(GLfloat shadowMat[4][4],
540 GLfloat groundplane[4],
545 /* find dot product between light position vector and ground plane normal */
546 dot = groundplane[X] * lightpos[X] +
547 groundplane[Y] * lightpos[Y] +
548 groundplane[Z] * lightpos[Z] +
549 groundplane[W] * lightpos[W];
551 shadowMat[0][0] = dot - lightpos[X] * groundplane[X];
552 shadowMat[1][0] = 0.f - lightpos[X] * groundplane[Y];
553 shadowMat[2][0] = 0.f - lightpos[X] * groundplane[Z];
554 shadowMat[3][0] = 0.f - lightpos[X] * groundplane[W];
556 shadowMat[X][1] = 0.f - lightpos[Y] * groundplane[X];
557 shadowMat[1][1] = dot - lightpos[Y] * groundplane[Y];
558 shadowMat[2][1] = 0.f - lightpos[Y] * groundplane[Z];
559 shadowMat[3][1] = 0.f - lightpos[Y] * groundplane[W];
561 shadowMat[X][2] = 0.f - lightpos[Z] * groundplane[X];
562 shadowMat[1][2] = 0.f - lightpos[Z] * groundplane[Y];
563 shadowMat[2][2] = dot - lightpos[Z] * groundplane[Z];
564 shadowMat[3][2] = 0.f - lightpos[Z] * groundplane[W];
566 shadowMat[X][3] = 0.f - lightpos[W] * groundplane[X];
567 shadowMat[1][3] = 0.f - lightpos[W] * groundplane[Y];
568 shadowMat[2][3] = 0.f - lightpos[W] * groundplane[Z];
569 shadowMat[3][3] = dot - lightpos[W] * groundplane[W];
572 /** reflectionboard */
573 static void draw_reflections(ModeInfo *mi, Chesscreen *cs)
577 glEnable(GL_STENCIL_TEST);
578 glStencilFunc(GL_ALWAYS, 1, 1);
579 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
580 glColorMask(0,0,0,0);
581 glDisable(GL_CULL_FACE);
583 glDisable(GL_DEPTH_TEST);
586 /* only draw white squares */
587 for(i = 0; i < BOARDSIZE; ++i) {
588 for(j = (BOARDSIZE+i) % 2; j < BOARDSIZE; j += 2) {
589 glVertex3f(i, 0.0, j + 1.0);
590 glVertex3f(i + 1.0, 0.0, j + 1.0);
591 glVertex3f(i + 1.0, 0.0, j);
592 glVertex3f(i, 0.0, j);
597 glEnable(GL_DEPTH_TEST);
599 glColorMask(1, 1, 1, 1);
600 glStencilFunc(GL_EQUAL, 1, 1);
601 glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
604 glScalef(1.0, -1.0, 1.0);
605 glTranslatef(0.5, 0.0, 0.5);
607 glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
608 draw_pieces(mi, cs, cs->wire);
611 glDisable(GL_STENCIL_TEST);
612 glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
614 glEnable(GL_CULL_FACE);
616 glColorMask(1,1,1,1);
619 /** draws the scene */
620 static void display(ModeInfo *mi, Chesscreen *cs)
622 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
624 mi->polygon_count = 0;
626 glMatrixMode(GL_MODELVIEW);
629 /** setup perspectiv */
630 glTranslatef(0.0, 0.0, -1.5*BOARDSIZE);
631 glRotatef(30.0, 1.0, 0.0, 0.0);
632 gltrackball_rotate (cs->trackball);
633 glRotatef(cs->theta*100, 0.0, 1.0, 0.0);
634 glTranslatef(-0.5*BOARDSIZE, 0.0, -0.5*BOARDSIZE);
636 /* cs->position[0] = 4.0 + 1.0*-sin(cs->theta*100*M_PI/180.0); */
637 /* cs->position[2] = 4.0 + 1.0* cos(cs->theta*100*M_PI/180.0); */
638 /* cs->position[1] = 5.0; */
640 /* this is the lone light that the shadow matrix is generated from */
641 cs->position[0] = 1.0;
642 cs->position[2] = 1.0;
643 cs->position[1] = 16.0;
645 cs->position2[0] = 4.0 + 8.0*-sin(cs->theta*100*M_PI/180.0);
646 cs->position2[2] = 4.0 + 8.0* cos(cs->theta*100*M_PI/180.0);
649 glEnable(GL_LIGHTING);
650 glLightfv(GL_LIGHT0, GL_POSITION, cs->position);
651 glLightfv(GL_LIGHT1, GL_POSITION, cs->position2);
655 /** draw board, pieces */
657 glEnable(GL_LIGHTING);
658 glEnable(GL_COLOR_MATERIAL);
660 if(reflections && !cs->wire) {
661 draw_reflections(mi, cs);
665 glEnable(GL_TEXTURE_2D);
666 glBindTexture(GL_TEXTURE_2D, cs->boardtexture);
668 glDisable(GL_TEXTURE_2D);
673 shadowmatrix(m, cs->ground, cs->position);
675 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialShadow);
677 glDisable(GL_LIGHTING);
678 glDisable(GL_DEPTH_TEST);
680 /* display ant shadow */
682 glTranslatef(0.0, 0.001, 0.0);
684 glTranslatef(0.5, 0.01, 0.5);
685 draw_shadow_pieces(mi, cs, cs->wire);
688 glEnable(GL_LIGHTING);
690 glEnable(GL_DEPTH_TEST);
699 glTranslatef(0.5, 0.0, 0.5);
700 draw_pieces(mi, cs, cs->wire);
703 glDisable(GL_COLOR_MATERIAL);
704 glDisable(GL_LIGHTING);
707 if (!cs->button_down_p)
711 /** reshape handler */
712 ENTRYPOINT void reshape_chess(ModeInfo *mi, int width, int height)
714 GLfloat h = (GLfloat) height / (GLfloat) width;
715 glViewport(0,0, width, height);
716 glMatrixMode(GL_PROJECTION);
718 gluPerspective(45, 1/h, 2.0, 30.0);
719 glMatrixMode(GL_MODELVIEW);
722 /** initialization handler */
723 ENTRYPOINT void init_chess(ModeInfo *mi)
726 int screen = MI_SCREEN(mi);
729 !(qs = (Chesscreen *) calloc(MI_NUM_SCREENS(mi), sizeof(Chesscreen))))
733 cs->window = MI_WINDOW(mi);
734 cs->wire = MI_IS_WIREFRAME(mi);
735 cs->trackball = gltrackball_init ();
739 cs->colors[0][0] = 1.0;
740 cs->colors[0][1] = 0.5;
741 cs->colors[0][2] = 0.0;
743 cs->colors[1][0] = 0.6;
744 cs->colors[1][1] = 0.6;
745 cs->colors[1][2] = 0.6;
751 /* cs->position[0] = 0.0; */
752 /* cs->position[1] = 5.0; */
753 /* cs->position[2] = 5.0; */
754 /* cs->position[3] = 1.0; */
756 cs->position[0] = 0.0;
757 cs->position[1] = 24.0;
758 cs->position[2] = 2.0;
759 cs->position[3] = 1.0;
762 cs->position2[0] = 5.0;
763 cs->position2[1] = 5.0;
764 cs->position2[2] = 5.0;
765 cs->position2[3] = 1.0;
770 cs->ground[3] = -0.00001;
775 if((cs->glx_context = init_GL(mi)))
776 reshape_chess(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
780 glClearColor(0.0, 0.0, 0.0, 0.0);
783 glDepthFunc(GL_LEQUAL);
785 glEnable(GL_CULL_FACE);
788 make_piece_texture(cs);
789 make_board_texture(cs);
791 gen_model_lists( classic, cs->poly_counts);
795 glColorMaterial(GL_FRONT, GL_DIFFUSE);
796 glShadeModel(smooth ? GL_SMOOTH : GL_FLAT);
797 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
798 glEnable(GL_DEPTH_TEST);
801 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
804 /** does dirty work drawing scene, moving pieces */
805 ENTRYPOINT void draw_chess(ModeInfo *mi)
807 Chesscreen *cs = &qs[MI_SCREEN(mi)];
808 Window w = MI_WINDOW(mi);
809 Display *disp = MI_DISPLAY(mi);
814 glXMakeCurrent(disp, w, *(cs->glx_context));
816 /** code for moving a piece */
817 if(cs->moving && ++cs->steps == 100) {
818 cs->moving = cs->count = cs->steps = cs->take = 0;
819 cs->game.board[cs->game.moves[cs->mc][2]][cs->game.moves[cs->mc][3]] = cs->mpiece;
822 if(cs->mc == cs->game.movecount) {
828 if(++cs->count == 100) {
830 cs->mpiece = cs->game.board[cs->game.moves[cs->mc][0]][cs->game.moves[cs->mc][1]];
831 cs->game.board[cs->game.moves[cs->mc][0]][cs->game.moves[cs->mc][1]] = NONE;
833 if((cs->tpiece = cs->game.board[cs->game.moves[cs->mc][2]][cs->game.moves[cs->mc][3]])) {
834 cs->game.board[cs->game.moves[cs->mc][2]][cs->game.moves[cs->mc][3]] = NONE;
838 cs->from[0] = cs->game.moves[cs->mc][0];
839 cs->from[1] = cs->game.moves[cs->mc][1];
840 cs->to[0] = cs->game.moves[cs->mc][2];
841 cs->to[1] = cs->game.moves[cs->mc][3];
843 cs->dz = (cs->to[0] - cs->from[0]) / 100;
844 cs->dx = (cs->to[1] - cs->from[1]) / 100;
848 else if(cs->done == 1) {
849 int newgame = cs->oldgame;
850 while(newgame == cs->oldgame)
851 newgame = random()%GAMES;
854 cs->mod = 0.6 + (random()%20)/10.0;
857 cs->oldgame = newgame;
858 cs->game = games[cs->oldgame];
871 glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION,
872 cs->done == 1 ? 1.0+0.1*cs->count : 100.0/cs->count);
873 glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION,
874 cs->done == 1 ? 1.0+0.1*cs->count : 100.0/cs->count);
875 glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.14);
876 glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.14);
881 if(mi->fps_p) do_fps(mi);
883 glXSwapBuffers(disp, w);
887 ENTRYPOINT void release_chess(ModeInfo *mi)
896 XSCREENSAVER_MODULE_2 ("Endgame", endgame, chess)