ENTRYPOINT void
init_thornbird (ModeInfo * mi)
{
thornbirdstruct *hp;
if (thornbirds == NULL) {
if ((thornbirds =
(thornbirdstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (thornbirdstruct))) == NULL)
return;
}
hp = þbirds[MI_SCREEN(mi)];
hp->maxx = MI_WIDTH(mi);
hp->maxy = MI_HEIGHT(mi);
hp->b = 0.1;
hp->i = hp->j = 0.1;
hp->pix = 0;
hp->inc = 0;
hp->nbuffers = MI_CYCLES(mi);
if (hp->pointBuffer == NULL)
if ((hp->pointBuffer = (XPoint **) calloc(MI_CYCLES(mi),
sizeof (XPoint *))) == NULL) {
free_thornbird(hp);
return;
}
if (hp->pointBuffer[0] == NULL)
if ((hp->pointBuffer[0] = (XPoint *) malloc(MI_COUNT(mi) *
sizeof (XPoint))) == NULL) {
free_thornbird(hp);
return;
}
/* select frequencies for parameter variation */
hp->liss.f1 = LRAND() % 5000;
hp->liss.f2 = LRAND() % 2000;
/* choose random 3D tumbling */
hp->tumble.theta = 0;
hp->tumble.phi = 0;
hp->tumble.dtheta = balance_rand(0.001);
hp->tumble.dphi = balance_rand(0.005);
/* Clear the background. */
MI_CLEARWINDOW(mi);
hp->count = 0;
}
void
initswarm(Window win, KRandomSequence &rnd)
{
swarmstruct *sp = &swarms[screen];
int b;
XWindowAttributes xwa;
sp->beecount = batchcount;
(void) XGetWindowAttributes(dsp, win, &xwa);
sp->width = xwa.width;
sp->height = xwa.height;
sp->border = (sp->width + sp->height) / 50;
/* Clear the background. */
XSetForeground(dsp, Scr[screen].gc, BlackPixel(dsp, screen));
XFillRectangle(dsp, win, Scr[screen].gc, 0, 0, sp->width, sp->height);
/* Now static data structures. epirker */
//if (!sp->segs) {
//sp->segs = (XSegment *) malloc(sizeof (XSegment) * sp->beecount);
//sp->old_segs = (XSegment *) malloc(sizeof (XSegment) * sp->beecount);
//sp->x = (short *) malloc(sizeof (short) * sp->beecount * TIMES);
//sp->y = (short *) malloc(sizeof (short) * sp->beecount * TIMES);
//sp->xv = (short *) malloc(sizeof (short) * sp->beecount);
//sp->yv = (short *) malloc(sizeof (short) * sp->beecount);
//}
/* Initialize point positions, velocities, etc. */
/* wasp */
sp->wx[0] = sp->border + rnd.getLong(sp->width - 2 * sp->border);
sp->wy[0] = sp->border + rnd.getLong(sp->height - 2 * sp->border);
sp->wx[1] = sp->wx[0];
sp->wy[1] = sp->wy[0];
sp->wxv = 0;
sp->wyv = 0;
/* bees */
for (b = 0; b < sp->beecount; b++) {
X(0, b) = rnd.getLong(sp->width);
X(1, b) = X(0, b);
Y(0, b) = rnd.getLong(sp->height);
Y(1, b) = Y(0, b);
sp->xv[b] = balance_rand(7);
sp->yv[b] = balance_rand(7);
}
}
/* Sets up initial conditions for a flow without all the extra baggage
that goes with init_flow */
static void
restart_flow(ModeInfo * mi)
{
flowstruct *sp;
int b;
if (flows == NULL)
return;
sp = &flows[MI_SCREEN(mi)];
sp->count = 0;
/* Re-Initialize point positions, velocities, etc. */
for (b = 0; b < sp->beecount; b++) {
X(0, b) = Gauss_Rand(sp->range.x);
Y(0, b) = (sp->yperiod > 0)?
balance_rand(sp->range.y) : Gauss_Rand(sp->range.y);
Z(0, b) = Gauss_Rand(sp->range.z);
}
}
ENTRYPOINT void
init_flow (ModeInfo * mi)
{
flowstruct *sp;
char *name;
if (flows == NULL) {
if ((flows = (flowstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (flowstruct))) == NULL)
return;
}
sp = &flows[MI_SCREEN(mi)];
sp->count2 = 0;
sp->taillen = MI_SIZE(mi);
if (sp->taillen < -MINTRAIL) {
/* Change by sqrt so it seems more variable */
sp->taillen = NRAND((int)sqrt((double) (-sp->taillen - MINTRAIL + 1)));
sp->taillen = sp->taillen * sp->taillen + MINTRAIL;
} else if (sp->taillen < MINTRAIL) {
sp->taillen = MINTRAIL;
}
if(!rotatep && !ridep) rotatep = True; /* We need at least one viewpoint */
/* Start camera at Orbit or Bee */
if(rotatep) {
sp->chaseto = ORBIT;
} else {
sp->chaseto = BEE;
}
sp->chasetime = 1; /* Go directly to target */
sp->lyap = 0;
sp->yperiod = 0;
sp->step2 = INITIALSTEP;
/* Zero parameter set */
memset(sp->par2, 0, N_PARS * sizeof(dvector));
/* Set up standard examples */
switch (NRAND((periodicp) ? 5 : 3)) {
case 0:
/*
x' = a(y - x)
y' = x(b - z) - y
z' = xy - cz
*/
name = "Lorentz";
sp->par2[Y].x = 10 + balance_rand(5*0); /* a */
sp->par2[X].x = - sp->par2[Y].x; /* -a */
sp->par2[X].y = 28 + balance_rand(5*0); /* b */
sp->par2[XZ].y = -1;
sp->par2[Y].y = -1;
sp->par2[XY].z = 1;
sp->par2[Z].z = - 2 + balance_rand(1*0); /* -c */
break;
case 1:
/*
x' = -(y + az)
y' = x + by
z' = c + z(x - 5.7)
*/
name = "Rossler";
sp->par2[Y].x = -1;
sp->par2[Z].x = -2 + balance_rand(1); /* a */
sp->par2[X].y = 1;
sp->par2[Y].y = 0.2 + balance_rand(0.1); /* b */
sp->par2[C].z = 0.2 + balance_rand(0.1); /* c */
sp->par2[XZ].z = 1;
sp->par2[Z].z = -5.7;
break;
case 2:
/*
x' = -(y + az)
y' = x + by - cz^2
z' = 0.2 + z(x - 5.7)
*/
name = "RosslerCone";
sp->par2[Y].x = -1;
sp->par2[Z].x = -2; /* a */
sp->par2[X].y = 1;
sp->par2[Y].y = 0.2; /* b */
sp->par2[ZZ].y = -0.331 + balance_rand(0.01); /* c */
sp->par2[C].z = 0.2;
sp->par2[XZ].z = 1;
sp->par2[Z].z = -5.7;
break;
case 3:
/*
x' = -z + b sin(y)
y' = c
z' = 0.7x + az(0.1 - x^2)
*/
name = "Birkhoff";
sp->par2[Z].x = -1;
sp->par2[SINY].x = 0.35 + balance_rand(0.25); /* b */
sp->par2[C].y = 1.57; /* c */
sp->par2[X].z = 0.7;
sp->par2[Z].z = 1 + balance_rand(0.5); /* a/10 */
sp->par2[XXZ].z = -10 * sp->par2[Z].z; /* -a */
sp->yperiod = 2 * M_PI;
break;
default:
/*
x' = -ax - z/2 - z^3/8 + b sin(y)
y' = c
z' = 2x
*/
name = "Duffing";
sp->par2[X].x = -0.2 + balance_rand(0.1); /* a */
sp->par2[Z].x = -0.5;
sp->par2[ZZZ].x = -0.125;
sp->par2[SINY].x = 27.0 + balance_rand(3.0); /* b */
sp->par2[C].y = 1.33; /* c */
sp->par2[X].z = 2;
sp->yperiod = 2 * M_PI;
break;
}
sp->range.x = 5;
sp->range.z = 5;
if(sp->yperiod > 0) {
sp->ODE = Periodic;
/* periodic flows show either uniform distribution or a
snapshot on the 'time' axis */
sp->range.y = NRAND(2)? sp->yperiod : 0;
} else {
sp->range.y = 5;
sp->ODE = Cubic;
}
/* Run discoverer to set up bounding box, etc. Lyapunov will
probably be innaccurate, since we're only running it once, but
we're using known strange attractors so it should be ok. */
discover(mi);
if(MI_IS_VERBOSE(mi))
fprintf(stdout,
"flow: Lyapunov exponent: %g, step: %g, size: %g (%s)\n",
sp->lyap2, sp->step2, sp->size2, name);
/* Install new params */
sp->lyap = sp->lyap2;
sp->size = sp->size2;
sp->mid = sp->mid2;
sp->step = sp->step2;
memcpy(sp->par, sp->par2, sizeof(sp->par2));
sp->count2 = 0; /* Reset search */
free_flow(sp);
sp->beecount = MI_COUNT(mi);
if (sp->beecount < 0) { /* random variations */
sp->beecount = NRAND(-sp->beecount) + 1; /* Minimum 1 */
}
# ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
dbufp = False;
# endif
if(dbufp) { /* Set up double buffer */
if (sp->buffer != None)
XFreePixmap(MI_DISPLAY(mi), sp->buffer);
sp->buffer = XCreatePixmap(MI_DISPLAY(mi), MI_WINDOW(mi),
MI_WIDTH(mi), MI_HEIGHT(mi), MI_DEPTH(mi));
} else {
sp->buffer = MI_WINDOW(mi);
}
/* no "NoExpose" events from XCopyArea wanted */
XSetGraphicsExposures(MI_DISPLAY(mi), MI_GC(mi), False);
/* Make sure we're using 'thin' lines */
XSetLineAttributes(MI_DISPLAY(mi), MI_GC(mi), 0, LineSolid, CapNotLast,
JoinMiter);
/* Clear the background (may be slow depending on user prefs). */
MI_CLEARWINDOW(mi);
/* Allocate memory. */
if (sp->csegs == NULL) {
allocate(sp->csegs, XSegment,
(sp->beecount + BOX_L) * MI_NPIXELS(mi) * sp->taillen);
allocate(sp->cnsegs, int, MI_NPIXELS(mi));
allocate(sp->old_segs, XSegment, sp->beecount * sp->taillen);
allocate(sp->p, dvector, sp->beecount * sp->taillen);
}
static Bool
discover(ModeInfo * mi)
{
flowstruct *sp;
double l = 0;
dvector dl;
dvector max, min;
double dl2, df, rs, lsum = 0, s, maxv2 = 0, v2;
int N, i, nl = 0;
if (flows == NULL)
return 0;
sp = &flows[MI_SCREEN(mi)];
if(sp->count2 == 0) {
/* initial conditions */
sp->p2[0].x = Gauss_Rand(sp->range.x);
sp->p2[0].y = (sp->yperiod > 0)?
balance_rand(sp->range.y) : Gauss_Rand(sp->range.y);
sp->p2[0].z = Gauss_Rand(sp->range.z);
/* 1000 steps to find an attractor */
/* Most cases explode out here */
for(N=0; N < 1000; N++){
Iterate(sp->p2, sp->ODE, sp->par2, sp->step2);
if(sp->yperiod > 0 && sp->p2[0].y > sp->yperiod)
sp->p2[0].y -= sp->yperiod;
if(fabs(sp->p2[0].x) > LOST_IN_SPACE ||
fabs(sp->p2[0].y) > LOST_IN_SPACE ||
fabs(sp->p2[0].z) > LOST_IN_SPACE) {
return 0;
}
sp->count2++;
}
/* Small perturbation */
sp->p2[1].x = sp->p2[0].x + 0.000001;
sp->p2[1].y = sp->p2[0].y;
sp->p2[1].z = sp->p2[0].z;
}
/* Reset bounding box */
max.x = min.x = sp->p2[0].x;
max.y = min.y = sp->p2[0].y;
max.z = min.z = sp->p2[0].z;
/* Compute Lyapunov Exponent */
/* (Technically, we're only estimating the largest Lyapunov
Exponent, but that's all we need to know to determine if we
have a strange attractor.) [TDA] */
/* Fly two bees close together */
for(N=0; N < 5000; N++){
for(i=0; i< 2; i++) {
v2 = Iterate(sp->p2+i, sp->ODE, sp->par2, sp->step2);
if(sp->yperiod > 0 && sp->p2[i].y > sp->yperiod)
sp->p2[i].y -= sp->yperiod;
if(fabs(sp->p2[i].x) > LOST_IN_SPACE ||
fabs(sp->p2[i].y) > LOST_IN_SPACE ||
fabs(sp->p2[i].z) > LOST_IN_SPACE) {
return 0;
}
if(v2 > maxv2) maxv2 = v2; /* Track max v^2 */
}
/* find bounding box */
if ( sp->p2[0].x < min.x ) min.x = sp->p2[0].x;
else if ( sp->p2[0].x > max.x ) max.x = sp->p2[0].x;
if ( sp->p2[0].y < min.y ) min.y = sp->p2[0].y;
else if ( sp->p2[0].y > max.y ) max.y = sp->p2[0].y;
if ( sp->p2[0].z < min.z ) min.z = sp->p2[0].z;
else if ( sp->p2[0].z > max.z ) max.z = sp->p2[0].z;
/* Measure how much we have to pull the two bees to prevent
them diverging. */
dl.x = sp->p2[1].x - sp->p2[0].x;
dl.y = sp->p2[1].y - sp->p2[0].y;
dl.z = sp->p2[1].z - sp->p2[0].z;
dl2 = dl.x*dl.x + dl.y*dl.y + dl.z*dl.z;
if(dl2 > 0) {
df = 1e12 * dl2;
rs = 1/sqrt(df);
sp->p2[1].x = sp->p2[0].x + rs * dl.x;
sp->p2[1].y = sp->p2[0].y + rs * dl.y;
sp->p2[1].z = sp->p2[0].z + rs * dl.z;
lsum = lsum + log(df);
nl = nl + 1;
l = M_LOG2E / 2 * lsum / nl / sp->step2;
}
sp->count2++;
}
/* Anything that didn't explode has a finite attractor */
/* If Lyapunov is negative then it probably hit a fixed point or a
* limit cycle. Positive Lyapunov indicates a strange attractor. */
sp->lyap2 = l;
sp->size2 = max.x - min.x;
s = max.y - min.y;
if(s > sp->size2) sp->size2 = s;
s = max.z - min.z;
if(s > sp->size2) sp->size2 = s;
sp->mid2.x = (max.x + min.x) / 2;
sp->mid2.y = (max.y + min.y) / 2;
sp->mid2.z = (max.z + min.z) / 2;
if(sqrt(maxv2) > sp->size2 * 0.2) {
/* Flowing too fast, reduce step size. This
helps to eliminate high-speed limit cycles,
which can show +ve Lyapunov due to integration
inaccuracy. */
sp->step2 /= 2;
}
return 1;
}
void
drawswarm(Window win, KRandomSequence &rnd)
{
swarmstruct *sp = &swarms[screen];
int b;
/* <=- Wasp -=> */
/* Age the arrays. */
sp->wx[2] = sp->wx[1];
sp->wx[1] = sp->wx[0];
sp->wy[2] = sp->wy[1];
sp->wy[1] = sp->wy[0];
/* Accelerate */
sp->wxv += balance_rand(WASPACC);
sp->wyv += balance_rand(WASPACC);
/* Speed Limit Checks */
if (sp->wxv > WASPVEL)
sp->wxv = WASPVEL;
if (sp->wxv < -WASPVEL)
sp->wxv = -WASPVEL;
if (sp->wyv > WASPVEL)
sp->wyv = WASPVEL;
if (sp->wyv < -WASPVEL)
sp->wyv = -WASPVEL;
/* Move */
sp->wx[0] = sp->wx[1] + sp->wxv;
sp->wy[0] = sp->wy[1] + sp->wyv;
/* Bounce Checks */
if ((sp->wx[0] < sp->border) || (sp->wx[0] > sp->width - sp->border - 1)) {
sp->wxv = -sp->wxv;
sp->wx[0] += sp->wxv;
}
if ((sp->wy[0] < sp->border) || (sp->wy[0] > sp->height - sp->border - 1)) {
sp->wyv = -sp->wyv;
sp->wy[0] += sp->wyv;
}
/* Don't let things settle down. */
sp->xv[rnd.getLong(sp->beecount)] += balance_rand(3);
sp->yv[rnd.getLong(sp->beecount)] += balance_rand(3);
/* <=- Bees -=> */
for (b = 0; b < sp->beecount; b++) {
int distance, dx, dy;
/* Age the arrays. */
X(2, b) = X(1, b);
X(1, b) = X(0, b);
Y(2, b) = Y(1, b);
Y(1, b) = Y(0, b);
/* Accelerate */
dx = sp->wx[1] - X(1, b);
dy = sp->wy[1] - Y(1, b);
distance = abs(dx) + abs(dy); /* approximation */
if (distance == 0)
distance = 1;
sp->xv[b] += (dx * BEEACC) / distance;
sp->yv[b] += (dy * BEEACC) / distance;
/* Speed Limit Checks */
if (sp->xv[b] > BEEVEL)
sp->xv[b] = BEEVEL;
if (sp->xv[b] < -BEEVEL)
sp->xv[b] = -BEEVEL;
if (sp->yv[b] > BEEVEL)
sp->yv[b] = BEEVEL;
if (sp->yv[b] < -BEEVEL)
sp->yv[b] = -BEEVEL;
/* Move */
X(0, b) = X(1, b) + sp->xv[b];
Y(0, b) = Y(1, b) + sp->yv[b];
/* Fill the segment lists. */
sp->segs[b].x1 = X(0, b);
sp->segs[b].y1 = Y(0, b);
sp->segs[b].x2 = X(1, b);
sp->segs[b].y2 = Y(1, b);
sp->old_segs[b].x1 = X(1, b);
sp->old_segs[b].y1 = Y(1, b);
sp->old_segs[b].x2 = X(2, b);
sp->old_segs[b].y2 = Y(2, b);
}
XSetForeground(dsp, Scr[screen].gc, BlackPixel(dsp, screen));
XDrawLine(dsp, win, Scr[screen].gc,
sp->wx[1], sp->wy[1], sp->wx[2], sp->wy[2]);
XDrawSegments(dsp, win, Scr[screen].gc, sp->old_segs, sp->beecount);
XSetForeground(dsp, Scr[screen].gc, WhitePixel(dsp, screen));
XDrawLine(dsp, win, Scr[screen].gc,
sp->wx[0], sp->wy[0], sp->wx[1], sp->wy[1]);
if (!mono && Scr[screen].npixels > 2) {
XSetForeground(dsp, Scr[screen].gc, Scr[screen].pixels[sp->pix]);
if (++sp->pix >= Scr[screen].npixels)
sp->pix = 0;
}
XDrawSegments(dsp, win, Scr[screen].gc, sp->segs, sp->beecount);
}
void
draw_swarm(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
int b, newlimit;
Bool track_p = trackmouse;
int cx, cy;
short prev;
float speed;
swarmstruct *sp;
if (swarms == NULL)
return;
sp = &swarms[MI_SCREEN(mi)];
if (sp->segs == NULL)
return;
MI_IS_DRAWN(mi) = True;
if (track_p) {
Window r, c;
int rx, ry;
unsigned int m;
(void) XQueryPointer(display, window,
&r, &c, &rx, &ry, &cx, &cy, &m);
if (cx <= sp->border || cy <= sp->border ||
cx >= MI_WIDTH(mi) - 1 - sp->border ||
cy >= MI_HEIGHT(mi) - 1 - sp->border)
track_p = False;
}
/* <=- Wasp -=> */
/* Age the arrays. */
sp->wx[2] = sp->wx[1];
sp->wx[1] = sp->wx[0];
sp->wy[2] = sp->wy[1];
sp->wy[1] = sp->wy[0];
if (track_p) {
sp->wx[0] = cx;
sp->wy[0] = cy;
} else {
/* Accelerate */
sp->wxv += balance_rand(WASPACC);
sp->wyv += balance_rand(WASPACC);
/* Speed Limit Checks */
speed = sqrt((double) sp->wxv * sp->wxv + sp->wyv * sp->wyv);
if (speed > WASPVEL) {
newlimit = (int) ((NRAND(WASPVEL) + WASPVEL / 2) / speed);
sp->wxv *= newlimit;
sp->wyv *= newlimit;
}
/* Move */
sp->wx[0] = sp->wx[1] + sp->wxv;
sp->wy[0] = sp->wy[1] + sp->wyv;
/* Bounce Checks */
if ((sp->wx[0] < sp->border) || (sp->wx[0] > sp->width - sp->border - 1)) {
sp->wxv = -sp->wxv;
sp->wx[0] += sp->wxv;
}
if ((sp->wy[0] < sp->border) || (sp->wy[0] > sp->height - sp->border - 1)) {
sp->wyv = -sp->wyv;
sp->wy[0] += sp->wyv;
}
/* Don't let things settle down. */
sp->xv[NRAND(sp->beecount)] += balance_rand(3);
sp->yv[NRAND(sp->beecount)] += balance_rand(3);
}
/* <=- Bees -=> */
sp->tick = ++(sp->tick) % (sp->taillen);
prev = (sp->tick) ? sp->tick - 1 : sp->taillen - 1;
if (sp->tick == sp->taillen - 1)
sp->rolloverflag = 1;
for (b = 0; b < sp->beecount; b++) {
int distance, dx, dy;
/* Accelerate */
dx = (int) (sp->wx[1] - X(prev, b));
dy = (int) (sp->wy[1] - Y(prev, b));
distance = (int) sqrt((double) dx * dx + dy * dy);
if (distance == 0)
distance = 1;
sp->xv[b] += dx * BEEACC / (2 * distance);
sp->yv[b] += dy * BEEACC / (2 * distance);
/* Speed Limit Checks */
speed = sqrt(sp->xv[b] * sp->xv[b] + sp->yv[b] * sp->yv[b]);
if (speed > BEEVEL) {
newlimit = (int) ((NRAND(BEEVEL) + BEEVEL / 2) / speed);
sp->xv[b] *= newlimit;
sp->yv[b] *= newlimit;
}
/* Move */
X(sp->tick, b) = X(prev, b) + sp->xv[b];
Y(sp->tick, b) = Y(prev, b) + sp->yv[b];
/* Fill the segment lists. */
sp->segs[b].x1 = (short) X(sp->tick, b);
sp->segs[b].y1 = (short) Y(sp->tick, b);
sp->segs[b].x2 = (short) X(prev, b);
sp->segs[b].y2 = (short) Y(prev, b);
sp->old_segs[b].x1 = (short) X(((sp->tick+2)%sp->taillen), b);
sp->old_segs[b].y1 = (short) Y(((sp->tick+2)%sp->taillen), b);
sp->old_segs[b].x2 = (short) X(((sp->tick+1)%sp->taillen), b);
sp->old_segs[b].y2 = (short) Y(((sp->tick+1)%sp->taillen), b);
}
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XDrawLine(display, window, gc,
sp->wx[1], sp->wy[1], sp->wx[2], sp->wy[2]);
if (sp->rolloverflag) {
XDrawSegments(display, window, gc, sp->old_segs, sp->beecount);
}
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
XDrawLine(display, window, gc,
sp->wx[0], sp->wy[0], sp->wx[1], sp->wy[1]);
if (MI_NPIXELS(mi) > 2) {
XSetForeground(display, gc, MI_PIXEL(mi, sp->pix));
if (++sp->pix >= MI_NPIXELS(mi))
sp->pix = 0;
}
XDrawSegments(display, window, gc, sp->segs, sp->beecount);
}
void
init_swarm(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int b, t;
swarmstruct *sp;
if (swarms == NULL) {
if ((swarms = (swarmstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (swarmstruct))) == NULL)
return;
}
sp = &swarms[MI_SCREEN(mi)];
sp->beecount = MI_COUNT(mi);
if (sp->beecount < -MINBEES) {
sp->beecount = NRAND(-sp->beecount - MINBEES + 1) + MINBEES;
/* if sp->beecount is random ... the size can change */
free_bees(sp);
} else if (sp->beecount < MINBEES)
sp->beecount = MINBEES;
sp->taillen = MI_SIZE(mi);
if (sp->taillen < -MINTRAIL) {
/* Change by sqr so its seems more variable */
sp->taillen = NRAND((int) sqrt((double) (-sp->taillen - MINTRAIL + 1)));
sp->taillen = sp->taillen * sp->taillen + MINTRAIL;
free_segs(sp);
} else if (sp->taillen < MINTRAIL)
sp->taillen = MINTRAIL;
sp->width = MI_WIDTH(mi);
sp->height = MI_HEIGHT(mi);
sp->border = (sp->width + sp->height) / 50;
sp->tick = 0;
sp->rolloverflag = 0;
if (trackmouse && !sp->cursor) { /* Create an invisible cursor */
Pixmap bit;
XColor black;
black.red = 0;
black.green = 0;
black.blue = 0;
black.flags = DoRed | DoGreen | DoBlue;
if ((bit = XCreatePixmapFromBitmapData(display, window,
(char *) "\000", 1, 1, MI_BLACK_PIXEL(mi),
MI_BLACK_PIXEL(mi), 1)) == None) {
free_bees(sp); /* Do not need to free cursor */
return;
}
if ((sp->cursor = XCreatePixmapCursor(display, bit, bit,
&black, &black, 0, 0)) == None) {
XFreePixmap(display, bit);
free_bees(sp);
return;
}
XFreePixmap(display, bit);
}
XDefineCursor(display, window, sp->cursor);
MI_CLEARWINDOW(mi);
/* Allocate memory. */
if (sp->segs == NULL) {
if (((sp->segs = (XSegment *) malloc(sizeof (XSegment) *
sp->beecount)) == NULL) ||
((sp->old_segs = (XSegment *) malloc(sizeof (XSegment) *
sp->beecount)) == NULL) ||
((sp->x = (float *) malloc(sizeof (float) * sp->beecount *
sp->taillen)) == NULL) ||
((sp->y = (float *) malloc(sizeof (float) * sp->beecount *
sp->taillen)) == NULL) ||
((sp->xv = (float *) malloc(sizeof (float) *
sp->beecount)) == NULL) ||
((sp->yv = (float *) malloc(sizeof (float) *
sp->beecount)) == NULL)) {
free_swarm(display, sp);
return;
}
}
/* Initialize point positions, velocities, etc. */
if (MI_NPIXELS(mi) > 2)
sp->pix = NRAND(MI_NPIXELS(mi));
/* wasp */
sp->wx[0] = sp->border + NRAND(sp->width - 2 * sp->border);
sp->wy[0] = sp->border + NRAND(sp->height - 2 * sp->border);
sp->wx[1] = sp->wx[0];
sp->wy[1] = sp->wy[0];
sp->wxv = 0;
sp->wyv = 0;
/* bees */
for (b = 0; b < sp->beecount; b++) {
X(0, b) = NRAND(sp->width);
Y(0, b) = NRAND(sp->height);
for (t = 1; t < sp->taillen; t++) {
X(t, b) = X(0, b);
Y(t, b) = Y(0, b);
}
sp->xv[b] = balance_rand(7);
sp->yv[b] = balance_rand(7);
}
}
