static void drawlissie(ModeInfo * mi, lissiestruct * lissie) { Display *display = MI_DISPLAY(mi); GC gc = MI_GC(mi); lissstruct *lp = &lisses[MI_SCREEN(mi)]; int p = (++lissie->pos) % MAXLISSIELEN; int oldp = (lissie->pos - lissie->len + MAXLISSIELEN) % MAXLISSIELEN; /* Let time go by ... */ lissie->tx += lissie->dtx; lissie->ty += lissie->dty; if (lissie->tx > 2 * M_PI) lissie->tx -= 2 * M_PI; if (lissie->ty > 2 * M_PI) lissie->ty -= 2 * M_PI; /* vary both (x/y) speeds by max. 1% */ lissie->dtx *= FLOATRAND(0.99, 1.01); lissie->dty *= FLOATRAND(0.99, 1.01); if (lissie->dtx < MINDT) lissie->dtx = MINDT; else if (lissie->dtx > MAXDT) lissie->dtx = MAXDT; if (lissie->dty < MINDT) lissie->dty = MINDT; else if (lissie->dty > MAXDT) lissie->dty = MAXDT; lissie->loc[p].x = lissie->xi + (int) (sin(lissie->tx) * lissie->rx); lissie->loc[p].y = lissie->yi + (int) (sin(lissie->ty) * lissie->ry); /* Mask */ XSetForeground(display, gc, MI_BLACK_PIXEL(mi)); Lissie(oldp); /* Redraw */ if (MI_NPIXELS(mi) > 2) { XSetForeground(display, gc, MI_PIXEL(mi, lissie->color)); if (++lissie->color >= (unsigned) MI_NPIXELS(mi)) lissie->color = 0; } else XSetForeground(display, gc, MI_WHITE_PIXEL(mi)); Lissie(p); if (lissie->redrawing) { int i; lissie->redrawpos++; /* This compensates for the changed p since the last callback. */ for (i = 0; i < REDRAWSTEP; i++) { Lissie((p - lissie->redrawpos + MAXLISSIELEN) % MAXLISSIELEN); if (++(lissie->redrawpos) >= lissie->len) { lissie->redrawing = 0; break; } } } }
static void level1_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; if (MI_NPIXELS(mi) > 2) /* color */ XSetForeground(display, gc, MI_PIXEL(mi, st->color)); else XSetForeground(display, gc, MI_WHITE_PIXEL(mi)); XDrawLine(display, window, gc, bolt.end1.x - 1, bolt.end1.y, bolt.middle[0].x - 1, bolt.middle[0].y); draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, -1); XDrawLine(display, window, gc, bolt.middle[BOLT_VERTICIES - 1].x - 1, bolt.middle[BOLT_VERTICIES - 1].y, bolt.end2.x - 1, bolt.end2.y); XDrawLine(display, window, gc, bolt.end1.x + 1, bolt.end1.y, bolt.middle[0].x + 1, bolt.middle[0].y); draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, 1); XDrawLine(display, window, gc, bolt.middle[BOLT_VERTICIES - 1].x + 1, bolt.middle[BOLT_VERTICIES - 1].y, bolt.end2.x + 1, bolt.end2.y); for (i = 0; i < bolt.fork_number; i++) { draw_line(mi, bolt.branch[i].ForkVerticies, bolt.branch[i].num_used, gc, -1); draw_line(mi, bolt.branch[i].ForkVerticies, bolt.branch[i].num_used, gc, 1); } first_strike(bolt, mi); }
static void drawcell(ModeInfo * mi, int col, int row, unsigned char color) { antfarmstruct *ap = &antfarms[MI_SCREEN(mi)]; GC gc; if (!color) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi)); gc = MI_GC(mi); } else if (MI_NPIXELS(mi) > 2) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_PIXEL(mi, ap->colors[color - 1])); gc = MI_GC(mi); } else { XGCValues gcv; gcv.stipple = ap->pixmaps[color - 1]; gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), ap->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = ap->stippledGC; } fillcell(mi, gc, col, row); }
static void init_planet(ModeInfo * mi, planetstruct * planet) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); gravstruct *gp = &gravs[MI_SCREEN(mi)]; if (MI_NPIXELS(mi) > 2) planet->colors = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else planet->colors = MI_WHITE_PIXEL(mi); /* Initialize positions */ POS(X) = FLOATRAND(-XR, XR); POS(Y) = FLOATRAND(-YR, YR); POS(Z) = FLOATRAND(-ZR, ZR); if (POS(Z) > -ALMOST) { planet->xi = (int) ((double) gp->width * (HALF + POS(X) / (POS(Z) + DIST))); planet->yi = (int) ((double) gp->height * (HALF + POS(Y) / (POS(Z) + DIST))); } else planet->xi = planet->yi = -1; planet->ri = RADIUS; /* Initialize velocities */ VEL(X) = FLOATRAND(-VR, VR); VEL(Y) = FLOATRAND(-VR, VR); VEL(Z) = FLOATRAND(-VR, VR); /* Draw planets */ Planet(planet->xi, planet->yi); }
static void InitDrop(ModeInfo * mi, rainstruct *rp, dropstruct *drop) { /* Where does the drop fall in the pool? At least 20% of height from top and not completely at the bottom */ int yMin = MI_HEIGHT(mi) / 5; int yMax = MI_HEIGHT(mi) - ((MAX_RADIUS * 3) / 2); drop->pool.x = 0; drop->pool.y = yMin + NRAND(yMax - yMin); /* How fast does it fall? */ drop->offset.x = 5 + NRAND(5); drop->offset.y = 20 + NRAND(20); /* Where does the drop start */ drop->drop.x = NRAND(MI_WIDTH(mi)); drop->drop.height = 0; drop->drop.width = drop->drop.x + drop->offset.x; drop->drop.y = drop->drop.height + drop->offset.y; /* How large is the pool and how fast does it grow? */ drop->radius = 0; drop->radius_step = 1 + NRAND(2); drop->max_radius = (MAX_RADIUS / 2) + NRAND(MAX_RADIUS / 2); /* Colored drops? */ if (rp->colored_drops) { if (rp->base_color == 0) drop->color = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else drop->color = rp->base_color + (NRAND(2) == 1 ? -1 : 1) * NRAND(12); } else drop->color = MI_WHITE_PIXEL(mi); }
static void init_planet(ModeInfo * mi, planetstruct * planet) { gravstruct *gp = &gravs[MI_SCREEN(mi)]; # ifdef HAVE_JWXYZ jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False); # endif if (MI_NPIXELS(mi) > 2) planet->colors = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else planet->colors = MI_WHITE_PIXEL(mi); /* Initialize positions */ POS(X) = FLOATRAND(-XR, XR); POS(Y) = FLOATRAND(-YR, YR); POS(Z) = FLOATRAND(-ZR, ZR); if (POS(Z) > -ALMOST) { planet->xi = (int) ((double) gp->width * (HALF + POS(X) / (POS(Z) + DIST))); planet->yi = (int) ((double) gp->height * (HALF + POS(Y) / (POS(Z) + DIST))); } else planet->xi = planet->yi = -1; planet->ri = RADIUS; /* Initialize velocities */ VEL(X) = FLOATRAND(-VR, VR); VEL(Y) = FLOATRAND(-VR, VR); VEL(Z) = FLOATRAND(-VR, VR); }
void draw_turtle(ModeInfo * mi) { turtlestruct *tp; if (turtles == NULL) return; tp = &turtles[MI_SCREEN(mi)]; if (++tp->time > MI_CYCLES(mi)) init_turtle(mi); MI_IS_DRAWN(mi) = True; if (MI_NPIXELS(mi) > 2) XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)))); tp->r = tp->r >> 1; tp->level++; if (tp->r > 1) switch (tp->curve) { case HILBERT: switch (tp->dir) { case 0: tp->pt1.x = tp->pt2.x = tp->start.x + tp->r / 2; tp->pt1.y = tp->pt2.y = tp->start.y + tp->r / 2; generate_hilbert(mi, 0, tp->r); break; case 1: tp->pt1.x = tp->pt2.x = tp->start.x + tp->min - tp->r / 2; tp->pt1.y = tp->pt2.y = tp->start.y + tp->min - tp->r / 2; generate_hilbert(mi, 0, -tp->r); break; case 2: tp->pt1.x = tp->pt2.x = tp->start.x + tp->min - tp->r / 2; tp->pt1.y = tp->pt2.y = tp->start.y + tp->min - tp->r / 2; generate_hilbert(mi, -tp->r, 0); break; case 3: tp->pt1.x = tp->pt2.x = tp->start.x + tp->r / 2; tp->pt1.y = tp->pt2.y = tp->start.y + tp->r / 2; generate_hilbert(mi, tp->r, 0); } break; case CESARO_VAR: generate_cesarovar(mi, (double) tp->pt1.x, (double) tp->pt1.y, (double) tp->pt2.x, (double) tp->pt2.y, tp->level, tp->sign); break; case HARTER_HEIGHTWAY: generate_harter_heightway(mi, (double) tp->pt1.x, (double) tp->pt1.y, (double) tp->pt2.x, (double) tp->pt2.y, tp->level, tp->sign); break; } }
ENTRYPOINT void draw_fadeplot (ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); int i, j, temp; fadeplotstruct *fp; if (fadeplots == NULL) return; fp = &fadeplots[MI_SCREEN(mi)]; if (fp->stab == NULL) return; MI_IS_DRAWN(mi) = True; XSetForeground(display, gc, MI_BLACK_PIXEL(mi)); XDrawPoints(display, window, gc, fp->pts, fp->maxpts, CoordModeOrigin); if (MI_NPIXELS(mi) > 2) { XSetForeground(display, gc, MI_PIXEL(mi, fp->pix)); if (++fp->pix >= MI_NPIXELS(mi)) fp->pix = 0; } else XSetForeground(display, gc, MI_WHITE_PIXEL(mi)); temp = 0; for (j = 0; j < fp->nbstep; j++) { for (i = 0; i < fp->maxpts / fp->nbstep; i++) { fp->pts[temp].x = fp->stab[(fp->st.x + fp->speed.x * j + i * fp->step.x) % fp->angles] * fp->factor.x + fp->width / 2 - fp->min; fp->pts[temp].y = fp->stab[(fp->st.y + fp->speed.y * j + i * fp->step.y) % fp->angles] * fp->factor.y + fp->height / 2 - fp->min; temp++; } } XDrawPoints(display, window, gc, fp->pts, temp, CoordModeOrigin); fp->st.x = (fp->st.x + fp->speed.x) % fp->angles; fp->st.y = (fp->st.y + fp->speed.y) % fp->angles; fp->temps++; if ((fp->temps % (fp->angles / 2)) == 0) { fp->temps = fp->temps % fp->angles * 5; if ((fp->temps % (fp->angles)) == 0) fp->speed.y = (fp->speed.y + 1) % 30 + 1; if ((fp->temps % (fp->angles * 2)) == 0) fp->speed.x = (fp->speed.x) % 20; if ((fp->temps % (fp->angles * 3)) == 0) fp->step.y = (fp->step.y + 1) % 2 + 1; MI_CLEARWINDOW(mi); } }
void draw_blot(ModeInfo * mi) { blotstruct *bp; XPoint *xp; int x, y, k; if (blots == NULL) return; bp = &blots[MI_SCREEN(mi)]; xp = bp->pointBuffer; if (xp == NULL) init_blot(mi); MI_IS_DRAWN(mi) = True; if (MI_NPIXELS(mi) > 2) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_PIXEL(mi, bp->pix)); if (++bp->pix >= MI_NPIXELS(mi)) bp->pix = 0; } x = bp->xmid; y = bp->ymid; k = bp->size; while (k >= 4) { x += (NRAND(1 + (bp->offset << 1)) - bp->offset); y += (NRAND(1 + (bp->offset << 1)) - bp->offset); k--; xp->x = x; xp->y = y; xp++; if (bp->xsym) { k--; xp->x = bp->width - x; xp->y = y; xp++; } if (bp->ysym) { k--; xp->x = x; xp->y = bp->height - y; xp++; } if (bp->xsym && bp->ysym) { k--; xp->x = bp->width - x; xp->y = bp->height - y; xp++; } } XDrawPoints(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi), bp->pointBuffer, (bp->size - k), CoordModeOrigin); if (++bp->count > MI_CYCLES(mi)) init_blot(mi); }
/* Sets the color to the color of a wall. */ static void setwallcolor(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); pacmangamestruct *pp = &pacmangames[MI_SCREEN(mi)]; if (MI_NPIXELS(mi) > 2) XSetForeground(display, pp->stippledGC, MI_PIXEL(mi, BLUE)); else XSetForeground(display, pp->stippledGC, MI_WHITE_PIXEL(mi)); }
static void drawImages(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); imagestruct *ip = &ims[MI_SCREEN(mi)]; GC gc = (message && *message) ? MI_GC(mi) : ip->bgGC; int i; MI_CLEARWINDOWCOLORMAPFAST(mi, gc, ip->black); for (i = 0; i < ip->iconcount; i++) { if (ip->icons[i].x >= 0) { if (message && *message) { if (MI_NPIXELS(mi) > 2) XSetForeground(display, gc, MI_PIXEL(mi, ip->icons[i].color)); else XSetForeground(display, gc, MI_WHITE_PIXEL(mi)); XCopyPlane(display, ip->pixmap, window, gc, 0, 0, ip->pixw, ip->pixh, ip->pixw * ip->icons[i].x + ip->image_offset.x, ip->pixh * ip->icons[i].y + ip->image_offset.y, 1L); } else if (ip->logo != NULL) { if (MI_NPIXELS(mi) <= 2) XSetForeground(display, gc, MI_WHITE_PIXEL(mi)); else if (ip->graphics_format < IS_XPM) XSetForeground(display, gc, MI_PIXEL(mi, ip->icons[i].color)); (void) XPutImage(display, window, gc, ip->logo, 0, 0, ip->pixw * ip->icons[i].x + ip->image_offset.x, ip->pixh * ip->icons[i].y + ip->image_offset.y, ip->pixw, ip->pixh); } } } }
static void random_petal(ModeInfo * mi) { petalstruct *pp = &petals[MI_SCREEN(mi)]; pp->npoints = compute_petal(pp->points, pp->lines, pp->width / 2, pp->height / 2); if (MI_NPIXELS(mi) <= 2) pp->color = MI_WHITE_PIXEL(mi); else pp->color = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); petal(mi); }
static void InitDropColors(ModeInfo * mi, rainstruct *rp) { /* Once in every 10 times show only white drops */ rp->colored_drops = (NRAND(10) != 1); /* When using colored, use the all random colors or around the base color */ if (rp->colored_drops) { if (NRAND(2) == 1) rp->base_color = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else rp->base_color = 0; } }
ENTRYPOINT void init_grav(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); GC gc = MI_GC(mi); unsigned char ball; gravstruct *gp; if (gravs == NULL) { if ((gravs = (gravstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (gravstruct))) == NULL) return; } gp = &gravs[MI_SCREEN(mi)]; gp->width = MI_WIDTH(mi); gp->height = MI_HEIGHT(mi); gp->sr = STARRADIUS; gp->nplanets = MI_COUNT(mi); if (gp->nplanets < 0) { if (gp->planets) { (void) free((void *) gp->planets); gp->planets = (planetstruct *) NULL; } gp->nplanets = NRAND(-gp->nplanets) + 1; /* Add 1 so its not too boring */ } if (gp->planets == NULL) { if ((gp->planets = (planetstruct *) calloc(gp->nplanets, sizeof (planetstruct))) == NULL) return; } MI_CLEARWINDOW(mi); if (MI_NPIXELS(mi) > 2) gp->starcolor = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else gp->starcolor = MI_WHITE_PIXEL(mi); for (ball = 0; ball < (unsigned char) gp->nplanets; ball++) init_planet(mi, &gp->planets[ball]); /* Draw centrepoint */ XDrawArc(display, MI_WINDOW(mi), gc, gp->width / 2 - gp->sr / 2, gp->height / 2 - gp->sr / 2, gp->sr, gp->sr, 0, 23040); }
ENTRYPOINT void draw_worm (ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); wormstruct *wp = &worms[MI_SCREEN(mi)]; unsigned long wcolor; int i; (void) memset((char *) wp->size, 0, wp->nc * sizeof (int)); for (i = 0; i < wp->nw; i++) { if (MI_NPIXELS(mi) > 2) { wcolor = (i + wp->chromo) % wp->nc; worm_doit(mi, i, wcolor); } else worm_doit(mi, i, (unsigned long) 0); } if (MI_WIN_IS_USE3D(mi)) { if (MI_WIN_IS_INSTALL(mi)) XSetFunction(display, gc, GXor); XSetForeground(display, gc, MI_RIGHT_COLOR(mi)); XFillRectangles(display, window, gc, &(wp->rects[0]), wp->size[0]); XSetForeground(display, gc, MI_LEFT_COLOR(mi)); XFillRectangles(display, window, gc, &(wp->rects[wp->maxsize]), wp->size[1]); if (MI_WIN_IS_INSTALL(mi)) XSetFunction(display, gc, GXcopy); } else if (MI_NPIXELS(mi) > 2) { for (i = 0; i < wp->nc; i++) { XSetForeground(display, gc, MI_PIXEL(mi, i)); XFillRectangles(display, window, gc, &(wp->rects[i * wp->maxsize]), wp->size[i]); } } else { XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi)); XFillRectangles(display, window, gc, &(wp->rects[0]), wp->size[0]); } if (++wp->chromo == (unsigned long) wp->nc) wp->chromo = 0; }
static void drawCell(ModeInfo * mi, int col, int row, unsigned char state) { circuitstruct *wp = &circuits[MI_SCREEN(mi)]; GC gc; if (MI_NPIXELS(mi) > 2) { gc = MI_GC(mi); XSetForeground(MI_DISPLAY(mi), gc, MI_PIXEL(mi, wp->colors[state])); } else { XGCValues gcv; gcv.stipple = wp->pixmaps[state]; gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), wp->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = wp->stippledGC; } fillcell(mi, gc, col, row); }
static void drawCell_notused(ModeInfo * mi, int col, int row, unsigned char state) { circuitstruct *wp = &circuits[MI_SCREEN(mi)]; XGCValues gcv; GC gc; if (MI_NPIXELS(mi) > 2) { gc = MI_GC(mi); XSetForeground(MI_DISPLAY(mi), gc, MI_PIXEL(mi, wp->colors[state])); } else { gcv.stipple = wp->pixmaps[state]; gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), wp->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = wp->stippledGC; } XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi), wp->xb + wp->xs * col, wp->yb + wp->ys * row, wp->xs - (wp->xs > 3), wp->ys - (wp->ys > 3)); }
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 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); }
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); } }
ENTRYPOINT void init_grav(ModeInfo * mi) { unsigned char ball; gravstruct *gp; MI_INIT (mi, gravs); gp = &gravs[MI_SCREEN(mi)]; gp->width = MI_WIDTH(mi); gp->height = MI_HEIGHT(mi); gp->sr = STARRADIUS; gp->nplanets = MI_COUNT(mi); if (gp->nplanets < 0) { if (gp->planets) { (void) free((void *) gp->planets); gp->planets = (planetstruct *) NULL; } gp->nplanets = NRAND(-gp->nplanets) + 1; /* Add 1 so its not too boring */ } if (gp->planets == NULL) { if ((gp->planets = (planetstruct *) calloc(gp->nplanets, sizeof (planetstruct))) == NULL) return; } MI_CLEARWINDOW(mi); if (MI_NPIXELS(mi) > 2) gp->starcolor = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else gp->starcolor = MI_WHITE_PIXEL(mi); for (ball = 0; ball < (unsigned char) gp->nplanets; ball++) init_planet(mi, &gp->planets[ball]); }
static void init_fly(ModeInfo * mi, Fly * f) { EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)]; int win_width = MI_WIDTH(mi); int win_height = MI_HEIGHT(mi); (void) memset((char *) f, 0, sizeof (Fly)); /* clear everything to zero */ f->side = FLY_SIDE_LEFT; if (!MI_IS_ICONIC(mi)) { f->width = ep->flywidth; f->height = ep->flyheight; f->vx = NRAND(15) + 1; /* random horiz velocity */ } else { /* image is just a dot when iconic */ f->width = f->height = FLY_ICON_SIZE; f->vx = NRAND(4) + 1; /* slower when iconic */ } f->y = NRAND(win_height); if (f->y > (win_height / 2)) { f->side = FLY_SIDE_RIGHT; /* change to right side */ f->y -= win_height / 2; /* start in top half */ f->x = win_width - f->width; /* move to right of screen */ f->vx = -(f->vx); /* flip direction */ } f->oldx = -(f->width); /* prevent undraw 1st time */ if (MI_NPIXELS(mi) <= 2) { f->pixel = MI_WHITE_PIXEL(mi); /* always white when mono */ } else { f->pixel = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); } }
void init_toneclock(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int i, size_hour, istart; toneclockstruct *tclock; /* initialize */ if (toneclocks == NULL) { if ((toneclocks = (toneclockstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (toneclockstruct))) == NULL) return; } tclock = &toneclocks[MI_SCREEN(mi)]; tclock->mi = mi; if (tclock->gc == None) { if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { XColor color; #ifndef STANDALONE tclock->fg = MI_FG_PIXEL(mi); tclock->bg = MI_BG_PIXEL(mi); #endif tclock->blackpixel = MI_BLACK_PIXEL(mi); tclock->whitepixel = MI_WHITE_PIXEL(mi); if ((tclock->cmap = XCreateColormap(display, window, MI_VISUAL(mi), AllocNone)) == None) { free_toneclock(display, tclock); return; } XSetWindowColormap(display, window, tclock->cmap); (void) XParseColor(display, tclock->cmap, "black", &color); (void) XAllocColor(display, tclock->cmap, &color); MI_BLACK_PIXEL(mi) = color.pixel; (void) XParseColor(display, tclock->cmap, "white", &color); (void) XAllocColor(display, tclock->cmap, &color); MI_WHITE_PIXEL(mi) = color.pixel; #ifndef STANDALONE (void) XParseColor(display, tclock->cmap, background, &color); (void) XAllocColor(display, tclock->cmap, &color); MI_BG_PIXEL(mi) = color.pixel; (void) XParseColor(display, tclock->cmap, foreground, &color); (void) XAllocColor(display, tclock->cmap, &color); MI_FG_PIXEL(mi) = color.pixel; #endif tclock->colors = (XColor *) NULL; tclock->ncolors = 0; } if ((tclock->gc = XCreateGC(display, MI_WINDOW(mi), (unsigned long) 0, (XGCValues *) NULL)) == None) { free_toneclock(display, tclock); return; } } /* Clear Display */ MI_CLEARWINDOW(mi); tclock->painted = False; XSetFunction(display, tclock->gc, GXxor); /*Set up toneclock data */ if (MI_IS_FULLRANDOM(mi)) { if (NRAND(10)) tclock->original = False; else tclock->original = True; } else { tclock->original = original; } tclock->direction = (LRAND() & 1) ? 1 : -1; tclock->win_width = MI_WIDTH(mi); tclock->win_height = MI_HEIGHT(mi); if (tclock->hour != NULL) free_hour(tclock); if ( tclock->original ) { tclock->num_hour = 12; } else { tclock->num_hour = MI_COUNT(mi); } tclock->x0 = tclock->win_width / 2; tclock->y0 = tclock->win_height / 2; if (tclock->num_hour == 0) { tclock->num_hour = DEF_NUM_hour; } else if (tclock->num_hour < 0) { tclock->num_hour = NRAND(-tclock->num_hour) + 1; } if ( tclock->num_hour < 12 ) istart = NRAND( 12 - tclock->num_hour ); else istart = 0; if ((tclock->hour = (toneclockhour *) calloc(tclock->num_hour, sizeof (toneclockhour))) == NULL) { free_toneclock(display, tclock); return; } if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { /* Set up colour map */ if (tclock->colors != NULL) { if (tclock->ncolors && !tclock->no_colors) free_colors(display, tclock->cmap, tclock->colors, tclock->ncolors); free(tclock->colors); tclock->colors = (XColor *) NULL; } tclock->ncolors = MI_NCOLORS(mi); if (tclock->ncolors < 2) tclock->ncolors = 2; if (tclock->ncolors <= 2) tclock->mono_p = True; else tclock->mono_p = False; if (tclock->mono_p) tclock->colors = (XColor *) NULL; else if ((tclock->colors = (XColor *) malloc(sizeof (*tclock->colors) * (tclock->ncolors + 1))) == NULL) { free_toneclock(display, tclock); return; } tclock->cycle_p = has_writable_cells(mi); if (tclock->cycle_p) { if (MI_IS_FULLRANDOM(mi)) { if (!NRAND(8)) tclock->cycle_p = False; else tclock->cycle_p = True; } else { tclock->cycle_p = cycle_p; } } if (!tclock->mono_p) { if (!(LRAND() % 10)) make_random_colormap( #ifdef STANDALONE MI_DISPLAY(mi), MI_WINDOW(mi), #else mi, #endif tclock->cmap, tclock->colors, &tclock->ncolors, True, True, &tclock->cycle_p); else if (!(LRAND() % 2)) make_uniform_colormap( #ifdef STANDALONE MI_DISPLAY(mi), MI_WINDOW(mi), #else mi, #endif tclock->cmap, tclock->colors, &tclock->ncolors, True, &tclock->cycle_p); else make_smooth_colormap( #ifdef STANDALONE MI_DISPLAY(mi), MI_WINDOW(mi), #else mi, #endif tclock->cmap, tclock->colors, &tclock->ncolors, True, &tclock->cycle_p); } XInstallColormap(display, tclock->cmap); if (tclock->ncolors < 2) { tclock->ncolors = 2; tclock->no_colors = True; } else tclock->no_colors = False; if (tclock->ncolors <= 2) tclock->mono_p = True; if (tclock->mono_p) tclock->cycle_p = False; } #ifndef NO_DBUF if (tclock->dbuf != None) XFreePixmap(display, tclock->dbuf); tclock->dbuf = XCreatePixmap(display, window, tclock->win_width, tclock->win_height, MI_DEPTH(mi)); /* Allocation checked */ if (tclock->dbuf != None) { XGCValues gcv; gcv.foreground = 0; gcv.background = 0; gcv.graphics_exposures = False; gcv.function = GXcopy; if (tclock->dbuf_gc != None) XFreeGC(display, tclock->dbuf_gc); if ((tclock->dbuf_gc = XCreateGC(display, (Drawable) tclock->dbuf, GCForeground | GCBackground | GCGraphicsExposures | GCFunction, &gcv)) == None) { XFreePixmap(display, tclock->dbuf); tclock->dbuf = None; } else { XFillRectangle(display, (Drawable) tclock->dbuf, tclock->dbuf_gc, 0, 0, tclock->win_width, tclock->win_height); /*XSetBackground(display, MI_GC(mi), MI_BLACK_PIXEL(mi)); XSetFunction(display, MI_GC(mi), GXcopy);*/ } } #endif tclock->angle = NRAND(360) * PI_RAD; tclock->velocity = (NRAND(7) - 3) * PI_RAD; size_hour = MIN( tclock->win_width , tclock->win_height) / 3; tclock->pulsating = False; tclock->moving = False; tclock->anglex = 0.0; tclock->angley = 0.0; tclock->fill = 0; tclock->radius = size_hour; tclock->max_radius =0.0; if ( ( !tclock->original && NRAND( 15 ) == 3 ) || tclock->num_hour > 12 ) tclock->randomhour = True; else tclock->randomhour = False; if ( !tclock->original && tclock->win_width > 20 ) { if ( abs( MI_SIZE(mi) ) > size_hour ) { if ( MI_SIZE( mi ) < 0 ) { size_hour = -size_hour; } } else { size_hour = MI_SIZE(mi); } if ( size_hour < 0 ) { tclock->radius = MIN(NRAND( size_hour - 10) + 10, tclock->radius ); } else { tclock->radius = MIN( size_hour , tclock->radius ); } if ( MI_IS_FULLRANDOM( mi ) ) { if ( NRAND(2) ) tclock->pulsating = True; else tclock->pulsating = False; tclock->fill = NRAND( 101 ); } else { tclock->pulsating = pulsating; tclock->fill = fill; } } tclock->phase = 0.0; if ( tclock->pulsating ) tclock->ph_vel = (NRAND(7) - 3) * PI_RAD; for (i = 0; i < tclock->num_hour; i++) { toneclockhour *hour0; hour0 = &tclock->hour[i]; if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { if (tclock->ncolors > 2) hour0->colour = NRAND(tclock->ncolors - 2) + 2; else hour0->colour = 1; /* Just in case */ XSetForeground(display, tclock->gc, tclock->colors[hour0->colour].pixel); } else { if (MI_NPIXELS(mi) > 2) hour0->colour = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else hour0->colour = 1; /*Xor'red so WHITE may not be appropriate */ XSetForeground(display, tclock->gc, hour0->colour); } hour0->angle = NRAND(360) * PI_RAD; hour0->velocity = (NRAND(7) - 3) * PI_RAD; hour0->radius = tclock->radius / 5.0; tclock->max_radius = MAX( tclock->max_radius , hour0->radius ); hour0->num_point = 12; hour0->num_point1 = 16; if ( tclock->randomhour ) { int j; hour0->point_numbers = tclock->hexadecimal_clock + i * hour0->num_point1; if ( NRAND( 14 ) == 4 ) { for (j = 0; j < ( hour0->num_point1 / 4 ) - 1 ; j++) { hour0->point_numbers[ j * 4 ] = NRAND( 12 ) + 1; hour0->point_numbers[ j * 4 + 1 ] = NRAND( 12 ) + 1; hour0->point_numbers[ j * 4 + 2 ] = NRAND( 12 ) + 1; hour0->point_numbers[ j * 4 + 3 ] = NRAND( 12 ) + 1; } hour0->point_numbers[ hour0->num_point1 / 4 ] = 1; hour0->point_numbers[ 1 + hour0->num_point1 / 4 ] = 1; hour0->point_numbers[ 2 + hour0->num_point1 / 4 ] = 1; hour0->point_numbers[ 3 + hour0->num_point1 / 4 ] = 1; } else { for (j = 0; j < hour0->num_point1 / 4 ; j++) { hour0->point_numbers[ j * 4 ] = NRAND( 12 ) + 1; hour0->point_numbers[ j * 4 + 1 ] = hour0->point_numbers[ j * 4 ]; hour0->point_numbers[ j * 4 + 2 ] = NRAND( 12 ) + 1; hour0->point_numbers[ j * 4 + 3 ] = NRAND( 12 ) + 1; } } } else hour0->point_numbers = original_clock[i+istart]; if ( NRAND( 100 ) >= tclock->fill ) hour0->draw = True; else hour0->draw = False; #ifdef NO_DBUF { int x0 , y0; x0 = (int) (tclock->radius * sin( -tclock->angle - PI_RAD * i * 360.0 / tclock->num_hour ) * 0.5 * ( 1 + cos( tclock->phase ) ) + tclock->x0 + tclock->a_x * sin( tclock->anglex ) ); y0 = (int) (tclock->radius * cos( -tclock->angle - PI_RAD * i * 360.0 / tclock->num_hour ) * 0.5 * ( 1 + cos( tclock->phase ) ) + tclock->y0 + tclock->a_y * sin( tclock->angley ) ); toneclock_drawhour(mi , hour0 , x0 , y0 ); } #endif } tclock->a_x = 0; tclock->a_y = 0; if ( !tclock->original && tclock->win_width > 20 ) { if ( tclock->radius < MIN( tclock->win_width , tclock->win_height) / 4 ) { if ( MI_IS_FULLRANDOM( mi ) ) { if ( NRAND(2) ) tclock->moving = True; } else { tclock->moving = move_clock; } if ( tclock->moving ) { tclock->a_x = (int) floor( ( tclock->win_width / 2 ) - 1.05 * ( tclock->radius + tclock->max_radius ) ); tclock->a_y = (int) floor( ( tclock->win_height / 2 ) - 1.05 * ( tclock->radius + tclock->max_radius ) ); tclock->vx = (NRAND(15) - 7) * PI_RAD; tclock->vy = (NRAND(15) - 7) * PI_RAD; } } } XFlush(display); XSetFunction(display, tclock->gc, GXcopy); }
void init_laser(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); int i, c = 0; lasersstruct *lp; if (lasers == NULL) { if ((lasers = (lasersstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (lasersstruct))) == NULL) return; } lp = &lasers[MI_SCREEN(mi)]; lp->width = MI_WIDTH(mi); lp->height = MI_HEIGHT(mi); lp->time = 0; lp->ln = MI_COUNT(mi); if (lp->ln < -MINLASER) { /* if lp->ln is random ... the size can change */ if (lp->laser != NULL) { free(lp->laser); lp->laser = (laserstruct *) NULL; } lp->ln = NRAND(-lp->ln - MINLASER + 1) + MINLASER; } else if (lp->ln < MINLASER) lp->ln = MINLASER; if (lp->laser == NULL) { if ((lp->laser = (laserstruct *) malloc(lp->ln * sizeof (laserstruct))) == NULL) { free_laser(display, lp); return; } } if (lp->stippledGC == None) { XGCValues gcv; gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); lp->gcv_black.foreground = MI_BLACK_PIXEL(mi); if ((lp->stippledGC = XCreateGC(display, MI_WINDOW(mi), GCForeground | GCBackground, &gcv)) == None) { free_laser(display, lp); return; } } MI_CLEARWINDOWCOLORMAPFAST(mi, MI_GC(mi), MI_BLACK_PIXEL(mi)); if (MINDIST < lp->width - MINDIST) lp->cx = RANGE_RAND(MINDIST, lp->width - MINDIST); else lp->cx = RANGE_RAND(0, lp->width); if (MINDIST < lp->height - MINDIST) lp->cy = RANGE_RAND(MINDIST, lp->height - MINDIST); else lp->cy = RANGE_RAND(0, lp->height); lp->lw = RANGE_RAND(MINWIDTH, MAXWIDTH); lp->lr = RANGE_RAND(MINREDRAW, MAXREDRAW); lp->sw = 0; lp->so = 0; if (MI_NPIXELS(mi) > 2) c = NRAND(MI_NPIXELS(mi)); for (i = 0; i < lp->ln; i++) { laserstruct *l = &lp->laser[i]; l->bn = (border) NRAND(4); switch (l->bn) { case TOP: l->bx = NRAND(lp->width); l->by = 0; break; case RIGHT: l->bx = lp->width; l->by = NRAND(lp->height); break; case BOTTOM: l->bx = NRAND(lp->width); l->by = lp->height; break; case LEFT: l->bx = 0; l->by = NRAND(lp->height); } l->dir = (int) (LRAND() & 1); l->speed = ((RANGE_RAND(MINSPEED, MAXSPEED) * lp->width) / 1000) + 1; if (MI_NPIXELS(mi) > 2) { l->gcv.foreground = MI_PIXEL(mi, c); c = (c + COLORSTEP) % MI_NPIXELS(mi); } else l->gcv.foreground = MI_WHITE_PIXEL(mi); } }
static Bool draw_state(ModeInfo * mi, int state) { demonstruct *dp = &demons[MI_SCREEN(mi)]; GC gc; XRectangle *rects; CellList *current; if (!state) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi)); gc = MI_GC(mi); } else if (MI_NPIXELS(mi) >= NUMSTIPPLES) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_PIXEL(mi, (((int) state - 1) * MI_NPIXELS(mi) / (dp->states - 1)) % MI_NPIXELS(mi))); gc = MI_GC(mi); } else { XGCValues gcv; #ifdef DO_STIPPLE gcv.stipple = dp->pixmaps[(state - 1) % (NUMSTIPPLES - 1)]; #endif /* DO_STIPPLE */ gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), dp->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = dp->stippledGC; } if (dp->neighbors == 6) { /* Draw right away, slow */ current = dp->cellList[state]; while (current) { int col, row, ccol, crow; col = current->pt.x; row = current->pt.y; ccol = 2 * col + !(row & 1), crow = 2 * row; dp->shape.hexagon[0].x = dp->xb + ccol * dp->xs; dp->shape.hexagon[0].y = dp->yb + crow * dp->ys; if (dp->xs == 1 && dp->ys == 1) XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->shape.hexagon[0].x, dp->shape.hexagon[0].y); else XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->shape.hexagon, 6, Convex, CoordModePrevious); current = current->next; } } else if (dp->neighbors == 4 || dp->neighbors == 8) { /* Take advantage of XDrawRectangles */ int ncells = 0; /* Create Rectangle list from part of the cellList */ if ((rects = (XRectangle *) malloc(dp->ncells[state] * sizeof (XRectangle))) == NULL) { return False; } current = dp->cellList[state]; while (current) { rects[ncells].x = dp->xb + current->pt.x * dp->xs; rects[ncells].y = dp->yb + current->pt.y * dp->ys; rects[ncells].width = dp->xs - (dp->xs > 3); rects[ncells].height = dp->ys - (dp->ys > 3); current = current->next; ncells++; } /* Finally get to draw */ XFillRectangles(MI_DISPLAY(mi), MI_WINDOW(mi), gc, rects, ncells); /* Free up rects list and the appropriate part of the cellList */ (void) free((void *) rects); } else { /* TRI */ current = dp->cellList[state]; while (current) { int col, row, orient; col = current->pt.x; row = current->pt.y; orient = (col + row) % 2; /* O left 1 right */ dp->shape.triangle[orient][0].x = dp->xb + col * dp->xs; dp->shape.triangle[orient][0].y = dp->yb + row * dp->ys; if (dp->xs <= 3 || dp->ys <= 3) XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc, ((orient) ? -1 : 1) + dp->shape.triangle[orient][0].x, dp->shape.triangle[orient][0].y); else { if (orient) dp->shape.triangle[orient][0].x += (dp->xs / 2 - 1); else dp->shape.triangle[orient][0].x -= (dp->xs / 2 - 1); XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->shape.triangle[orient], 3, Convex, CoordModePrevious); } current = current->next; } } free_state(dp, state); return True; }
static void drawcell(ModeInfo * mi, int col, int row, unsigned char state) { demonstruct *dp = &demons[MI_SCREEN(mi)]; GC gc; if (!state) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi)); gc = MI_GC(mi); } else if (MI_NPIXELS(mi) >= NUMSTIPPLES) { XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_PIXEL(mi, (((int) state - 1) * MI_NPIXELS(mi) / (dp->states - 1)) % MI_NPIXELS(mi))); gc = MI_GC(mi); } else { XGCValues gcv; #ifdef DO_STIPPLE gcv.stipple = dp->pixmaps[(state - 1) % (NUMSTIPPLES - 1)]; #endif /* DO_STIPPLE */ gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), dp->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = dp->stippledGC; } if (dp->neighbors == 6) { int ccol = 2 * col + !(row & 1), crow = 2 * row; dp->shape.hexagon[0].x = dp->xb + ccol * dp->xs; dp->shape.hexagon[0].y = dp->yb + crow * dp->ys; if (dp->xs == 1 && dp->ys == 1) XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->shape.hexagon[0].x, dp->shape.hexagon[0].y); else XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->shape.hexagon, 6, Convex, CoordModePrevious); } else if (dp->neighbors == 4 || dp->neighbors == 8) { XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->xb + dp->xs * col, dp->yb + dp->ys * row, dp->xs - (dp->xs > 3), dp->ys - (dp->ys > 3)); } else { /* TRI */ int orient = (col + row) % 2; /* O left 1 right */ dp->shape.triangle[orient][0].x = dp->xb + col * dp->xs; dp->shape.triangle[orient][0].y = dp->yb + row * dp->ys; if (dp->xs <= 3 || dp->ys <= 3) XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc, ((orient) ? -1 : 1) + dp->shape.triangle[orient][0].x, dp->shape.triangle[orient][0].y); else { if (orient) dp->shape.triangle[orient][0].x += (dp->xs / 2 - 1); else dp->shape.triangle[orient][0].x -= (dp->xs / 2 - 1); XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc, dp->shape.triangle[orient], 3, Convex, CoordModePrevious); } } }
void draw_mandelbrot(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int h; complex c; double demrange; mandelstruct *mp; if (mandels == NULL) return; mp = &mandels[MI_SCREEN(mi)]; MI_IS_DRAWN(mi) = True; if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { if (mp->mono_p) { XSetForeground(display, mp->gc, mp->cur_color); } else { mp->cur_color = (mp->cur_color + 1) % mp->ncolors; XSetForeground(display, mp->gc, mp->colors[mp->cur_color].pixel); } } else { if (MI_NPIXELS(mi) > 2) XSetForeground(display, mp->gc, MI_PIXEL(mi, mp->cur_color)); else if (mp->cur_color) XSetForeground(display, mp->gc, MI_BLACK_PIXEL(mi)); else XSetForeground(display, mp->gc, MI_WHITE_PIXEL(mi)); if (++mp->cur_color >= (unsigned int) MI_NPIXELS(mi)) mp->cur_color = 0; } /* Rotate colours */ if (mp->cycle_p) { rotate_colors(display, mp->cmap, mp->colors, mp->ncolors, mp->direction); if (!(LRAND() % 1000)) mp->direction = -mp->direction; } /* so we iterate columns beyond the width of the physical screen, so that ** we just wait around and show what we've done */ if ((!mp->backwards && (mp->column >= 3 * mp->screen_width)) || (mp->backwards && (mp->column < -2 * mp->screen_width))) { /* reset to left edge of screen, bump power */ mp->backwards = (Bool) (LRAND() & 1); if (mp->backwards) mp->column = mp->screen_width - 1; else mp->column = 0; mp->power = NRAND(3) + MINPOWER; /* select a new region! */ Select(&mp->extreme_ul,&mp->extreme_lr, mp->screen_width,mp->screen_height, (int) mp->power,mp->reptop, mp->pow, mp->sin, &mp->ul,&mp->lr); } else if (mp->column >= mp->screen_width || mp->column < 0) { /* delay a while */ if (mp->backwards) mp->column--; else mp->column++; mp->counter++; return; } /* demrange is used to give some idea of scale */ demrange = mp->dem ? fabs(mp->ul.real - mp->lr.real) / 2 : 0; for (h = 0; h < mp->screen_height; h++) { unsigned int color; int result; /* c.real = 1.3 - (double) mp->column / mp->screen_width * 3.4; */ /* c.imag = -1.6 + (double) h / mp->screen_height * 3.2; */ c.real = mp->ul.real + (mp->ul.real-mp->lr.real)*(((double)(mp->column))/mp->screen_width); c.imag = mp->ul.imag + (mp->ul.imag - mp->lr.imag)*(((double) h) / mp->screen_height); result = reps(c, mp->power, mp->reptop, mp->binary, mp->interior, demrange, mp->pow, mp->sin); if (result < 0 || result >= mp->reptop) XSetForeground(display, mp->gc, MI_BLACK_PIXEL(mi)); else { color=(unsigned int) ((MI_NPIXELS(mi) * (float)result) / mp->reptop); XSetForeground(display, mp->gc, MI_PIXEL(mi, color)); } /* we no longer have vertical symmetry - so we compute all points ** and don't draw with redundancy */ XDrawPoint(display, window, mp->gc, mp->column, h); } if (mp->backwards) mp->column--; else mp->column++; mp->counter++; if (mp->counter > MI_CYCLES(mi)) { init_mandelbrot(mi); } }
void init_puzzle(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); puzzlestruct *pp; int x, y; XPoint size; if (puzzles == NULL) { if ((puzzles = (puzzlestruct *) calloc(MI_NUM_SCREENS(mi), sizeof (puzzlestruct))) == NULL) return; } pp = &puzzles[MI_SCREEN(mi)]; if (pp->painted && pp->windowsize.x == MI_WIDTH(mi) && pp->windowsize.y == MI_HEIGHT(mi)) return; /* Debounce since refresh_puzzle is init_puzzle */ #ifdef HAVE_XPM if (pp->graphics_format >= IS_XPM) { /* This is needed when another program changes the colormap. */ free_puzzle(display, pp); } #endif if (!init_stuff(mi)) return; pp->excount = MI_COUNT(mi); if (pp->excount < 0) { if (pp->fixbuff != NULL) { free(pp->fixbuff); pp->fixbuff = (int *) NULL; } pp->excount = NRAND(-pp->excount) + 1; } pp->lastbox = -1; pp->moves = 0; pp->movingBox = False; pp->windowsize.x = MI_WIDTH(mi); pp->windowsize.y = MI_HEIGHT(mi); if (pp->windowsize.x < 7) pp->windowsize.x = 7; if (pp->windowsize.y < 7) pp->windowsize.y = 7; pp->forward = 1; pp->prev = 0; /* don't want any exposure events from XCopyArea */ XSetGraphicsExposures(display, pp->backGC, False); MI_CLEARWINDOWCOLORMAP(mi, pp->backGC, pp->black); if (pp->logo) { size.x = (pp->logo->width < pp->windowsize.x) ? pp->logo->width : pp->windowsize.x; size.y = (pp->logo->height < pp->windowsize.y) ? pp->logo->height : pp->windowsize.y; } else { size.x = pp->windowsize.x; size.y = pp->windowsize.y; } pp->boxsize.y = NRAND(1 + size.y / 4) + 6; pp->boxsize.x = NRAND(1 + size.x / 4) + 6; if ((pp->boxsize.x > 4 * pp->boxsize.y) || pp->boxsize.y > 4 * pp->boxsize.x) pp->boxsize.x = pp->boxsize.y = 2 * MIN(pp->boxsize.x, pp->boxsize.y); pp->count.x = size.x / pp->boxsize.x; pp->count.y = size.y / pp->boxsize.y; if (pp->bufferBox != None) { XFreePixmap(display, pp->bufferBox); pp->bufferBox = None; } pp->usablewindow.x = pp->count.x * pp->boxsize.x; pp->usablewindow.y = pp->count.y * pp->boxsize.y; pp->offsetwindow.x = (pp->windowsize.x - pp->usablewindow.x) / 2; pp->offsetwindow.y = (pp->windowsize.y - pp->usablewindow.y) / 2; pp->incrementOfMove = MIN(pp->usablewindow.x, pp->usablewindow.y) / 20; pp->incrementOfMove = MAX(pp->incrementOfMove, 1); if (pp->logo) { pp->randompos.x = NRAND(MAX((pp->windowsize.x - pp->logo->width), 2 * pp->offsetwindow.x + 1)); pp->randompos.y = NRAND(MAX((pp->windowsize.y - pp->logo->height), 2 * pp->offsetwindow.y + 1)); if (MI_NPIXELS(mi) <= 2) XSetForeground(display, pp->backGC, MI_WHITE_PIXEL(mi)); else XSetForeground(display, pp->backGC, MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)))); (void) XPutImage(display, window, pp->backGC, pp->logo, (int) (NRAND(MAX(1, (pp->logo->width - pp->usablewindow.x)))), (int) (NRAND(MAX(1, (pp->logo->height - pp->usablewindow.y)))), pp->randompos.x, pp->randompos.y, pp->usablewindow.x, pp->usablewindow.y); XSetForeground(display, pp->backGC, pp->black); for (x = 0; x <= pp->count.x; x++) { int tempx = x * pp->boxsize.x; XDrawLine(display, window, pp->backGC, tempx + pp->randompos.x, pp->randompos.y, tempx + pp->randompos.x, pp->usablewindow.y + pp->randompos.y); XDrawLine(display, window, pp->backGC, tempx + pp->randompos.x - 1, pp->randompos.y, tempx + pp->randompos.x - 1, pp->usablewindow.y + pp->randompos.y); } for (y = 0; y <= pp->count.y; y++) { int tempy = y * pp->boxsize.y; XDrawLine(display, window, pp->backGC, pp->randompos.x, tempy + pp->randompos.y, pp->usablewindow.x + pp->randompos.x, tempy + pp->randompos.y); XDrawLine(display, window, pp->backGC, pp->randompos.x, tempy + pp->randompos.y - 1, pp->usablewindow.x + pp->randompos.x, tempy + pp->randompos.y - 1); } } #ifdef NUMBERED else { if (pp->image) (void) XDestroyImage(pp->image); pp->randompos.x = pp->offsetwindow.x; pp->randompos.y = pp->offsetwindow.y; if (!NumberScreen(mi)) { release_puzzles(mi); return; } if ((pp->image = XGetImage(display, window, pp->offsetwindow.x, pp->offsetwindow.y, pp->usablewindow.x, pp->usablewindow.y, AllPlanes, (MI_NPIXELS(mi) <= 2) ? XYPixmap : ZPixmap)) == None) { free_puzzle(display, pp); return; } } pp->row = pp->count.y - 1; pp->col = pp->count.x - 1; #else pp->row = NRAND(pp->count.y); pp->col = NRAND(pp->count.x); #endif if ((pp->excount) && (pp->fixbuff == NULL)) if ((pp->fixbuff = (int *) calloc(pp->excount, sizeof (int))) == NULL) { free_puzzle(display, pp); return; } pp->painted = True; }
ENTRYPOINT void draw_braid(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int num_points = 500; float t_inc; float theta, psi; float t, r_diff; int i, s; float x_1, y_1, x_2, y_2, r1, r2; float color, color_use = 0.0, color_inc; braidtype *braid; if (braids == NULL) return; braid = &braids[MI_SCREEN(mi)]; #ifdef STANDALONE if (braid->eraser) { braid->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), braid->eraser); return; } #endif MI_IS_DRAWN(mi) = True; XSetLineAttributes(display, MI_GC(mi), braid->linewidth, LineSolid, (braid->linewidth <= 3 ? CapButt : CapRound), JoinMiter); theta = (2.0 * M_PI) / (float) (braid->braidlength); t_inc = (2.0 * M_PI) / (float) num_points; color_inc = (float) MI_NPIXELS(mi) * braid->color_direction / (float) num_points; braid->startcolor += SPINRATE * color_inc; if (((int) braid->startcolor) >= MI_NPIXELS(mi)) braid->startcolor = 0.0; r_diff = (braid->max_radius - braid->min_radius) / (float) (braid->nstrands); color = braid->startcolor; psi = 0.0; for (i = 0; i < braid->braidlength; i++) { psi += theta; for (t = 0.0; t < theta; t += t_inc) { #ifdef COLORROUND color += color_inc; if (((int) color) >= MI_NPIXELS(mi)) color = 0.0; color_use = color; #endif for (s = 0; s < braid->nstrands; s++) { if (ABS(braid->braidword[i]) == s) continue; if (ABS(braid->braidword[i]) - 1 == s) { /* crosSINFg */ #ifdef COLORCOMP if (MI_NPIXELS(mi) > 2) { color_use = color + SPINRATE * braid->components[applywordbackto(braid, s, i)] + (psi + t) / 2.0 / M_PI * (float) MI_NPIXELS(mi); while (((int) color_use) >= MI_NPIXELS(mi)) color_use -= (float) MI_NPIXELS(mi); while (((int) color_use) < 0) color_use += (float) MI_NPIXELS(mi); } #endif #ifdef COLORROUND if (MI_NPIXELS(mi) > 2) { color_use += SPINRATE * color_inc; while (((int) color_use) >= MI_NPIXELS(mi)) color_use -= (float) MI_NPIXELS(mi); } #endif r1 = braid->min_radius + r_diff * (float) (s); r2 = braid->min_radius + r_diff * (float) (s + 1); if (braid->braidword[i] > 0 || (FABSF(t - theta / 2.0) > theta / 7.0)) { x_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r2 + 0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r1)) * COSF(t + psi) + braid->center_x; y_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r2 + 0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r1)) * SINF(t + psi) + braid->center_y; x_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r2 + 0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r1)) * COSF(t + t_inc + psi) + braid->center_x; y_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r2 + 0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r1)) * SINF(t + t_inc + psi) + braid->center_y; if (MI_NPIXELS(mi) > 2) XSetForeground(display, MI_GC(mi), MI_PIXEL(mi, (int) color_use)); else XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi)); XDrawLine(display, window, MI_GC(mi), (int) (x_1), (int) (y_1), (int) (x_2), (int) (y_2)); } #ifdef COLORCOMP if (MI_NPIXELS(mi) > 2) { color_use = color + SPINRATE * braid->components[applywordbackto(braid, s + 1, i)] + (psi + t) / 2.0 / M_PI * (float) MI_NPIXELS(mi); while (((int) color_use) >= MI_NPIXELS(mi)) color_use -= (float) MI_NPIXELS(mi); while (((int) color_use) < 0) color_use += (float) MI_NPIXELS(mi); } #endif if (braid->braidword[i] < 0 || (FABSF(t - theta / 2.0) > theta / 7.0)) { x_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r1 + 0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r2)) * COSF(t + psi) + braid->center_x; y_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r1 + 0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r2)) * SINF(t + psi) + braid->center_y; x_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r1 + 0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r2)) * COSF(t + t_inc + psi) + braid->center_x; y_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r1 + 0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r2)) * SINF(t + t_inc + psi) + braid->center_y; if (MI_NPIXELS(mi) > 2) XSetForeground(display, MI_GC(mi), MI_PIXEL(mi, (int) color_use)); else XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi)); XDrawLine(display, window, MI_GC(mi), (int) (x_1), (int) (y_1), (int) (x_2), (int) (y_2)); } } else { /* no crosSINFg */ #ifdef COLORCOMP if (MI_NPIXELS(mi) > 2) { color_use = color + SPINRATE * braid->components[applywordbackto(braid, s, i)] + (psi + t) / 2.0 / M_PI * (float) MI_NPIXELS(mi); while (((int) color_use) >= MI_NPIXELS(mi)) color_use -= (float) MI_NPIXELS(mi); while (((int) color_use) < 0) color_use += (float) MI_NPIXELS(mi); } #endif #ifdef COLORROUND if (MI_NPIXELS(mi) > 2) { color_use += SPINRATE * color_inc; while (((int) color_use) >= MI_NPIXELS(mi)) color_use -= (float) MI_NPIXELS(mi); } #endif r1 = braid->min_radius + r_diff * (float) (s); x_1 = r1 * COSF(t + psi) + braid->center_x; y_1 = r1 * SINF(t + psi) + braid->center_y; x_2 = r1 * COSF(t + t_inc + psi) + braid->center_x; y_2 = r1 * SINF(t + t_inc + psi) + braid->center_y; if (MI_NPIXELS(mi) > 2) XSetForeground(display, MI_GC(mi), MI_PIXEL(mi, (int) color_use)); else XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi)); XDrawLine(display, window, MI_GC(mi), (int) (x_1), (int) (y_1), (int) (x_2), (int) (y_2)); } } } } XSetLineAttributes(display, MI_GC(mi), 1, LineSolid, CapNotLast, JoinRound); if (++braid->age > MI_CYCLES(mi)) { #ifdef STANDALONE braid->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), braid->eraser); #endif init_braid(mi); } }
ENTRYPOINT void draw_strange(ModeInfo * mi) { int i, j, n, Cur_Pt; PRM x, y, xo, yo; DBL u; XPoint *Buf; Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); DBL Lx, Ly; void (*Iterate) (ATTRACTOR *, PRM, PRM, PRM *, PRM *); PRM xmin, xmax, ymin, ymax; ATTRACTOR *A; if (Root == NULL) return; A = &Root[MI_SCREEN(mi)]; if (A->Fold == NULL) return; Cur_Pt = A->Cur_Pt; Iterate = A->Iterate; u = (DBL) (A->Count) / 1000.0; for (j = MAX_PRM - 1; j >= 0; --j) A->Prm[j] = DBL_To_PRM((1.0 - u) * A->Prm1[j] + u * A->Prm2[j]); x = y = DBL_To_PRM(.0); for (n = SKIP_FIRST; n; --n) { (*Iterate) (A, x, y, &xo, &yo); x = xo + NRAND(8) - 4; y = yo + NRAND(8) - 4; } xmax = 0; xmin = UNIT * 4; ymax = 0; ymin = UNIT * 4; A->Cur_Pt = 0; Buf = A->Buffer2; Lx = (DBL) A->Width / UNIT / 2.2; Ly = (DBL) A->Height / UNIT / 2.2; for (n = A->Max_Pt; n; --n) { (*Iterate) (A, x, y, &xo, &yo); Buf->x = (int) (Lx * (x + DBL_To_PRM(1.1))); Buf->y = (int) (Ly * (DBL_To_PRM(1.1) - y)); /* (void) fprintf( stderr, "X,Y: %d %d ", Buf->x, Buf->y ); */ Buf++; A->Cur_Pt++; if (xo > xmax) xmax = xo; else if (xo < xmin) xmin = xo; if (yo > ymax) ymax = yo; else if (yo < ymin) ymin = yo; x = xo + NRAND(8) - 4; y = yo + NRAND(8) - 4; } MI_IS_DRAWN(mi) = True; XSetForeground(display, gc, MI_BLACK_PIXEL(mi)); if (A->dbuf != None) { /* jwz */ XSetForeground(display, A->dbuf_gc, 0); /* XDrawPoints(display, A->dbuf, A->dbuf_gc, A->Buffer1, Cur_Pt,CoordModeOrigin); */ XFillRectangle(display, A->dbuf, A->dbuf_gc, 0, 0, A->Width, A->Height); } else XDrawPoints(display, window, gc, A->Buffer1, Cur_Pt, CoordModeOrigin); if (MI_NPIXELS(mi) < 2) XSetForeground(display, gc, MI_WHITE_PIXEL(mi)); else XSetForeground(display, gc, MI_PIXEL(mi, A->Col % MI_NPIXELS(mi))); if (A->dbuf != None) { XSetForeground(display, A->dbuf_gc, 1); XDrawPoints(display, A->dbuf, A->dbuf_gc, A->Buffer2, A->Cur_Pt, CoordModeOrigin); XCopyPlane(display, A->dbuf, window, gc, 0, 0, A->Width, A->Height, 0, 0, 1); } else XDrawPoints(display, window, gc, A->Buffer2, A->Cur_Pt, CoordModeOrigin); Buf = A->Buffer1; A->Buffer1 = A->Buffer2; A->Buffer2 = Buf; if ((xmax - xmin < DBL_To_PRM(.2)) && (ymax - ymin < DBL_To_PRM(.2))) A->Count += 4 * A->Speed; else A->Count += A->Speed; if (A->Count >= 1000) { for (i = MAX_PRM - 1; i >= 0; --i) A->Prm1[i] = A->Prm2[i]; Random_Prm(A->Prm2); A->Count = 0; } A->Col++; }