static void paint_fly(ModeInfo * mi, Fly * f) { EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)]; Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int x = f->x, y = f->y; if (MI_IS_ICONIC(mi)) { /* don't need to unpaint when iconic * ep->flyGC has stipple set, don't use when iconic */ XSetForeground(display, MI_GC(mi), f->pixel); XFillArc(display, window, MI_GC(mi), x, y, f->width, f->height, 90 * 64, 360 * 64); } else { unpaint_fly(mi, f); XSetForeground(display, ep->flyGC, f->pixel); #ifdef XBM_GRELB if (ep->fly2pix != None) { XSetStipple(display, ep->flyGC, (f->vy <= 0) ? ep->flypix : ep->fly2pix); } else #endif XSetStipple(display, ep->flyGC, ep->flypix); XSetTSOrigin(display, ep->flyGC, x, y); #ifdef FLASH XSetFillStyle(display, ep->flyGC, FillStippled); #else XSetFillStyle(display, ep->flyGC, FillOpaqueStippled); #endif XFillRectangle(display, window, ep->flyGC, x, y, f->width, f->height); XFlush(display); } }
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); }
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); }
static void petal(ModeInfo * mi) { petalstruct *pp = &petals[MI_SCREEN(mi)]; XSetForeground(MI_DISPLAY(mi), MI_GC(mi), pp->color); if (pp->wireframe) { XDrawLines(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi), pp->points, pp->npoints + 1, CoordModeOrigin); } else { XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi), pp->points, pp->npoints, Complex, CoordModeOrigin); } }
static void drawtruchet(ModeInfo * mi, int col, int row, unsigned char color, unsigned char truchetstate) { antfarmstruct *ap = &antfarms[MI_SCREEN(mi)]; if (!color) XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi)); else if (MI_NPIXELS(mi) > 2 || color > ap->ncolors / 2) XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi)); else XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi)); truchetcell(mi, col, row, truchetstate); }
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 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 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); }
static void draw_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)]; double D; /* A distance variable to work with */ register unsigned char cmpt; D = POS(X) * POS(X) + POS(Y) * POS(Y) + POS(Z) * POS(Z); if (D < COLLIDE) D = COLLIDE; D = sqrt(D); D = D * D * D; for (cmpt = X; cmpt < DIMENSIONS; cmpt++) { ACC(cmpt) = POS(cmpt) * GRAV / D; if (decay) { if (ACC(cmpt) > MaxA) ACC(cmpt) = MaxA; else if (ACC(cmpt) < -MaxA) ACC(cmpt) = -MaxA; VEL(cmpt) = VEL(cmpt) + ACC(cmpt); VEL(cmpt) *= DAMP; } else { /* update velocity */ VEL(cmpt) = VEL(cmpt) + ACC(cmpt); } /* update position */ POS(cmpt) = POS(cmpt) + VEL(cmpt); } gp->x = planet->xi; gp->y = planet->yi; 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; /* Mask */ XSetForeground(display, gc, MI_BLACK_PIXEL(mi)); Planet(gp->x, gp->y); if (trail) { XSetForeground(display, gc, planet->colors); XDrawPoint(display, MI_WINDOW(mi), gc, gp->x, gp->y); } /* Move */ gp->x = planet->xi; gp->y = planet->yi; planet->ri = RADIUS; /* Redraw */ XSetForeground(display, gc, planet->colors); Planet(gp->x, gp->y); }
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; } }
static void DrawLine(ModeInfo * mi, XRectangle rect, unsigned long color) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); XSetForeground(display, gc, color); XDrawLine(display, window, gc, rect.x, rect.height, rect.width, rect.y); }
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; if (!MI_IS_DRAWN(mi)) { for (ball = 0; ball < (unsigned char) gp->nplanets; ball++) { planetstruct *planet = &gp->planets[ball]; /* Draw planets */ Planet(planet->xi, planet->yi); } /* 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); } 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]); }
static void draw_mesh(ModeInfo * mi, trianglestruct * tp, int d, int count) { XPoint p[3]; int first = 1; int y_0, y_1, y_2; double dinv = 0.2 / d; if ((tp->j == 0) && (tp->i == 0)) { #if 0 /* jwz */ XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi)); #else { int x = 0; int y = 0; int x2 = MI_WIN_WIDTH(mi); int y2 = tp->ypos[0]; XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_BLACK_PIXEL(mi)); XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi), x, y, x2, y2); } #endif } for (; (tp->j < tp->size) && (count > 0); tp->j += ((count) ? d : 0)) { for (tp->i = (first) ? tp->i : 0, first = 0; (tp->i < MAX_SIZE - tp->j) && (count > 0); tp->i += d, count--) { if (tp->i + tp->j < tp->size) { calc_points1(tp, d, &y_0, &y_1, &y_2, p); draw_atriangle(mi, p, y_0, y_1, y_2, dinv); } if (tp->i + tp->j + d < tp->size) { calc_points2(tp, d, &y_0, &y_1, &y_2, p); draw_atriangle(mi, p, y_0, y_1, y_2, dinv); } } } if (tp->j == tp->size) { tp->init_now = 1; } }
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); } }
static void DrawEllipse(ModeInfo * mi, dropstruct *drop, unsigned long color) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); int w = 2 * drop->radius; int h = (drop->radius * 2) / 3; XSetForeground(display, gc, color); XDrawArc(display, window, gc, drop->drop.x - w, drop->drop.y - h, 2 * w + 1, 2 * h + 1, 0, 360 * 64); }
void init_galaxy(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); unistruct *gp; if (universes == NULL) { if ((universes = (unistruct *) calloc(MI_NUM_SCREENS(mi), sizeof (unistruct))) == NULL) return; } gp = &universes[MI_SCREEN(mi)]; gp->f_hititerations = MI_CYCLES(mi); gp->clip.left = 0; gp->clip.top = 0; gp->clip.right = MI_WIDTH(mi); gp->clip.bottom = MI_HEIGHT(mi); gp->scale = (double) (gp->clip.right + gp->clip.bottom) / 8.0; gp->midx = gp->clip.right / 2; gp->midy = gp->clip.bottom / 2; if (MI_IS_FULLRANDOM(mi)) { gp->fisheye = !(NRAND(3)); if (!gp->fisheye) gp->tracks = (Bool) (LRAND() & 1); } else { gp->fisheye = fisheye; gp->tracks = tracks; } if (!startover(mi)) return; if (gp->fisheye) { if (gp->pixmap != None) XFreePixmap(display, gp->pixmap); if ((gp->pixmap = XCreatePixmap(display, MI_WINDOW(mi), MI_WIDTH(mi), MI_HEIGHT(mi), MI_DEPTH(mi))) == None) { gp->fisheye = False; } } if (gp->fisheye) { XSetGraphicsExposures(display, MI_GC(mi), False); gp->scale *= Z_OFFSET; gp->star_scale_Z = (gp->scale * .005); /* don't want any exposure events from XCopyPlane */ } }
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 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); }
static void generate_cesarovar(ModeInfo * mi, double pt1x, double pt1y, double pt2x, double pt2y, int level, int sign) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); turtlestruct *tp = &turtles[MI_SCREEN(mi)]; complextype points[4]; level--; tp->turtle.r = sqrt((double) ((pt2x - pt1x) * (pt2x - pt1x) + (pt2y - pt1y) * (pt2y - pt1y))) / 2.0; points[0].x = pt1x; points[0].y = pt1y; points[2].x = pt2x; points[2].y = pt2y; tp->turtle.theta = POINT(pt1x, pt1y, pt2x, pt2y); tp->turtle.x = pt1x; tp->turtle.y = pt1y; STEP(tp->turtle.x, tp->turtle.y, tp->turtle.r, tp->turtle.theta); points[3].x = tp->turtle.x; points[3].y = tp->turtle.y; TURN(tp->turtle.theta, 90.0 * (double) sign); STEP(tp->turtle.x, tp->turtle.y, tp->turtle.r, tp->turtle.theta); points[1].x = tp->turtle.x; points[1].y = tp->turtle.y; sign = -1; if (level > 0) { int j; for (j = 0; j < 2; j++) { pt1x = points[j].x; pt2x = points[j + 1].x; pt1y = points[j].y; pt2y = points[j + 1].y; generate_cesarovar(mi, pt1x, pt1y, pt2x, pt2y, level, sign); } } else { XDrawLine(display, window, gc, (int) points[0].x + tp->start.x, (int) points[0].y + tp->start.y, (int) points[2].x + tp->start.x, (int) points[2].y + tp->start.y); XDrawLine(display, window, gc, (int) points[1].x + tp->start.x, (int) points[1].y + tp->start.y, (int) points[3].x + tp->start.x, (int) points[3].y + tp->start.y); } }
static Bool draw_state(ModeInfo * mi, int state) { dragonstruct *dp = &dragons[MI_SCREEN(mi)]; Display *display = MI_DISPLAY(mi); GC gc; CellList *current; 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; } { /* 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; if (dp->vertical) { dp->hexagon[0].x = dp->xb + ccol * dp->xs; dp->hexagon[0].y = dp->yb + crow * dp->ys; } else { dp->hexagon[0].y = dp->xb + ccol * dp->xs; dp->hexagon[0].x = 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); current = current->next; } } XFlush(MI_DISPLAY(mi)); return True; }
void init_blot(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); blotstruct *bp; if (blots == NULL) { if ((blots = (blotstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (blotstruct))) == NULL) return; } bp = &blots[MI_SCREEN(mi)]; bp->width = MI_WIDTH(mi); bp->height = MI_HEIGHT(mi); bp->xmid = bp->width / 2; bp->ymid = bp->height / 2; bp->offset = 4; bp->ysym = (int) LRAND() & 1; bp->xsym = (bp->ysym) ? (int) LRAND() & 1 : 1; if (MI_NPIXELS(mi) > 2) bp->pix = NRAND(MI_NPIXELS(mi)); if (bp->offset <= 0) bp->offset = 3; if (MI_COUNT(mi) < 0) bp->size = NRAND(-MI_COUNT(mi) + 1); else bp->size = MI_COUNT(mi); /* Fudge the size so it takes up the whole screen */ bp->size *= (bp->width / 32 + 1) * (bp->height / 32 + 1); if (!bp->pointBuffer || bp->pointBufferSize < bp->size * sizeof (XPoint)) { if (bp->pointBuffer != NULL) free(bp->pointBuffer); bp->pointBufferSize = bp->size * sizeof (XPoint); if ((bp->pointBuffer = (XPoint *) malloc(bp->pointBufferSize)) == NULL) { return; } } MI_CLEARWINDOW(mi); XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi)); bp->count = 0; }
static void generate_hilbert(ModeInfo * mi, int r1, int r2) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); GC gc = MI_GC(mi); turtlestruct *tp = &turtles[MI_SCREEN(mi)]; tp->level--; if (tp->level > 0) generate_hilbert(mi, r2, r1); tp->pt2.x += r1; tp->pt2.y += r2; XDrawLine(display, window, gc, tp->pt1.x, tp->pt1.y, tp->pt2.x, tp->pt2.y); tp->pt1.x = tp->pt2.x; tp->pt1.y = tp->pt2.y; if (tp->level > 0) generate_hilbert(mi, r1, r2); tp->pt2.x += r2; tp->pt2.y += r1; XDrawLine(display, window, gc, tp->pt1.x, tp->pt1.y, tp->pt2.x, tp->pt2.y); tp->pt1.x = tp->pt2.x; tp->pt1.y = tp->pt2.y; if (tp->level > 0) generate_hilbert(mi, r1, r2); tp->pt2.x -= r1; tp->pt2.y -= r2; XDrawLine(display, window, gc, tp->pt1.x, tp->pt1.y, tp->pt2.x, tp->pt2.y); tp->pt1.x = tp->pt2.x; tp->pt1.y = tp->pt2.y; if (tp->level > 0) generate_hilbert(mi, -r2, -r1); tp->level++; }
void draw_image(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int i; GC gc; imagestruct *ip; if (ims == NULL) return; ip = &ims[MI_SCREEN(mi)]; if (ip->icons == NULL) return; if (icononly && !MI_IS_ICONIC(mi)) return; gc = (message && *message) ? MI_GC(mi) : ip->bgGC; MI_IS_DRAWN(mi) = True; XSetForeground(display, gc, ip->black); if (ip->border.x < 0) ip->image_offset.x = -NRAND(-ip->border.x); else if (ip->border.x > 0) ip->image_offset.x = NRAND(ip->border.x); else ip->image_offset.x = 0; if (ip->border.y < 0) ip->image_offset.y = -NRAND(-ip->border.y); else if (ip->border.y > 0) ip->image_offset.y = NRAND(ip->border.y); else ip->image_offset.y = 0; for (i = 0; i < ip->iconcount; i++) { ip->icons[i].x = NRAND(ip->ncols); ip->icons[i].y = NRAND(ip->nrows); ip->icons[i].color = NRAND(MI_NPIXELS(mi)); if (ip->ncols * ip->nrows > ip->iconcount && ip->icons[i].x >= 0) XFillRectangle(display, window, gc, ip->pixw * ip->icons[i].x + ip->image_offset.x, ip->pixh * ip->icons[i].y + ip->image_offset.y, ip->pixw, ip->pixh); } drawImages(mi); }
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 draw_dots(ModeInfo * mi, int in) { float i, inc; float x, y; spiralstruct *sp = &spirals[MI_SCREEN(mi)]; inc = TWOPI / (float) sp->dots; for (i = 0.0; i < TWOPI; i += inc) { x = sp->traildots[in].hx + COSF(i + sp->traildots[in].ha) * sp->traildots[in].hr; y = sp->traildots[in].hy + SINF(i + sp->traildots[in].ha) * sp->traildots[in].hr; XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi), TFX(sp, x), TFY(sp, y)); } }
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); }
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]); }
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); }