/* Checks for death of any ghosts/pacman and updates. It also makes a new
level if all ghosts are dead or all dots are eaten. */
static void
check_death(ModeInfo * mi, pacmangamestruct *pp)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
unsigned int ghost;
int alldead;
alldead = 1;
for (ghost = 0; ghost < pp->nghosts; ghost++) {
if (pp->ghosts[ghost].dead == True)
continue;
if ((pp->ghosts[ghost].nextrow == NOWHERE &&
pp->ghosts[ghost].nextcol == NOWHERE)) {
alldead = 0;
continue;
}
if (((pp->ghosts[ghost].nextrow == pp->pacman.nextrow) &&
(pp->ghosts[ghost].nextcol == pp->pacman.nextcol)) ||
((pp->ghosts[ghost].nextrow == pp->pacman.row) &&
(pp->ghosts[ghost].nextcol == pp->pacman.col) &&
(pp->ghosts[ghost].row == pp->pacman.nextrow) &&
(pp->ghosts[ghost].col == pp->pacman.nextcol))) {
pp->ghosts[ghost].dead = 1;
XSetForeground(display,
pp->stippledGC,
MI_BLACK_PIXEL(mi));
XFillRectangle(display, window,
pp->stippledGC,
pp->ghosts[ghost].cf,
pp->ghosts[ghost].rf,
pp->spritexs,
pp->spriteys);
} else
alldead = 0;
}
if (alldead == 1 || pp->dotsleft == 0)
repopulate(mi);
}
ENTRYPOINT void draw_cube21(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
cube21_conf *cp;
if (!cube21) return;
cp = &cube21[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!cp->glx_context) return;
mi->polygon_count = 0;
glXMakeCurrent(display, window, *cp->glx_context);
if (!draw_main(mi, cp)) {
MI_ABORT(mi);
return;
}
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
}
ENTRYPOINT void
draw_grav(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
register unsigned char ball;
gravstruct *gp;
if (gravs == NULL)
return;
gp = &gravs[MI_SCREEN(mi)];
if (gp->planets == NULL)
return;
MI_IS_DRAWN(mi) = True;
/* Mask centrepoint */
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XDrawArc(display, window, gc,
gp->width / 2 - gp->sr / 2, gp->height / 2 - gp->sr / 2, gp->sr, gp->sr,
0, 23040);
/* Resize centrepoint */
switch (NRAND(4)) {
case 0:
if (gp->sr < (int) STARRADIUS)
gp->sr++;
break;
case 1:
if (gp->sr > 2)
gp->sr--;
}
/* Draw centrepoint */
XSetForeground(display, gc, gp->starcolor);
XDrawArc(display, window, gc,
gp->width / 2 - gp->sr / 2, gp->height / 2 - gp->sr / 2, gp->sr, gp->sr,
0, 23040);
for (ball = 0; ball < (unsigned char) gp->nplanets; ball++)
draw_planet(mi, &gp->planets[ball]);
}
void
refresh_toneclock(ModeInfo * mi)
{
toneclockstruct *tclock;
if (toneclocks == NULL)
return;
tclock = &toneclocks[MI_SCREEN(mi)];
if (tclock->hour == NULL)
return;
if (!tclock->painted)
return;
MI_CLEARWINDOW(mi);
#ifdef NO_DBUF
{
Display *display = MI_DISPLAY(mi);
int i;
XSetFunction(display, tclock->gc, GXxor);
for (i = 0; i < tclock->num_hour; i++) {
toneclockhour *hour0;
int x0 , y0;
x0 = (int) (tclock->radius * sin( -tclock->angle - PI_RAD * i *
360.0 / tclock->num_hour ) +
tclock->x0 + tclock->a_x * sin( tclock->anglex ) );
y0 = (int) (tclock->radius * cos( -tclock->angle - PI_RAD * i *
360.0 / tclock->num_hour ) +
tclock->y0 + tclock->a_y * sin( tclock->angley ) );
hour0 = &tclock->hour[i];
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XSetForeground(display, tclock->gc, tclock->colors[hour0->colour].pixel);
} else {
XSetForeground(display, tclock->gc, hour0->colour);
}
toneclock_drawhour(mi, hour0 , x0 , y0 );
}
XSetFunction(display, tclock->gc, GXcopy);
}
#endif
}
/* Set up and enable texturing on our object */
static void
setup_xpm_texture (ModeInfo *mi, char **xpm_data)
{
XImage *image = xpm_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi),
MI_COLORMAP (mi), xpm_data);
char buf[1024];
clear_gl_error();
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
/* iOS invalid enum:
glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width);
*/
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
image->width, image->height, 0,
GL_RGBA,
/* GL_UNSIGNED_BYTE, */
GL_UNSIGNED_INT_8_8_8_8_REV,
image->data);
sprintf (buf, "builtin texture (%dx%d)", image->width, image->height);
check_gl_error(buf);
}
static void
first_strike(Lightning bolt, ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
int i;
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
XDrawLine(display, window, gc,
bolt.end1.x, bolt.end1.y, bolt.middle[0].x, bolt.middle[0].y);
draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, 0);
XDrawLine(display, window, gc,
bolt.middle[BOLT_VERTICIES - 1].x, bolt.middle[BOLT_VERTICIES - 1].y,
bolt.end2.x, bolt.end2.y);
for (i = 0; i < bolt.fork_number; i++)
draw_line(mi, bolt.branch[i].ForkVerticies, bolt.branch[i].num_used,
gc, 0);
}
ENTRYPOINT Bool
screenflip_handle_event (ModeInfo *mi, XEvent *event)
{
Screenflip *c = &screenflip[MI_SCREEN(mi)];
if (gltrackball_event_handler (event, c->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&c->button_down_p))
return True;
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
if (!c->waiting_for_image_p)
{
getSnapshot (mi);
return True;
}
}
return False;
}
ENTRYPOINT void
free_stream (ModeInfo * mi)
{
stream_configuration *es = &ess[MI_SCREEN(mi)];
int i;
if (!es->glx_context) return;
glXMakeCurrent (MI_DISPLAY(mi), MI_WINDOW(mi), *es->glx_context);
if (es->trackball) gltrackball_free (es->trackball);
if (es->rot) free_rotator (es->rot);
for (i = 0; i < es->num_streams; i++) {
free (es->streams[i].flares);
glDeleteTextures (1, &es->streams[i].flare_tex);
}
if (es->streams) free (es->streams);
}
void
refresh_image(ModeInfo * mi)
{
#ifdef HAVE_XPM
imagestruct *ip;
if (ims == NULL)
return;
ip = &ims[MI_SCREEN(mi)];
if (ip->icons == NULL)
return;
if (ip->graphics_format >= IS_XPM) {
/* This is needed when another program changes the colormap. */
free_image(MI_DISPLAY(mi), ip);
init_image(mi);
return;
}
#endif
drawImages(mi);
}
ENTRYPOINT void
draw_gasket(ModeInfo * mi)
{
gasketstruct *gp = &gasket[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!gp->glx_context) return;
glDrawBuffer(GL_BACK);
if (max_depth > 10)
max_depth = 10;
glXMakeCurrent(display, window, *(gp->glx_context));
draw(mi);
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
static Bool
initLogo(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
imagestruct *ip = &ims[MI_SCREEN(mi)];
if (ip->logo == None) {
getImage(mi, &ip->logo, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_BITS,
#ifdef HAVE_XPM
DEFAULT_XPM, IMAGE_NAME,
#endif
&ip->graphics_format, &ip->cmap, &ip->black);
if (ip->logo == None) {
free_image(display, ip);
return False;
}
ip->pixw = ip->logo->width;
ip->pixh = ip->logo->height;
}
#ifndef STANDALONE
if (ip->cmap != None) {
setColormap(display, window, ip->cmap, MI_IS_INWINDOW(mi));
if (ip->bgGC == None) {
XGCValues xgcv;
xgcv.background = ip->black;
if ((ip->bgGC = XCreateGC(display, window, GCBackground,
&xgcv)) == None) {
free_image(display, ip);
return False;
}
}
} else
#endif /* STANDALONE */
{
ip->black = MI_BLACK_PIXEL(mi);
ip->bgGC = MI_GC(mi);
}
return True;
}
ENTRYPOINT void
init_lissie (ModeInfo * mi)
{
lissstruct *lp;
unsigned char ball;
MI_INIT (mi, lisses, 0);
lp = &lisses[MI_SCREEN(mi)];
lp->width = MI_WIDTH(mi);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
#endif
lp->height = MI_HEIGHT(mi);
lp->nlissies = MI_COUNT(mi);
if (lp->nlissies < -MINLISSIES) {
if (lp->lissie) {
(void) free((void *) lp->lissie);
lp->lissie = (lissiestruct *) NULL;
}
lp->nlissies = NRAND(-lp->nlissies - MINLISSIES + 1) + MINLISSIES;
} else if (lp->nlissies < MINLISSIES)
lp->nlissies = MINLISSIES;
lp->loopcount = 0;
if (lp->lissie == NULL)
if ((lp->lissie = (lissiestruct *) calloc(lp->nlissies,
sizeof (lissiestruct))) == NULL)
return;
MI_CLEARWINDOW(mi);
lp->painted = False;
for (ball = 0; ball < (unsigned char) lp->nlissies; ball++)
initlissie(mi, &lp->lissie[ball]);
}
/*
*-----------------------------------------------------------------------------
* Called by the mainline code periodically to update the display.
*-----------------------------------------------------------------------------
*/
void draw_fire(ModeInfo * mi)
{
firestruct *fs = &fire[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
MI_IS_DRAWN(mi) = True;
if (!fs->glx_context)
return;
#ifdef WIN32
wglMakeCurrent(hdc, fs->glx_context);
#else
glXMakeCurrent(display, window, *(fs->glx_context));
#endif
DrawFire(mi);
reshape_fire(mi,MI_WIDTH(mi),MI_HEIGHT(mi));
glFinish();
glXSwapBuffers(display, window);
}
ENTRYPOINT void
draw_rubikblocks(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
rubikblocks_conf *cp;
if (!rubikblocks) return;
cp = &rubikblocks[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!cp->glx_context) return;
mi->polygon_count = 0;
glXMakeCurrent(display, window, *(cp->glx_context));
if (!draw_main(mi, cp))
{
release_rubikblocks(mi);
return;
}
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
}
ENTRYPOINT Bool
cube_handle_event (ModeInfo *mi, XEvent *event)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
/* Neutralize any vertical motion */
GLfloat rot = current_device_rotation();
Bool rotp = ((rot > 45 && rot < 135) ||
(rot < -45 && rot > -135));
if (event->xany.type == ButtonPress ||
event->xany.type == ButtonRelease)
{
if (rotp)
event->xbutton.x = MI_WIDTH(mi) / 2;
else
event->xbutton.y = MI_HEIGHT(mi) / 2;
}
else if (event->xany.type == MotionNotify)
{
if (rotp)
event->xmotion.x = MI_WIDTH(mi) / 2;
else
event->xmotion.y = MI_HEIGHT(mi) / 2;
}
if (gltrackball_event_handler (event, cc->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&cc->button_down_p))
return True;
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
reset_colors (mi);
tweak_cubes (mi);
gltrackball_reset (cc->trackball, 0, 0);
return True;
}
return False;
}
ENTRYPOINT Bool
carousel_handle_event (ModeInfo *mi, XEvent *event)
{
carousel_state *ss = &sss[MI_SCREEN(mi)];
if (event->xany.type == ButtonPress &&
event->xbutton.button == Button1)
{
if (! ss->button_down_p)
ss->button_down_time = time((time_t *) 0);
}
else if (event->xany.type == ButtonRelease &&
event->xbutton.button == Button1)
{
if (ss->button_down_p)
{
/* Add the time the mouse was held to the expire times of all
frames, so that mouse-dragging doesn't count against
image expiration.
*/
int secs = time((time_t *) 0) - ss->button_down_time;
int i;
for (i = 0; i < ss->nframes; i++)
ss->frames[i]->expires += secs;
}
}
if (gltrackball_event_handler (event, ss->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&ss->button_down_p))
return True;
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
int i = random() % ss->nframes;
ss->frames[i]->expires = 0;
return True;
}
return False;
}
ENTRYPOINT void
draw_noof (ModeInfo *mi)
{
int i;
noof_configuration *bp = &bps[MI_SCREEN(mi)];
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
/**
if((random() & 0xff) == 0x34){
glClear(GL_COLOR_BUFFER_BIT);
}
if((tko & 0x1f) == 0x1f){
glEnable(GL_BLEND);
glColor4f(0.0, 0.0, 0.0, 0.09);
glRectf(0.0, 0.0, wd, ht);
glDisable(GL_BLEND);
#ifdef __sgi
sginap(0);
#endif
}
*/
gravity(bp, -2.0);
for (i = 0; i < N_SHAPES; i++) {
motionUpdate(bp, i);
colorUpdate(bp, i);
drawleaf(bp, i);
}
if (mi->fps_p) do_fps (mi);
glFinish();
/* For some reason this hack screws up on Cocoa if we try to double-buffer it.
It looks fine single-buffered, so let's just do that. */
/* glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi)); */
}
ENTRYPOINT Bool
flipflop_handle_event (ModeInfo *mi, XEvent *event)
{
Flipflopcreen *c = &qs[MI_SCREEN(mi)];
if (gltrackball_event_handler (event, c->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&c->button_down_p))
return True;
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
if (!textured || c->got_texture)
{
textured = 1;
c->got_texture = False;
get_texture (mi);
return True;
}
}
return False;
}
ENTRYPOINT void
draw_lisa (ModeInfo * mi)
{
lisacons *lc;
if (Lisa == NULL)
return;
lc = &Lisa[MI_SCREEN(mi)];
if (lc->lissajous == NULL)
return;
#ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */
XClearWindow (MI_DISPLAY(mi), MI_WINDOW(mi));
#endif
MI_IS_DRAWN(mi) = True;
lc->painted = True;
if (++lc->loopcount > lc->maxcycles) {
change_lisa(mi);
}
refreshlisa(mi);
}
ENTRYPOINT Bool
slideshow_handle_event (ModeInfo *mi, XEvent *event)
{
slideshow_state *ss = &sss[MI_SCREEN(mi)];
if (event->xany.type == Expose ||
event->xany.type == GraphicsExpose ||
event->xany.type == VisibilityNotify)
{
ss->redisplay_needed_p = True;
if (debug_p)
fprintf (stderr, "%s: exposure\n", blurb());
return False;
}
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
ss->change_now_p = True;
return True;
}
return False;
}
ENTRYPOINT void
draw_sierpinski(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
GC gc = MI_GC(mi);
XPoint *xp[MAXCORNERS];
int i, v;
sierpinskistruct *sp;
if (tris == NULL)
return;
sp = &tris[MI_SCREEN(mi)];
if (sp->pointBuffer[0] == NULL)
return;
MI_IS_DRAWN(mi) = True;
if (MI_NPIXELS(mi) <= 2)
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
for (i = 0; i < sp->corners; i++)
xp[i] = sp->pointBuffer[i];
for (i = 0; i < sp->total_npoints; i++) {
v = NRAND(sp->corners);
sp->px = (sp->px + sp->vertex[v].x) / 2;
sp->py = (sp->py + sp->vertex[v].y) / 2;
xp[v]->x = sp->px;
xp[v]->y = sp->py;
xp[v]++;
sp->npoints[v]++;
}
for (i = 0; i < sp->corners; i++) {
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, gc, MI_PIXEL(mi, sp->colors[i]));
XDrawPoints(display, MI_WINDOW(mi), gc, sp->pointBuffer[i], sp->npoints[i],
CoordModeOrigin);
sp->npoints[i] = 0;
}
if (++sp->time >= MI_CYCLES(mi))
startover(mi);
}
static void
set_atom_color (ModeInfo *mi, molecule_atom *a, Bool font_p)
{
atom_data *d;
GLfloat *gl_color;
if (a)
d = a->data;
else
{
static atom_data *def_data = 0;
if (!def_data) def_data = get_atom_data ("bond");
d = def_data;
}
gl_color = (!font_p ? d->gl_color : (d->gl_color + 4));
if (gl_color[3] == 0)
{
const char *string = !font_p ? d->color : d->text_color;
XColor xcolor;
if (!XParseColor (MI_DISPLAY(mi), MI_COLORMAP(mi), string, &xcolor))
{
(void) fprintf (stderr, "molecule: unparsable color in %s: %s\n",
(a ? a->label : d->name), string);
/* exit (1); */
}
gl_color[0] = xcolor.red / 65536.0;
gl_color[1] = xcolor.green / 65536.0;
gl_color[2] = xcolor.blue / 65536.0;
gl_color[3] = 1.0;
}
if (font_p)
glColor3f (gl_color[0], gl_color[1], gl_color[2]);
else
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gl_color);
}
static void
level2_strike(Lightning bolt, ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
Storm *st = &Helga[MI_SCREEN(mi)];
GC gc = MI_GC(mi);
int i;
/* This was originally designed to be a little darker then the
level1 strike. This was changed to get it to work on
multiscreens and to add more color variety. I tried
stippling but it did not look good. */
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, gc, MI_PIXEL(mi, st->color));
else
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
XDrawLine(display, window, gc,
bolt.end1.x - 2, bolt.end1.y, bolt.middle[0].x - 2, bolt.middle[0].y);
draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, -2);
XDrawLine(display, window, gc,
bolt.middle[BOLT_VERTICIES - 1].x - 2,
bolt.middle[BOLT_VERTICIES - 1].y, bolt.end2.x - 2, bolt.end2.y);
XDrawLine(display, window, gc,
bolt.end1.x + 2, bolt.end1.y, bolt.middle[0].x + 2, bolt.middle[0].y);
draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, 2);
XDrawLine(display, window, gc,
bolt.middle[BOLT_VERTICIES - 1].x + 2,
bolt.middle[BOLT_VERTICIES - 1].y, bolt.end2.x + 2, bolt.end2.y);
for (i = 0; i < bolt.fork_number; i++) {
draw_line(mi, bolt.branch[i].ForkVerticies, bolt.branch[i].num_used,
gc, -2);
draw_line(mi, bolt.branch[i].ForkVerticies, bolt.branch[i].num_used,
gc, 2);
}
level1_strike(bolt, mi);
}
/*=================== Load Texture =========================================*/
static void LoadTexture(ModeInfo * mi, char **fn, int t_num)
{
#if defined( I_HAVE_XPM )
atunnelstruct *sa = &Atunnel[MI_SCREEN(mi)];
XImage *teximage; /* Texture data */
if ((teximage = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi),
MI_COLORMAP(mi), fn)) == None) {
(void) fprintf(stderr, "Error reading the texture.\n");
glDeleteTextures(1, &sa->texture[t_num]);
do_texture = False;
#ifdef STANDALONE
exit(0);
#else
return;
#endif
}
#ifdef HAVE_GLBINDTEXTURE
glBindTexture(GL_TEXTURE_2D, sa->texture[t_num]);
#endif /* HAVE_GLBINDTEXTURE */
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
clear_gl_error();
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, teximage->width, teximage->height,
0, GL_RGBA,
/* GL_UNSIGNED_BYTE, */
GL_UNSIGNED_INT_8_8_8_8_REV,
teximage->data);
check_gl_error("texture");
/* Texture parameters, LINEAR scaling for better texture quality */
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
XDestroyImage(teximage);
#else /* !I_HAVE_XPM */
do_texture = False;
#endif /* !I_HAVE_XPM */
}
static void
unpaint_fly(ModeInfo * mi, Fly * f)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
if (MI_IS_ICONIC(mi)) {
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XFillArc(display, window, gc, f->oldx, f->oldy,
f->width, f->height, 90 * 64, 360 * 64);
} else {
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
#ifdef FLASH
XFillRectangle(display, window, gc,
f->oldx, f->oldy, f->width, f->height);
#else
ERASE_IMAGE(display, window, gc, f->x, f->y,
f->oldx, f->oldy, f->width, f->height);
#endif
}
}
ENTRYPOINT void
free_cube (ModeInfo *mi)
{
cube_configuration *bp = &bps[MI_SCREEN(mi)];
if (!bp->glx_context) return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *bp->glx_context);
while (bp->cubes)
{
cube *c = bp->cubes->next;
free (bp->cubes);
bp->cubes = c;
}
while (bp->oscillators)
{
oscillator *o = bp->oscillators->next;
free (bp->oscillators);
bp->oscillators = o;
}
if (bp->trackball) gltrackball_free (bp->trackball);
if (bp->rot) free_rotator (bp->rot);
}
static void
drawcell(ModeInfo * mi, int col, int row, unsigned char state)
{
dragonstruct *dp = &dragons[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
GC gc;
if (!state) {
XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
gc = MI_GC(mi);
} else if (state == 1) {
XSetForeground(display, MI_GC(mi), MI_BLACK_PIXEL(mi));
gc = MI_GC(mi);
} else if (MI_NPIXELS(mi) > 2) {
XSetForeground(display, MI_GC(mi), dp->color);
gc = MI_GC(mi);
} else {
XGCValues gcv;
gcv.stipple = dp->graypix;
gcv.foreground = MI_WHITE_PIXEL(mi);
gcv.background = MI_BLACK_PIXEL(mi);
XChangeGC(display, dp->stippledGC,
GCStipple | GCForeground | GCBackground, &gcv);
gc = dp->stippledGC;
}
{
int ccol = 2 * col + !(row & 1), crow = 2 * row;
dp->hexagon[0].x = dp->xb + ccol * dp->xs;
dp->hexagon[0].y = dp->yb + crow * dp->ys;
if (dp->xs == 1 && dp->ys == 1)
XDrawPoint(display, MI_WINDOW(mi),
gc, dp->hexagon[0].x, dp->hexagon[0].y);
else
XFillPolygon(display, MI_WINDOW(mi), gc,
dp->hexagon, 6, Convex, CoordModePrevious);
}
}
static Bool
init_stuff(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
puzzlestruct *pp = &puzzles[MI_SCREEN(mi)];
if (pp->logo == None)
getImage(mi, &pp->logo, PUZZLE_WIDTH, PUZZLE_HEIGHT, PUZZLE_BITS,
#ifdef HAVE_XPM
DEFAULT_XPM, PUZZLE_NAME,
#endif
&pp->graphics_format, &pp->cmap, &pp->black);
if (pp->logo == None) {
free_puzzle(display, pp);
return False;
}
#ifndef STANDALONE
if (pp->cmap != None) {
setColormap(display, window, pp->cmap, MI_IS_INWINDOW(mi));
if (pp->backGC == None) {
XGCValues xgcv;
xgcv.background = pp->black;
if ((pp->backGC = XCreateGC(display, window, GCBackground,
&xgcv)) == None) {
free_puzzle(display, pp);
return False;
}
}
} else
#endif /* STANDALONE */
{
pp->black = MI_BLACK_PIXEL(mi);
pp->backGC = MI_GC(mi);
}
return True;
}
static
void
draw_atriangle(ModeInfo * mi, XPoint * p, int y_0, int y_1, int y_2, double dinv)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
if (MI_NCOLORS(mi) > 2) { /* color */
int dmax, dmin;
long color;
dmin = MIN(y_0, y_1);
dmin = MIN(dmin, y_2);
dmax = MAX(y_0, y_1);
dmax = MAX(dmax, y_2);
if (dmax == 0) {
color = BLUE;
} else {
color = MI_NCOLORS(mi) -
(int) ((double) MI_NCOLORS(mi) / M_PI_2 * atan(dinv * (dmax - dmin)));
}
XSetForeground(display, gc, mi->colors[color % MI_NCOLORS(mi)].pixel);
XFillPolygon(display, window, gc, p, 3, Convex, CoordModeOrigin);
} else {
/* mono */
#ifdef BACKFACE_REMOVAL
XSetForeground(display, gc, MI_WIN_BLACK_PIXEL(mi));
XFillPolygon(display, window, gc, p, 3, Convex, CoordModeOrigin);
#endif
XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
XDrawLine(display, window, gc, p[0].x, p[0].y, p[1].x, p[1].y);
XDrawLine(display, window, gc, p[1].x, p[1].y, p[2].x, p[2].y);
XDrawLine(display, window, gc, p[2].x, p[2].y, p[0].x, p[0].y);
}
}
static void
drawcell(ModeInfo * mi, int col, int row, unsigned int state)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
life1dstruct *lp = &life1ds[MI_SCREEN(mi)];
GC gc = lp->backGC;
if (!state) {
XSetForeground(display, gc, lp->black);
XFillRectangle(display, window, gc,
lp->xb + lp->xs * col, lp->yb + lp->ys * row, lp->xs, lp->ys);
return;
}
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, gc, MI_PIXEL(mi, lp->colors[state - 1]));
if (lp->pixelmode || (MI_NPIXELS(mi) <= 2)) {
if (MI_NPIXELS(mi) <= 2) {
XGCValues gcv;
gcv.stipple = lp->pixmaps[state - 1];
gcv.foreground = MI_WHITE_PIXEL(mi);
gcv.background = lp->black;
gcv.fill_style = FillOpaqueStippled;
XChangeGC(display, lp->stippledGC,
GCStipple | GCFillStyle | GCForeground | GCBackground, &gcv);
XFillRectangle(display, window, lp->stippledGC,
lp->xb + lp->xs * col, lp->yb + lp->ys * row, lp->xs, lp->ys);
} else
XFillRectangle(display, window, gc,
lp->xb + lp->xs * col, lp->yb + lp->ys * row, lp->xs, lp->ys);
}
else {
(void) XPutImage(display, window, gc,
lp->logo, 0, 0, lp->xb + lp->xs * col, lp->yb + lp->ys * row,
lp->logo->width, lp->logo->height);
}
}
