ENTRYPOINT void
init_moebius (ModeInfo * mi)
{
moebiusstruct *mp;
if (moebius == NULL) {
if ((moebius = (moebiusstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (moebiusstruct))) == NULL)
return;
}
mp = &moebius[MI_SCREEN(mi)];
mp->step = NRAND(90);
mp->ant_position = NRAND(90);
{
double rot_speed = 0.3;
mp->rot = make_rotator (rot_speed, rot_speed, rot_speed, 1, 0, True);
mp->trackball = gltrackball_init ();
}
if ((mp->glx_context = init_GL(mi)) != NULL) {
reshape_moebius(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
}
static void
MakeTeapot(ModeInfo * mi, int newdir)
{
pipesstruct *pp = &pipes[MI_SCREEN(mi)];
switch (newdir) {
case dirUP:
case dirDOWN:
glRotatef(90.0, 1.0, 0.0, 0.0);
glRotatef(NRAND(3) * 90.0, 0.0, 0.0, 1.0);
break;
case dirLEFT:
case dirRIGHT:
glRotatef(90.0, 0.0, -1.0, 0.0);
glRotatef((NRAND(3) * 90.0) - 90.0, 0.0, 0.0, 1.0);
break;
case dirNEAR:
case dirFAR:
glRotatef(NRAND(4) * 90.0, 0.0, 0.0, 1.0);
break;
}
glCallList(pp->teapot);
mi->polygon_count += pp->teapot_polys;
glFrontFace(GL_CCW);
}
static int
look(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
/*GC gc = MI_GC(mi); */
nosestruct *np = &noses[MI_SCREEN(mi)];
int i;
if (NRAND(3)) {
i = (LRAND() & 1) ? D : F;
XCopyArea(display, np->position[i], window, np->noseGC[i],
0, 0, PIXMAP_SIZE, PIXMAP_SIZE, np->x, np->y);
return 3;
}
if (!NRAND(5))
return 0;
if (NRAND(3)) {
i = (LRAND() & 1) ? LF : RF;
XCopyArea(display, np->position[i], window, np->noseGC[i],
0, 0, PIXMAP_SIZE, PIXMAP_SIZE, np->x, np->y);
return 3;
}
if (!NRAND(5))
return 0;
i = (LRAND() & 1) ? L : R;
XCopyArea(display, np->position[i], window, np->noseGC[i],
0, 0, PIXMAP_SIZE, PIXMAP_SIZE, np->x, np->y);
return 3;
}
ENTRYPOINT void change_fire(ModeInfo * mi)
{
firestruct *fs = &fire[MI_SCREEN(mi)];
if (!fs->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(fs->glx_context));
/* if available, randomly change some values */
if (do_fog)
fs->fog = LRAND() & 1;
if (do_shadows)
fs->shadows = LRAND() & 1;
/* reset observer position */
frame = 0;
vinit(fs->obs, DEF_OBS[0], DEF_OBS[1], DEF_OBS[2]);
fs->v = 0.0;
/* particle randomisation */
fs->eject_r = 0.1 + NRAND(10) * 0.03;
fs->ridtri = 0.1 + NRAND(10) * 0.005;
if (MI_IS_DEBUG(mi)) {
(void) fprintf(stderr,
"%s:\n\tnum_part=%d\n\ttrees=%d\n\tfog=%s\n\tshadows=%s\n\teject_r=%.3f\n\tridtri=%.3f\n",
MI_NAME(mi),
fs->np,
fs->num_trees,
fs->fog ? "on" : "off",
fs->shadows ? "on" : "off",
fs->eject_r, fs->ridtri);
}
}
void
init_morph3d(ModeInfo * mi)
{
morph3dstruct *mp;
if (morph3d == NULL) {
if ((morph3d = (morph3dstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (morph3dstruct))) == NULL)
return;
}
mp = &morph3d[MI_SCREEN(mi)];
mp->step = NRAND(90);
mp->VisibleSpikes = 1;
if ((mp->glx_context = init_GL(mi)) != NULL) {
reshape_morph3d(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
mp->object = MI_COUNT(mi);
if (mp->object <= 0 || mp->object > 5)
mp->object = NRAND(5) + 1;
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
}
static Bool Init(ModeInfo * mi)
{
int i;
firestruct *fs = &fire[MI_SCREEN(mi)];
/* default settings */
fs->eject_r = 0.1 + NRAND(10) * 0.03;
fs->dt = 0.015;
fs->eject_vy = 4;
fs->eject_vl = 1;
fs->ridtri = 0.1 + NRAND(10) * 0.005;
fs->maxage = 1.0 / fs->dt;
vinit(fs->obs, DEF_OBS[0], DEF_OBS[1], DEF_OBS[2]);
fs->v = 0.0;
fs->alpha = DEF_ALPHA;
fs->beta = DEF_BETA;
/* initialise texture stuff */
if (do_texture)
inittextures(mi);
else
{
fs->ttexture = (XImage*) NULL;
fs->gtexture = (XImage*) NULL;
}
if (MI_IS_DEBUG(mi)) {
(void) fprintf(stderr,
"%s:\n\tnum_part=%d\n\ttrees=%d\n\tfog=%s\n\tshadows=%s\n\teject_r=%.3f\n\tridtri=%.3f\n",
MI_NAME(mi),
fs->np,
fs->num_trees,
fs->fog ? "on" : "off",
fs->shadows ? "on" : "off",
fs->eject_r, fs->ridtri);
}
/* initialise particles and trees */
for (i = 0; i < fs->np; i++) {
setnewpart(fs, &(fs->p[i]));
}
if (fs->num_trees)
if (!inittree(mi)) {
return False;
}
/* if no fire particles then initialise rain particles */
if (!fs->np)
{
vinit(fs->min,-7.0f,-0.2f,-7.0f);
vinit(fs->max,7.0f,8.0f,7.0f);
for (i = 0; i < NUMPART; i++) {
setnewrain(fs, &(fs->r[i]));
}
}
return True;
}
static void
create_path(circuitstruct * wp, int n)
{
int col, row;
int count = 0;
int dir, prob;
int nextcol, nextrow, i;
#ifdef RANDOMSTART
/* Path usually "mushed" in a corner */
col = NRAND(wp->ncols) + 1;
row = NRAND(wp->nrows) + 1;
#else
/* Start from center */
col = wp->ncols / 2;
row = wp->nrows / 2;
#endif
wp->mincol = col - 1, wp->minrow = row - 2;
wp->maxcol = col + 1, wp->maxrow = row + 2;
dir = NRAND(wp->neighbors) * ANGLES / wp->neighbors;
*(wp->newcells + col + row * wp->bncols) = HEAD;
while (++count < n) {
prob = NRAND(wp->prob_array[wp->neighbors - 1]);
i = 0;
while (prob > wp->prob_array[i])
i++;
dir = ((dir * wp->neighbors / ANGLES + i) %
wp->neighbors) * ANGLES / wp->neighbors;
nextcol = col;
nextrow = row;
positionOfNeighbor(wp, dir, &nextcol, &nextrow);
if (withinBounds(wp, nextcol, nextrow)) {
col = nextcol;
row = nextrow;
if (col == wp->mincol && col > 2)
wp->mincol--;
if (row == wp->minrow && row > 2)
wp->minrow--;
else if (row == wp->minrow - 1 && row > 3)
wp->minrow -= 2;
if (col == wp->maxcol && col < wp->bncols - 3)
wp->maxcol++;
if (row == wp->maxrow && row < wp->bnrows - 3)
wp->maxrow++;
else if (row == wp->maxrow + 1 && row < wp->bnrows - 4)
wp->maxrow += 2;
if (!*(wp->newcells + col + row * wp->bncols))
*(wp->newcells + col + row * wp->bncols) = WIRE;
} else {
if (wp->neighbors == 3)
break; /* There is no reverse step */
dir = ((dir * wp->neighbors / ANGLES + wp->neighbors / 2) %
wp->neighbors) * ANGLES / wp->neighbors;
}
}
*(wp->newcells + col + row * wp->bncols) = HEAD;
}
static void
wiggle_line(XPoint * p, int number, int amount)
{
int i;
for (i = 0; i < number; i++) {
p[i].x += NRAND(amount) - amount / 2;
p[i].y += NRAND(amount) - amount / 2;
}
}
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);
}
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
RandomSoup(life1dstruct * lp, int n, int v)
{
int col;
v /= 2;
if (v < 1)
v = 1;
for (col = lp->ncols / 2 - v; col < lp->ncols / 2 + v; ++col)
if (NRAND(100) < n && col >= 0 && col < lp->ncols)
lp->newcells[col + lp->border] = (unsigned char) NRAND(lp->k - 1) + 1;
}
static void
RandomSoup(circuitstruct * wp)
{
int i, j;
for (j = 2; j < wp->bnrows - 2; j++)
for (i = 2; i < wp->bncols - 2; i++) {
*(wp->newcells + i + j * wp->bncols) =
(NRAND(100) > wp->n) ? SPACE : (NRAND(4)) ? WIRE : (NRAND(2)) ?
HEAD : TAIL;
}
}
ENTRYPOINT void
init_fadeplot (ModeInfo * mi)
{
fadeplotstruct *fp;
if (fadeplots == NULL) {
if ((fadeplots = (fadeplotstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (fadeplotstruct))) == NULL)
return;
}
fp = &fadeplots[MI_SCREEN(mi)];
fp->width = MI_WIDTH(mi);
fp->height = MI_HEIGHT(mi);
fp->min = MAX(MIN(fp->width, fp->height) / 2, 1);
fp->speed.x = 8;
fp->speed.y = 10;
fp->step.x = 1;
fp->step.y = 1;
fp->temps = 0;
fp->factor.x = MAX(fp->width / (2 * fp->min), 1);
fp->factor.y = MAX(fp->height / (2 * fp->min), 1);
fp->nbstep = MI_COUNT(mi);
if (fp->nbstep < -MINSTEPS) {
fp->nbstep = NRAND(-fp->nbstep - MINSTEPS + 1) + MINSTEPS;
} else if (fp->nbstep < MINSTEPS)
fp->nbstep = MINSTEPS;
fp->maxpts = MI_CYCLES(mi);
if (fp->maxpts < 1)
fp->maxpts = 1;
if (fp->pts == NULL) {
if ((fp->pts = (XPoint *) calloc(fp->maxpts, sizeof (XPoint))) ==
NULL) {
free_fadeplot(fp);
return;
}
}
if (MI_NPIXELS(mi) > 2)
fp->pix = NRAND(MI_NPIXELS(mi));
if (fp->stab != NULL)
(void) free((void *) fp->stab);
if (!initSintab(mi))
return;
MI_CLEARWINDOW(mi);
}
static void
init_colors(ModeInfo *mi)
{
if (strncasecmp(bubble_color_str, "auto", strlen("auto")) == 0) {
glb_config.bubble_colour[0] = ((float) (NRAND(100)) / 100.0);
glb_config.bubble_colour[1] = ((float) (NRAND(100)) / 100.0);
/* I keep more blue */
glb_config.bubble_colour[2] = ((float) (NRAND(50)) / 100.0) + 0.50;
} else if (strncasecmp(bubble_color_str, "random", strlen("random")) == 0) {
glb_config.bubble_colour[0] = -1.0;
} else {
parse_color(mi, "bubble", bubble_color_str, glb_config.bubble_colour);
}
}
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;
}
}
static void
move_blob(blob * b, int maxx, int maxy)
{
maxx *= SCALE;
maxy *= SCALE;
b->x += b->dx;
b->y += b->dy;
/* If we've reached the edge of the box, reverse direction. */
if ((b->x > maxx && b->dx >= 0) ||
(b->x < 0 && b->dx < 0)) {
b->dx = -b->dx;
}
if ((b->y > maxy && b->dy >= 0) ||
(b->y < 0 && b->dy < 0)) {
b->dy = -b->dy;
}
/* Alter velocity randomly. */
if (!(LRAND() % 10)) {
b->dx += (NRAND(b->max_velocity / 2) * RANDSIGN());
b->dy += (NRAND(b->max_velocity / 2) * RANDSIGN());
/* Throttle velocity */
if (b->dx > b->max_velocity || b->dx < -b->max_velocity)
b->dx /= 2;
if (b->dy > b->max_velocity || b->dy < -b->max_velocity)
b->dy /= 2;
} {
double th = b->th;
double d = (b->torque == 0 ? 0 : (b->torque) * LRAND() / MAXRAND);
if (th < 0)
th = -(th + d);
else
th += d;
if (th > (M_PI + M_PI))
th -= (M_PI + M_PI);
else if (th < 0)
th += (M_PI + M_PI);
b->th = (b->th > 0 ? th : -th);
}
/* Alter direction of rotation randomly. */
if (!(LRAND() % 100))
b->th *= -1;
}
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
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
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);
}
ENTRYPOINT void
init_stairs (ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
stairsstruct *sp;
if (stairs == NULL) {
if ((stairs = (stairsstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (stairsstruct))) == NULL)
return;
}
sp = &stairs[screen];
sp->step = 0.0;
sp->rotating = 0;
sp->sphere_position = NRAND(NPOSITIONS);
sp->sphere_tick = 0;
if ((sp->glx_context = init_GL(mi)) != NULL) {
reshape_stairs(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
if (!glIsList(sp->objects))
sp->objects = glGenLists(1);
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
sp->trackball = gltrackball_init (False);
}
static void
throb_blob(blob * b)
{
int i;
double frac = ((M_PI + M_PI) / b->npoints);
for (i = 0; i < b->npoints; i++) {
long r = b->r[i];
long ra = (r > 0 ? r : -r);
double th = (b->th > 0 ? b->th : -b->th);
long x, y;
/* place control points evenly around perimiter, shifted by theta */
x = b->x + (long) (ra * cos(i * frac + th));
y = b->y + (long) (ra * sin(i * frac + th));
b->splines->control_x[i] = x / SCALE;
b->splines->control_y[i] = y / SCALE;
/* alter the radius by a random amount, in the direction in which
it had been going (the sign of the radius indicates direction.) */
ra += (NRAND(b->elasticity) * (r > 0 ? 1 : -1));
r = ra * (r >= 0 ? 1 : -1);
/* If we've reached the end (too long or too short) reverse direction. */
if ((ra > b->max_r && r >= 0) ||
(ra < b->min_r && r < 0))
r = -r;
/* And reverse direction in mid-course once every 50 times. */
else if (!(LRAND() % 50))
r = -r;
b->r[i] = r;
}
}
void
draw_tik_tak(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
int i;
tik_takstruct *tiktak;
if (tik_taks == NULL)
return;
tiktak = &tik_taks[MI_SCREEN(mi)];
if (tiktak->object == NULL)
return;
if (tiktak->no_colors) {
free_tik_tak(display, tiktak);
init_tik_tak(mi);
return;
}
tiktak->painted = True;
MI_IS_DRAWN(mi) = True;
XSetFunction(display, tiktak->gc, GXxor);
/* Rotate colours */
if (tiktak->cycle_p) {
rotate_colors(display, tiktak->cmap, tiktak->colors, tiktak->ncolors,
tiktak->direction);
if (!(LRAND() % 1000))
tiktak->direction = -tiktak->direction;
}
for (i = 0; i < tiktak->num_object; i++) {
tik_takobject *object0;
object0 = &tiktak->object[i];
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XSetForeground(display, tiktak->gc, tiktak->colors[object0->colour].pixel);
} else {
XSetForeground(display, tiktak->gc, object0->colour);
}
object0->velocity_a += ((float) NRAND(1001) - 500.0) / 200000.0;
object0->angle += object0->velocity_a;
object0->velocity_a1 += ((float) NRAND(1001) - 500.0) / 200000.0;
object0->angle1 += object0->velocity_a1;
tik_tak_setupobject( mi , object0);
tik_tak_drawobject(mi, object0 );
}
XSetFunction(display, tiktak->gc, GXcopy);
}
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
generate(XPoint A, XPoint B, int iter, XPoint * verts, int *vert_index)
{
XPoint mid;
mid.x = (A.x + B.x) / 2 + NRAND(WIDTH_VARIATION) - WIDTH_VARIATION / 2;
mid.y = (A.y + B.y) / 2 + NRAND(HEIGHT_VARIATION) - HEIGHT_VARIATION / 2;
if (!iter) {
verts[*vert_index].x = mid.x;
verts[*vert_index].y = mid.y;
(*vert_index)++;
return;
}
generate(A, mid, iter - 1, verts, vert_index);
generate(mid, B, iter - 1, verts, vert_index);
}
/*=================== Tunnel Initialization ================================*/
struct tunnel_state *
atunnel_InitTunnel(void)
{
struct tunnel_state *st = (struct tunnel_state *) calloc (1, sizeof(*st));
LoadPath(st);
st->current_texture = NRAND(MAX_TEXTURE);
return st;
}
static void
initlissie(ModeInfo * mi, lissiestruct * lissie)
{
lissstruct *lp = &lisses[MI_SCREEN(mi)];
int size = MI_SIZE(mi);
int i;
if (MI_NPIXELS(mi) > 2)
lissie->color = NRAND(MI_NPIXELS(mi));
else
lissie->color = MI_WHITE_PIXEL(mi);
/* Initialize parameters */
if (size < -MINSIZE)
lissie->ri = NRAND(MIN(-size, MAX(MINSIZE,
MIN(lp->width, lp->height) / 4)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
lissie->ri = MAX(MINSIZE, MIN(lp->width, lp->height) / 4);
else
lissie->ri = MINSIZE;
} else
lissie->ri = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) / 4));
lissie->xi = INTRAND(lp->width / 4 + lissie->ri,
lp->width * 3 / 4 - lissie->ri);
lissie->yi = INTRAND(lp->height / 4 + lissie->ri,
lp->height * 3 / 4 - lissie->ri);
lissie->rx = INTRAND(lp->width / 4,
MIN(lp->width - lissie->xi, lissie->xi)) - 2 * lissie->ri;
lissie->ry = INTRAND(lp->height / 4,
MIN(lp->height - lissie->yi, lissie->yi)) - 2 * lissie->ri;
lissie->len = INTRAND(MINLISSIELEN, MAXLISSIELEN - 1);
lissie->pos = 0;
lissie->redrawing = 0;
lissie->tx = FLOATRAND(0, 2 * M_PI);
lissie->ty = FLOATRAND(0, 2 * M_PI);
lissie->dtx = FLOATRAND(MINDT, MAXDT);
lissie->dty = FLOATRAND(MINDT, MAXDT);
for (i = 0; i < MAXLISSIELEN; i++)
lissie->loc[i].x = lissie->loc[i].y = 0;
/* Draw lissie */
drawlissie(mi, lissie);
}
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 int
flashing_strike(void)
{
int tmp = NRAND(FLASH_PROBILITY);
if (tmp <= FLASH_PROBILITY)
return (1);
return (0);
}
ENTRYPOINT void
draw_lightning (ModeInfo * mi)
{
int i;
Storm *st;
if (Helga == NULL)
return;
st = &Helga[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
switch (st->stage) {
case 0:
MI_IS_DRAWN(mi) = False;
MI_CLEARWINDOW(mi);
MI_IS_DRAWN(mi) = True;
st->color = NRAND(MI_NPIXELS(mi));
st->draw_time = 0;
if (storm_active(st))
st->stage++;
else
st->stage = 4;
break;
case 1:
for (i = 0; i < st->multi_strike; i++) {
if (st->bolts[i].visible)
draw_bolt(&(st->bolts[i]), mi);
update_bolt(&(st->bolts[i]), st->draw_time);
}
st->draw_time++;
st->stage++;
st->busyLoop = 0;
break;
case 2:
if (++st->busyLoop > 6) {
st->stage++;
st->busyLoop = 0;
}
break;
case 3:
MI_IS_DRAWN(mi) = False;
MI_CLEARWINDOW(mi);
MI_IS_DRAWN(mi) = True;
if (storm_active(st))
st->stage = 1;
else
st->stage++;
break;
case 4:
if (++st->busyLoop > 100) {
st->busyLoop = 0;
}
init_lightning(mi);
break;
}
}
static void
MakeValve(ModeInfo * mi, int newdir)
{
pipesstruct *pp = &pipes[MI_SCREEN(mi)];
/* There is a glPopMatrix() right after this subroutine returns. */
switch (newdir) {
case dirUP:
case dirDOWN:
glRotatef(90.0, 1.0, 0.0, 0.0);
glRotatef(NRAND(3) * 90.0, 0.0, 0.0, 1.0);
break;
case dirLEFT:
case dirRIGHT:
glRotatef(90.0, 0.0, -1.0, 0.0);
glRotatef((NRAND(3) * 90.0) - 90.0, 0.0, 0.0, 1.0);
break;
case dirNEAR:
case dirFAR:
glRotatef(NRAND(4) * 90.0, 0.0, 0.0, 1.0);
break;
}
glFrontFace(GL_CW);
glCallList(pp->betweenbolts);
mi->polygon_count += LWO_PipeBetweenBolts.num_pnts/3;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialGray);
glCallList(pp->bolts);
mi->polygon_count += LWO_Bolts3D.num_pnts/3;
if (!MI_IS_MONO(mi)) {
if (pp->system_color == MaterialRed) {
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, NRAND(2) ? MaterialYellow : MaterialBlue);
} else if (pp->system_color == MaterialBlue) {
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, NRAND(2) ? MaterialRed : MaterialYellow);
} else if (pp->system_color == MaterialYellow) {
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, NRAND(2) ? MaterialBlue : MaterialRed);
} else {
switch ((NRAND(3))) {
case 0:
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialRed);
break;
case 1:
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialBlue);
break;
case 2:
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialYellow);
}
}
}
glRotatef((GLfloat) (NRAND(90)), 1.0, 0.0, 0.0);
glCallList(pp->valve);
mi->polygon_count += LWO_BigValve.num_pnts/3;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pp->system_color);
glFrontFace(GL_CCW);
}
