ENTRYPOINT void
init_mgears (ModeInfo *mi)
{
mgears_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
int i;
if (!bps) {
bps = (mgears_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (mgears_configuration));
if (!bps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_mgears (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
if (!wire)
{
GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
}
{
double spin_speed = 0.5;
double wander_speed = 0.01;
double spin_accel = 2.0;
bp->rot = make_rotator (do_spin ? spin_speed : 0,
do_spin ? spin_speed : 0,
do_spin ? spin_speed : 0,
spin_accel,
do_wander ? wander_speed : 0,
False /* don't randomize */
);
bp->trackball = gltrackball_init ();
}
{
int total_gears = MI_COUNT(mi);
double gears_per_turn;
double gear_r, tw, th, thick, slope;
int nubs, size;
if (! (total_gears & 1))
total_gears++; /* must be odd or gears intersect */
/* Number of teeth must be odd if number of gears is odd, or teeth don't
mesh when the loop closes. And since number of gears must be odd...
*/
if (! (teeth_arg & 1)) teeth_arg++;
if (teeth_arg < 7) teeth_arg = 7;
if (total_gears < 13) /* gear mesh angle is too steep with less */
total_gears = 13;
thick = 0.2;
nubs = (random() & 3) ? 0 : (random() % teeth_arg) / 2;
slope = 0;
/* Sloping gears are incompatible with "-roll" ... */
/* slope= -M_PI * 2 / total_gears; */
gears_per_turn = total_gears / 2.0;
bp->ring_r = 3;
gear_r = M_PI * bp->ring_r / gears_per_turn;
tw = 0;
th = gear_r * 2.5 / teeth_arg;
/* If the gears are small, use a lower density mesh. */
size = (gear_r > 0.32 ? INVOLUTE_LARGE :
gear_r > 0.13 ? INVOLUTE_MEDIUM :
INVOLUTE_SMALL);
/* If there are lots of teeth, use a lower density mesh. */
if (teeth_arg > 77)
size = INVOLUTE_SMALL;
if (teeth_arg > 45 && size == INVOLUTE_LARGE)
size = INVOLUTE_MEDIUM;
bp->ngears = total_gears;
bp->gears = (mogear *) calloc (bp->ngears, sizeof(*bp->gears));
for (i = 0; i < bp->ngears; i++)
{
mogear *mg = &bp->gears[i];
gear *g = &mg->g;
g->r = gear_r;
g->size = size;
g->nteeth = teeth_arg;
g->tooth_w = tw;
g->tooth_h = th;
g->tooth_slope = slope;
g->thickness = g->r * thick;
g->thickness2 = g->thickness * 0.1;
g->thickness3 = g->thickness;
g->inner_r = g->r * 0.80;
g->inner_r2 = g->r * 0.60;
g->inner_r3 = g->r * 0.55;
g->nubs = nubs;
mg->pos_th = (M_PI * 2 / gears_per_turn) * i;
mg->pos_thz = (M_PI / 2 / gears_per_turn) * i;
g->th = ((i & 1)
? (M_PI * 2 / g->nteeth)
: 0);
/* Colorize
*/
g->color[0] = 0.7 + frand(0.3);
g->color[1] = 0.7 + frand(0.3);
g->color[2] = 0.7 + frand(0.3);
g->color[3] = 1.0;
g->color2[0] = g->color[0] * 0.85;
g->color2[1] = g->color[1] * 0.85;
g->color2[2] = g->color[2] * 0.85;
g->color2[3] = g->color[3];
/* Now render the gear into its display list.
*/
g->dlist = glGenLists (1);
if (! g->dlist)
{
check_gl_error ("glGenLists");
abort();
}
glNewList (g->dlist, GL_COMPILE);
g->polygons += draw_involute_gear (g, wire);
glEndList ();
}
}
}
ENTRYPOINT void
init_tunnel (ModeInfo *mi)
{
int i;
tunnel_configuration *tc;
wire = MI_IS_WIREFRAME(mi);
# ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */
wire = 0;
# endif
if (!tconf) {
tconf = (tunnel_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (tunnel_configuration));
if (!tconf) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
tc = &tconf[MI_SCREEN(mi)];
tc->glx_context = init_GL(mi);
tc->cyllist = glGenLists(1);
tc->diamondlist = glGenLists(1);
tc->num_effects = 12;
tc->num_texshifts = 3;
tc->effect_time = 0.0;
tc->effect_maxsecs = 30.00;
/* check bounds on cmd line opts */
if (start > tc->effect_maxsecs) start = tc->effect_maxsecs;
if (end > tc->effect_maxsecs) end = tc->effect_maxsecs;
if (start < tc->effect_time) start = tc->effect_time;
if (end < tc->effect_time) end = tc->effect_time;
/* set loop times, in seconds */
tc->start_time = start;
tc->end_time = end;
/* reset animation knots, effect 0 not defined. */
tc->effects = malloc(sizeof(effect_t) * ( tc->num_effects + 1));
for ( i = 1; i <= tc->num_effects ; i++)
init_effects(&tc->effects[i], i);
if (wire) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
do_texture = False;
}
if (do_texture)
{
/* the following textures are loaded, and possible overridden:
tunnel 1, tunnel 2, tunnel 3, marquee, tardis, head */
glGenTextures(MAX_TEXTURE, tc->texture_binds);
/*LoadTexture(*mi, **fn, *filename, texbind, bluralpha, bw_color, anegative, onealpha)*/
if (strcasecmp (do_tun1, "(none)")) /* tunnel 1 */
LoadTexture(mi, NULL, do_tun1, tc->texture_binds[0], 0,0.0, False, False);
else
LoadTexture(mi, timetunnel0_xpm, NULL, tc->texture_binds[0], 0, 0.0, False, False);
if (strcasecmp (do_tun2, "(none)")) /* tunnel 2 */
LoadTexture(mi, NULL, do_tun2, tc->texture_binds[2], 0,0.0, False, False);
else
LoadTexture(mi, timetunnel1_xpm, NULL, tc->texture_binds[2], 0, 0.0, False, False);
if (strcasecmp (do_tun3, "(none)")) /* tunnel 3 */
LoadTexture(mi, NULL, do_tun3, tc->texture_binds[5], 0,0.0, False, False);
else
LoadTexture(mi, timetunnel2_xpm, NULL, tc->texture_binds[5], 0, 0.0, False, False);
LoadTexture(mi, tunnelstar_xpm, NULL, tc->texture_binds[4], 0, 0.0, False, False);
if (strcasecmp (do_tx1, "(none)")) /* marquee */
LoadTexture(mi, NULL, do_tx1, tc->texture_binds[3], 0,0.0, False, False);
#ifndef HAVE_JWZGLES /* logo_180_xpm is 180px which is not a power of 2! */
else
LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[3], 0,0.0, False, False);
#endif
if (strcasecmp (do_tx2, "(none)")) /* tardis */
LoadTexture(mi, NULL, do_tx2, tc->texture_binds[1], 0, 0.0 ,False, False);
#ifndef HAVE_JWZGLES /* logo_180_xpm is 180px which is not a power of 2! */
else
LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[1], 0,0.0, False, False);
#endif
if (strcasecmp (do_tx3, "(none)")) { /* head */
LoadTexture(mi, NULL, do_tx3, tc->texture_binds[6], 0, 0.0 ,False, False);
/* negative */
LoadTexture(mi, NULL, do_tx3, tc->texture_binds[9], 2,1.0, True, True);
#ifndef HAVE_JWZGLES /* logo_180_xpm is 180px which is not a power of 2! */
} else {
LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[6], 0,0.0, False, False);
/* negative */
LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[9], 2,1.0, True, True);
#endif
}
glEnable(GL_TEXTURE_2D);
check_gl_error("tex");
}
reshape_tunnel (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDisable(GL_DEPTH_TEST); /* who needs it? ;-) */
if (do_fog)
glEnable(GL_FOG);
if (!wire)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5);
}
tc->trackball = gltrackball_init ();
tc->texshift = calloc(tc->num_texshifts, sizeof(GLfloat));
for ( i = 0 ; i < tc->num_texshifts; i++)
tc->texshift[i] = 0.0;
glNewList(tc->cyllist, GL_COMPILE);
makecyl(30, -0.1, CYL_LEN, 1., 10. / 40.0 * CYL_LEN);
/*makecyl(30, -0.5, DIAMOND_LEN, 1., 4. / 40 * DIAMOND_LEN); */
glEndList();
glNewList(tc->diamondlist, GL_COMPILE);
makecyl(4, -0.5, DIAMOND_LEN, 1., 4. / 40 * DIAMOND_LEN);
glEndList();
}
void
init_hop(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
GC gc = MI_GC(mi);
double range;
hopstruct *hp;
if (hops == NULL) {
if ((hops = (hopstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (hopstruct))) == NULL)
return;
}
hp = &hops[MI_SCREEN(mi)];
hp->centerx = MI_WIDTH(mi) / 2;
hp->centery = MI_HEIGHT(mi) / 2;
/* Make the other operations less common since they are less interesting */
if (MI_IS_FULLRANDOM(mi)) {
hp->op = NRAND(OPS);
} else {
if (martin)
hp->op = MARTIN;
else if (popcorn)
hp->op = POPCORN;
else if (ejk1)
hp->op = EJK1;
else if (ejk2)
hp->op = EJK2;
else if (ejk3)
hp->op = EJK3;
else if (ejk4)
hp->op = EJK4;
else if (ejk5)
hp->op = EJK5;
else if (ejk6)
hp->op = EJK6;
else if (rr)
hp->op = RR;
else if (jong)
hp->op = JONG;
else if (sine)
hp->op = SINE;
else
hp->op = NRAND(OPS);
}
range = sqrt((double) hp->centerx * hp->centerx +
(double) hp->centery * hp->centery) / (1.0 + LRAND() / MAXRAND);
hp->i = hp->j = 0.0;
hp->inc = (int) ((LRAND() / MAXRAND) * 200) - 100;
#undef XMARTIN
switch (hp->op) {
case MARTIN:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 1500.0 + 40.0;
hp->b = (LRAND() / MAXRAND) * 17.0 + 3.0;
hp->c = (LRAND() / MAXRAND) * 3000.0 + 100.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
hp->b = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
if (LRAND() & 1)
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
else
hp->c = 0.0;
#endif
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "sqrt a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK1:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 500.0;
hp->c = (LRAND() / MAXRAND) * 100.0 + 10.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 40.0;
#endif
hp->b = (LRAND() / MAXRAND) * 0.4;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk1 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK2:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 500.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
#endif
hp->b = pow(10.0, 6.0 + (LRAND() / MAXRAND) * 24.0);
if (LRAND() & 1)
hp->b = -hp->b;
hp->c = pow(10.0, (LRAND() / MAXRAND) * 9.0);
if (LRAND() & 1)
hp->c = -hp->c;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk2 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK3:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 500.0;
hp->c = (LRAND() / MAXRAND) * 80.0 + 30.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 70.0;
#endif
hp->b = (LRAND() / MAXRAND) * 0.35 + 0.5;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk3 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK4:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 1000.0;
hp->c = (LRAND() / MAXRAND) * 40.0 + 30.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 2.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 200.0;
#endif
hp->b = (LRAND() / MAXRAND) * 9.0 + 1.0;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk4 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK5:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 600.0;
hp->c = (LRAND() / MAXRAND) * 90.0 + 20.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 2.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 200.0;
#endif
hp->b = (LRAND() / MAXRAND) * 0.3 + 0.1;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk5 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK6:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 100.0 + 550.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
#endif
hp->b = (LRAND() / MAXRAND) + 0.5;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk6 a=%g, b=%g\n", hp->a, hp->b);
break;
case RR:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 100.0;
hp->b = (LRAND() / MAXRAND) * 20.0;
hp->c = (LRAND() / MAXRAND) * 200.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 40.0;
hp->b = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 200.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
#endif
hp->d = (LRAND() / MAXRAND) * 0.9;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "rr a=%g, b=%g, c=%g, d=%g\n",
hp->a, hp->b, hp->c, hp->d);
break;
case POPCORN:
hp->a = 0.0;
hp->b = 0.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * 0.24 + 0.25;
hp->inc = 100;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "popcorn a=%g, b=%g, c=%g, d=%g\n",
hp->a, hp->b, hp->c, hp->d);
break;
case JONG:
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
hp->b = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
hp->d = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "jong a=%g, b=%g, c=%g, d=%g\n",
hp->a, hp->b, hp->c, hp->d);
break;
case SINE: /* MARTIN2 */
#ifdef XMARTIN
hp->a = M_PI + ((LRAND() / MAXRAND) * 2.0 - 1.0) * 0.07;
#else
hp->a = M_PI + ((LRAND() / MAXRAND) * 2.0 - 1.0) * 0.7;
#endif
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "sine a=%g\n", hp->a);
break;
}
if (MI_NPIXELS(mi) > 2)
hp->pix = NRAND(MI_NPIXELS(mi));
hp->bufsize = MI_COUNT(mi);
if (hp->bufsize < 1)
hp->bufsize = 1;
if (hp->pointBuffer == NULL) {
if ((hp->pointBuffer = (XPoint *) malloc(hp->bufsize *
sizeof (XPoint))) == NULL)
return;
}
MI_CLEARWINDOW(mi);
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
hp->count = 0;
}
void
init_life1d(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int size = MI_SIZE(mi);
int i;
life1dstruct *lp;
if (life1ds == NULL) {
if ((life1ds = (life1dstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (life1dstruct))) == NULL)
return;
}
lp = &life1ds[MI_SCREEN(mi)];
if (!init_stuff(mi)) {
free_life1d(display, lp);
return;
}
lp->screen_generation = 0;
lp->row = 0;
if (totalistic) {
maxstates = MAXSTATES;
maxradius = 4;
maxsum_size = (maxstates - 1) * (maxradius * 2 + 1) + 1;
} else {
maxstates = MAXSTATES - 1;
maxradius = 1;
maxsum_size = (int) power(maxstates, (2 * maxradius + 1));
}
if (lp->nextstate == NULL) {
if ((lp->nextstate = (char *) malloc(maxsum_size *
sizeof (char))) == NULL) {
free_life1d(display, lp);
return;
}
}
if (lp->init_bits == 0) {
XGCValues gcv;
gcv.fill_style = FillOpaqueStippled;
if ((lp->stippledGC = XCreateGC(display, window, GCFillStyle,
&gcv)) == None) {
free_life1d(display, lp);
return;
}
for (i = 0; i < MAXSTATES - 1; i++) {
LIFE1DBITS(stipples[i + NUMSTIPPLES - MAXSTATES + 1],
STIPPLESIZE, STIPPLESIZE);
}
LIFE1DBITS(stipples[NUMSTIPPLES / 2],
STIPPLESIZE, STIPPLESIZE); /* grey */
}
if (lp->newcells != NULL)
free(lp->newcells);
if (lp->oldcells != NULL)
free(lp->oldcells);
if (lp->buffer != NULL)
free(lp->buffer);
if (lp->previousBuffer != NULL)
free(lp->previousBuffer);
lp->previousBuffer = (unsigned char *) NULL;
lp->width = MI_WIDTH(mi);
lp->height = MI_HEIGHT(mi);
if (lp->width < 2)
lp->width = 2;
if (lp->height < 2)
lp->height = 2;
if (size == 0 ||
MINGRIDSIZE * size > lp->width || MINGRIDSIZE * size > lp->height) {
if (lp->width > MINGRIDSIZE * lp->logo->width &&
lp->height > MINGRIDSIZE * lp->logo->height) {
lp->pixelmode = False;
lp->xs = lp->logo->width;
lp->ys = lp->logo->height;
} else
{
int min = MIN(lp->width, lp->height) / (12 * MINGRIDSIZE);
int max = MIN(lp->width, lp->height) / (4 * MINGRIDSIZE);
lp->xs = lp->ys = MAX(MINSIZE, min + NRAND(max - min + 1));
lp->pixelmode = True;
}
} else {
lp->pixelmode = True;
if (size < -MINSIZE) {
lp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
} else if (size < MINSIZE) {
lp->ys = MINSIZE;
} else {
lp->ys = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE));
}
lp->xs = lp->ys;
}
lp->ncols = MAX(lp->width / lp->xs, 2);
lp->nrows = MAX(lp->height / lp->ys, 2);
lp->border = (lp->nrows / 2 + 1) * MI_CYCLES(mi);
if ((lp->newcells = (unsigned char *) calloc(lp->ncols + 2 * lp->border,
sizeof (unsigned char))) == NULL) {
free_life1d(display, lp);
return;
}
if ((lp->oldcells = (unsigned char *) calloc(lp->ncols + 2 *
(maxradius + lp->border),
sizeof (unsigned char))) == NULL) {
free_life1d(display, lp);
return;
}
if ((lp->buffer = (unsigned char *) calloc(lp->ncols * lp->nrows,
sizeof (unsigned char))) == NULL) {
free_life1d(display, lp);
return;
}
lp->xb = (lp->width - lp->xs * lp->ncols) / 2;
lp->yb = (lp->height - lp->ys * lp->nrows) / 2;
GetRule(lp, (int) NRAND((totalistic) ? TOTALISTICRULES : LCAURULES));
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stdout, "colors %d, radius %d, code %ld, ",
lp->k, lp->r, lp->code);
if (totalistic) {
(void) fprintf(stdout, "totalistic rule ");
for (i = (lp->k - 1) * (lp->r * 2 + 1); i >= 0; i--)
(void) fprintf(stdout, "%d", (int) lp->nextstate[i]);
} else {
(void) fprintf(stdout, "LCAU rule ");
for (i = (int) power(lp->k, (lp->r * 2 + 1)); i >= 0; i--)
(void) fprintf(stdout, "%d", (int) lp->nextstate[i]);
}
(void) fprintf(stdout, "\n");
}
if (MI_NPIXELS(mi) > 2)
for (i = 0; i < lp->k - 1; i++)
lp->colors[i] = (NRAND(MI_NPIXELS(mi)) + i * MI_NPIXELS(mi)) /
(lp->k - 1);
RandomSoup(lp, 40, 25);
(void) memcpy((char *) (lp->oldcells + maxradius + lp->border),
(char *) (lp->newcells + lp->border), lp->ncols);
lp->busyLoop = 0;
MI_CLEARWINDOWCOLORMAP(mi, lp->backGC, lp->black);
}
ENTRYPOINT void
init_carousel (ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
carousel_state *ss;
int wire = MI_IS_WIREFRAME(mi);
if (sss == NULL) {
if ((sss = (carousel_state *)
calloc (MI_NUM_SCREENS(mi), sizeof(carousel_state))) == NULL)
return;
}
ss = &sss[screen];
if ((ss->glx_context = init_GL(mi)) != NULL) {
reshape_carousel (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */
} else {
MI_CLEARWINDOW(mi);
}
if (!tilt_str || !*tilt_str)
;
else if (!strcasecmp (tilt_str, "0"))
;
else if (!strcasecmp (tilt_str, "X"))
tilt_x_p = 1;
else if (!strcasecmp (tilt_str, "Y"))
tilt_y_p = 1;
else if (!strcasecmp (tilt_str, "XY"))
tilt_x_p = tilt_y_p = 1;
else
{
fprintf (stderr, "%s: tilt must be 'X', 'Y', 'XY' or '', not '%s'\n",
progname, tilt_str);
exit (1);
}
{
double spin_speed = speed * 0.2; /* rotation of tube around axis */
double spin_accel = speed * 0.1;
double wander_speed = speed * 0.001; /* tilting of axis */
spin_speed *= 0.9 + frand(0.2);
wander_speed *= 0.9 + frand(0.2);
ss->rot = make_rotator (spin_speed, spin_speed, spin_speed,
spin_accel, wander_speed, True);
ss->trackball = gltrackball_init (False);
}
if (strstr ((char *) glGetString(GL_EXTENSIONS),
"GL_EXT_texture_filter_anisotropic"))
glGetFloatv (GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &ss->anisotropic);
else
ss->anisotropic = 0.0;
glDisable (GL_LIGHTING);
glEnable (GL_DEPTH_TEST);
glDisable (GL_CULL_FACE);
if (! wire)
{
glShadeModel (GL_SMOOTH);
glEnable (GL_LINE_SMOOTH);
/* This gives us a transparent diagonal slice through each image! */
/* glEnable (GL_POLYGON_SMOOTH); */
glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_ALPHA_TEST);
glEnable (GL_POLYGON_OFFSET_FILL);
glPolygonOffset (1.0, 1.0);
}
ss->texfont = load_texture_font (MI_DISPLAY(mi), "font");
if (debug_p)
hack_resources (MI_DISPLAY (mi));
ss->nframes = 0;
ss->frames_size = 10;
ss->frames = (image_frame **)
calloc (1, ss->frames_size * sizeof(*ss->frames));
ss->mode = IN;
ss->mode_tick = fade_ticks / speed;
ss->awaiting_first_images_p = True;
}
void
init_coral(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
coralstruct *cp;
int size = MI_SIZE(mi);
int i;
if (reefs == NULL) {
if ((reefs = (coralstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (coralstruct))) == NULL)
return;
}
cp = &reefs[MI_SCREEN(mi)];
cp->width = MAX(MI_WIDTH(mi), 4);
cp->height = MAX(MI_HEIGHT(mi), 4);
cp->widthb = ((cp->width + 31) >> 5);
if (cp->reef != NULL)
free(cp->reef);
if ((cp->reef = (unsigned int *) calloc((cp->widthb + 1) * cp->height,
sizeof (unsigned int))) == NULL) {
free_coral(cp);
return;
}
if (size < -MINSIZE)
cp->density = NRAND(MIN(MAXSIZE, -size) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
cp->density = MINSIZE;
else
cp->density = MIN(MAXSIZE, size);
cp->nwalkers = MAX((cp->width * cp->height * cp->density) / 100, 1);
if (cp->walkers != NULL)
free(cp->walkers);
if ((cp->walkers = (XPoint *) calloc(cp->nwalkers,
sizeof (XPoint))) == NULL) {
free_coral(cp);
return;
}
cp->seeds = MI_COUNT(mi);
if (cp->seeds < -MINSEEDS)
cp->seeds = NRAND(-cp->seeds - MINSEEDS + 1) + MINSEEDS;
else if (cp->seeds < MINSEEDS)
cp->seeds = MINSEEDS;
MI_CLEARWINDOW(mi);
if (MI_NPIXELS(mi) > 2) {
cp->colorindex = NRAND(MI_NPIXELS(mi) * COLORTHRESH);
XSetForeground(display, gc, MI_PIXEL(mi, cp->colorindex / COLORTHRESH));
} else
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
for (i = 0; i < cp->seeds; i++) {
int x, y;
do {
x = NRAND(cp->width);
y = NRAND(cp->height);
} while (getdot(x, y));
setdot((x - 1), (y - 1));
setdot(x, (y - 1));
setdot((x + 1), (y - 1));
setdot((x - 1), y);
setdot(x, y);
setdot((x + 1), y);
setdot((x - 1), (y + 1));
setdot(x, (y + 1));
setdot((x + 1), (y + 1));
XDrawPoint(display, window, gc, x, y);
}
for (i = 0; i < cp->nwalkers; i++) {
cp->walkers[i].x = NRAND(cp->width - 2) + 1;
cp->walkers[i].y = NRAND(cp->height - 2) + 1;
}
if (cp->pointbuf) {
free(cp->pointbuf);
}
if ((cp->pointbuf = (XPoint *) calloc((MAXPOINTS + 2),
sizeof (XPoint))) == NULL) {
free_coral(cp);
return;
}
}
void
init_goop(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
XGCValues gcv;
int nblobs;
unsigned long *plane_masks = NULL;
unsigned long base_pixel = 0;
goopstruct *gp;
if (goops == NULL) {
if ((goops = (goopstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (goopstruct))) == NULL)
return;
}
gp = &goops[MI_SCREEN(mi)];
gp->mode = (False /* xor init */ ? xored
: (True /* transparent init */ ? transparent : opaque));
gp->width = MI_WIDTH(mi);
gp->height = MI_HEIGHT(mi);
free_goop(display, gp);
gp->nlayers = 0; /* planes init */
if (gp->nlayers <= 0)
gp->nlayers = (int) (LRAND() % (MI_DEPTH(mi) - 2)) + 2;
if ((gp->layers = (layer *) calloc(gp->nlayers, sizeof (layer))) == NULL) {
return; /* free_goop just ran */
}
if ((MI_NPIXELS(mi) < 2) && gp->mode == transparent)
gp->mode = opaque;
/* Try to allocate some color planes before committing to nlayers.
*/
#if 0
if (gp->mode == transparent) {
Bool additive_p = True; /* additive init */
int nplanes = gp->nlayers;
/* allocate_alpha_colors (display, MI_COLORMAP(mi), &nplanes, additive_p, &plane_masks,
&base_pixel); *//* COME BACK */
if (nplanes > 1)
gp->nlayers = nplanes;
else {
(void) fprintf(stderr,
"could not allocate any color planes; turning transparency off.\n");
gp->mode = opaque;
}
}
#else
if (gp->mode == transparent)
gp->mode = opaque;
#endif
nblobs = MI_COUNT(mi);
if (nblobs < 0) {
nblobs = NRAND(-nblobs) + 1; /* Add 1 so its not too boring */
} {
int *lblobs;
int total = DEF_COUNT;
if ((lblobs = (int *) calloc(gp->nlayers,
sizeof (int))) == NULL) {
free_goop(display, gp);
return;
}
if (nblobs <= 0)
while (total)
for (i = 0; total && i < gp->nlayers; i++)
lblobs[i]++, total--;
for (i = 0; i < gp->nlayers; i++)
if (!make_layer(mi, &(gp->layers[i]),
(nblobs > 0 ? nblobs : lblobs[i])))
free_goop(display, gp);
free(lblobs);
}
if (gp->mode == transparent && plane_masks) {
for (i = 0; i < gp->nlayers; i++)
gp->layers[i].pixel = base_pixel | plane_masks[i];
gp->background = base_pixel;
}
if (plane_masks != NULL)
free(plane_masks);
if (gp->mode != transparent) {
gp->background = 0; /* init */
for (i = 0; i < gp->nlayers; i++) {
if (MI_NPIXELS(mi) > 2)
gp->layers[i].pixel = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
else
gp->layers[i].pixel = MI_WHITE_PIXEL(mi);
}
}
if ((gp->pixmap = XCreatePixmap(display, window,
MI_WIDTH(mi), MI_HEIGHT(mi),
(gp->mode == xored ? 1 : MI_DEPTH(mi)))) == None) {
free_goop(display, gp);
return;
}
gcv.background = gp->background;
gcv.foreground = 255; /* init */
gcv.line_width = 5; /* thickness init */
if ((gp->pixmap_gc = XCreateGC(display, gp->pixmap, GCLineWidth,
&gcv)) == None) {
free_goop(display, gp);
return;
}
MI_CLEARWINDOW(mi);
}
void
init_wire(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i, size = MI_SIZE(mi), n;
circuitstruct *wp;
XGCValues gcv;
if (circuits == NULL) {
if ((circuits = (circuitstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (circuitstruct))) == NULL)
return;
}
wp = &circuits[MI_SCREEN(mi)];
wp->redrawing = 0;
if ((MI_NPIXELS(mi) <= 2) && (wp->init_bits == 0)) {
if (wp->stippledGC == None) {
gcv.fill_style = FillOpaqueStippled;
if ((wp->stippledGC = XCreateGC(display, window, GCFillStyle,
&gcv)) == None) {
free_wire(display, wp);
return;
}
}
WIREBITS(stipples[NUMSTIPPLES - 1], STIPPLESIZE, STIPPLESIZE);
WIREBITS(stipples[NUMSTIPPLES - 3], STIPPLESIZE, STIPPLESIZE);
WIREBITS(stipples[2], STIPPLESIZE, STIPPLESIZE);
}
if (MI_NPIXELS(mi) > 2) {
wp->colors[0] = (NRAND(MI_NPIXELS(mi)));
wp->colors[1] = (wp->colors[0] + MI_NPIXELS(mi) / 6 +
NRAND(MI_NPIXELS(mi) / 4 + 1)) % MI_NPIXELS(mi);
wp->colors[2] = (wp->colors[1] + MI_NPIXELS(mi) / 6 +
NRAND(MI_NPIXELS(mi) / 4 + 1)) % MI_NPIXELS(mi);
}
free_list(wp);
wp->generation = 0;
if (MI_IS_FULLRANDOM(mi)) {
wp->vertical = (Bool) (LRAND() & 1);
} else {
wp->vertical = vertical;
}
wp->width = MI_WIDTH(mi);
wp->height = MI_HEIGHT(mi);
for (i = 0; i < NEIGHBORKINDS; i++) {
if (neighbors == plots[i]) {
wp->neighbors = plots[i];
break;
}
if (i == NEIGHBORKINDS - 1) {
i = NRAND(NEIGHBORKINDS - 3) + 1; /* Skip triangular ones */
wp->neighbors = plots[i];
break;
}
}
wp->prob_array[wp->neighbors - 1] = 100;
if (wp->neighbors == 3) {
wp->prob_array[1] = 67;
wp->prob_array[0] = 33;
} else {
int incr = 24 / wp->neighbors;
for (i = wp->neighbors - 2; i >= 0; i--) {
wp->prob_array[i] = wp->prob_array[i + 1] - incr -
incr * ((i + 1) != wp->neighbors / 2);
}
}
if (wp->neighbors == 6) {
int nccols, ncrows;
wp->polygon = 6;
if (!wp->vertical) {
wp->height = MI_WIDTH(mi);
wp->width = MI_HEIGHT(mi);
}
if (wp->width < 8)
wp->width = 8;
if (wp->height < 8)
wp->height = 8;
if (size < -MINSIZE)
wp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
wp->ys = MAX(MINSIZE, MIN(wp->width, wp->height) / MINGRIDSIZE);
else
wp->ys = MINSIZE;
} else
wp->ys = MIN(size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE));
wp->xs = wp->ys;
nccols = MAX(wp->width / wp->xs - 2, 16);
ncrows = MAX(wp->height / wp->ys - 1, 16);
wp->ncols = nccols / 2;
wp->nrows = ncrows / 2;
wp->nrows -= !(wp->nrows & 1); /* Must be odd */
wp->xb = (wp->width - wp->xs * nccols) / 2 + wp->xs;
wp->yb = (wp->height - wp->ys * ncrows) / 2 + wp->ys;
for (i = 0; i < 6; i++) {
if (wp->vertical) {
wp->shape.hexagon[i].x =
(wp->xs - 1) * hexagonUnit[i].x;
wp->shape.hexagon[i].y =
((wp->ys - 1) * hexagonUnit[i].y /
2) * 4 / 3;
} else {
wp->shape.hexagon[i].y =
(wp->xs - 1) * hexagonUnit[i].x;
wp->shape.hexagon[i].x =
((wp->ys - 1) * hexagonUnit[i].y /
2) * 4 / 3;
}
}
} else if (wp->neighbors == 4 || wp->neighbors == 8) {
wp->polygon = 4;
if (size < -MINSIZE)
wp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
wp->ys = MAX(MINSIZE, MIN(wp->width, wp->height) / MINGRIDSIZE);
else
wp->ys = MINSIZE;
} else
wp->ys = MIN(size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE));
wp->xs = wp->ys;
wp->ncols = MAX(wp->width / wp->xs, 8);
wp->nrows = MAX(wp->height / wp->ys, 8);
wp->xb = (wp->width - wp->xs * wp->ncols) / 2;
wp->yb = (wp->height - wp->ys * wp->nrows) / 2;
} else { /* TRI */
int orient;
wp->polygon = 3;
if (!wp->vertical) {
wp->height = MI_WIDTH(mi);
wp->width = MI_HEIGHT(mi);
}
if (wp->width < 4)
wp->width = 4;
if (wp->height < 2)
wp->height = 2;
if (size < -MINSIZE)
wp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
wp->ys = MAX(MINSIZE, MIN(wp->width, wp->height) / MINGRIDSIZE);
else
wp->ys = MINSIZE;
} else
wp->ys = MIN(size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE));
wp->xs = (int) (1.52 * wp->ys);
wp->ncols = (MAX(wp->width / wp->xs - 1, 8) / 2) * 2;
wp->nrows = (MAX(wp->height / wp->ys - 1, 8) / 2) * 2 - 1;
wp->xb = (wp->width - wp->xs * wp->ncols) / 2 + wp->xs / 2;
wp->yb = (wp->height - wp->ys * wp->nrows) / 2 + wp->ys;
for (orient = 0; orient < 2; orient++) {
for (i = 0; i < 3; i++) {
if (wp->vertical) {
wp->shape.triangle[orient][i].x =
(wp->xs - 2) * triangleUnit[orient][i].x;
wp->shape.triangle[orient][i].y =
(wp->ys - 2) * triangleUnit[orient][i].y;
} else {
wp->shape.triangle[orient][i].y =
(wp->xs - 2) * triangleUnit[orient][i].x;
wp->shape.triangle[orient][i].x =
(wp->ys - 2) * triangleUnit[orient][i].y;
}
}
}
}
/*
* I am being a bit naughty here wasting a little bit of memory
* but it will give me a real headache to figure out the logic
* and to refigure the mappings to save a few bytes
* ncols should only need a border of 2 and nrows should only need
* a border of 4 when in the neighbors = 9 or 12
*/
wp->bncols = wp->ncols + 4;
wp->bnrows = wp->nrows + 4;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout,
"neighbors %d, ncols %d, nrows %d\n",
wp->neighbors, wp->ncols, wp->nrows);
MI_CLEARWINDOW(mi);
if (wp->oldcells != NULL) {
free(wp->oldcells);
wp->oldcells = (unsigned char *) NULL;
}
if ((wp->oldcells = (unsigned char *) calloc(wp->bncols * wp->bnrows,
sizeof (unsigned char))) == NULL) {
free_wire(display, wp);
return;
}
if (wp->newcells != NULL) {
free(wp->newcells);
wp->newcells = (unsigned char *) NULL;
}
if ((wp->newcells = (unsigned char *) calloc(wp->bncols * wp->bnrows,
sizeof (unsigned char))) == NULL) {
free_wire(display, wp);
return;
}
n = MI_COUNT(mi);
i = (1 + (wp->neighbors == 6)) * wp->ncols * wp->nrows / 4;
if (n < -MINWIRES && i > MINWIRES) {
n = NRAND(MIN(-n, i) - MINWIRES + 1) + MINWIRES;
} else if (n < MINWIRES) {
n = MINWIRES;
} else if (n > i) {
n = MAX(MINWIRES, i);
}
create_path(wp, n);
}
ENTRYPOINT void
init_matrix (ModeInfo *mi)
{
matrix_configuration *mp;
int wire = MI_IS_WIREFRAME(mi);
Bool flip_p = 0;
int i;
if (wire)
do_texture = False;
if (!mps) {
mps = (matrix_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (matrix_configuration));
if (!mps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
mp = &mps[MI_SCREEN(mi)];
mp->glx_context = init_GL(mi);
if (!mode_str || !*mode_str || !strcasecmp(mode_str, "matrix"))
{
flip_p = 1;
mp->glyph_map = matrix_encoding;
mp->nglyphs = countof(matrix_encoding);
}
else if (!strcasecmp (mode_str, "dna"))
{
flip_p = 0;
mp->glyph_map = dna_encoding;
mp->nglyphs = countof(dna_encoding);
}
else if (!strcasecmp (mode_str, "bin") ||
!strcasecmp (mode_str, "binary"))
{
flip_p = 0;
mp->glyph_map = binary_encoding;
mp->nglyphs = countof(binary_encoding);
}
else if (!strcasecmp (mode_str, "hex") ||
!strcasecmp (mode_str, "hexadecimal"))
{
flip_p = 0;
mp->glyph_map = hex_encoding;
mp->nglyphs = countof(hex_encoding);
}
else if (!strcasecmp (mode_str, "dec") ||
!strcasecmp (mode_str, "decimal"))
{
flip_p = 0;
mp->glyph_map = decimal_encoding;
mp->nglyphs = countof(decimal_encoding);
}
else
{
fprintf (stderr,
"%s: `mode' must be matrix, dna, binary, or hex: not `%s'\n",
progname, mode_str);
exit (1);
}
reshape_matrix (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glShadeModel(GL_SMOOTH);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_NORMALIZE);
if (do_texture)
load_textures (mi, flip_p);
/* to scale coverage-percent to strips, this number looks about right... */
mp->nstrips = (int) (density * 2.2);
if (mp->nstrips < 1) mp->nstrips = 1;
else if (mp->nstrips > 2000) mp->nstrips = 2000;
mp->strips = calloc (mp->nstrips, sizeof(strip));
for (i = 0; i < mp->nstrips; i++)
{
strip *s = &mp->strips[i];
reset_strip (mi, s);
/* If we start all strips from zero at once, then the first few seconds
of the animation are much denser than normal. So instead, set all
the initial strips to erase-mode with random starting positions.
As these die off at random speeds and are re-created, we'll get a
more consistent density. */
s->erasing_p = True;
s->spinner_y = frand(GRID_SIZE);
memset (s->glyphs, 0, sizeof(s->glyphs)); /* no visible glyphs */
}
/* Compute the brightness ramp.
*/
for (i = 0; i < WAVE_SIZE; i++)
{
GLfloat j = ((WAVE_SIZE - i) / (GLfloat) (WAVE_SIZE - 1));
j *= (M_PI / 2); /* j ranges from 0.0 - PI/2 */
j = sin (j); /* j ranges from 0.0 - 1.0 */
j = 0.2 + (j * 0.8); /* j ranges from 0.2 - 1.0 */
mp->brightness_ramp[i] = j;
/* printf("%2d %8.2f\n", i, j); */
}
auto_track_init (mi);
}
void
init_turtle(ModeInfo * mi)
{
int i;
turtlestruct *tp;
if (turtles == NULL) {
if ((turtles = (turtlestruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (turtlestruct))) == NULL)
return;
}
tp = &turtles[MI_SCREEN(mi)];
tp->width = MI_WIDTH(mi);
tp->height = MI_HEIGHT(mi);
tp->min = MIN(tp->width, tp->height);
tp->maxlevel = 0;
i = tp->min;
do {
tp->r = i;
tp->maxlevel++;
i = (tp->min - 1) / (1 << tp->maxlevel);
} while (i > 1);
tp->maxlevel--;
tp->r = tp->min = (tp->r << tp->maxlevel);
tp->width = MAX(tp->width, tp->min + 1);
tp->height = MAX(tp->height, tp->min + 1);
tp->curve = NRAND(TURTLE_CURVES);
switch (tp->curve) {
case HILBERT:
tp->start.x = NRAND(tp->width - tp->min);
tp->start.y = NRAND(tp->height - tp->min);
break;
case CESARO_VAR:
tp->r <<= 6;
tp->min = 3 * tp->min / 4;
tp->start.x = tp->width / 2;
tp->start.y = tp->height / 2;
switch (NRAND(4)) {
case 0:
tp->pt1.x = -tp->min / 2;
tp->pt1.y = 0;
tp->pt2.x = tp->min / 2;
tp->pt2.y = 0;
tp->start.y -= tp->min / 6;
break;
case 1:
tp->pt1.x = 0;
tp->pt1.y = -tp->min / 2;
tp->pt2.x = 0;
tp->pt2.y = tp->min / 2;
tp->start.x += tp->min / 6;
break;
case 2:
tp->pt1.x = tp->min / 2;
tp->pt1.y = 0;
tp->pt2.x = -tp->min / 2;
tp->pt2.y = 0;
tp->start.y += tp->min / 6;
break;
case 3:
tp->pt1.x = 0;
tp->pt1.y = tp->min / 2;
tp->pt2.x = 0;
tp->pt2.y = -tp->min / 2;
tp->start.x -= tp->min / 6;
break;
}
break;
case HARTER_HEIGHTWAY:
tp->r <<= 6;
tp->min = 3 * tp->min / 4;
tp->start.x = tp->width / 2;
tp->start.y = tp->height / 2;
switch (NRAND(4)) {
case 0:
tp->pt1.x = -tp->min / 2;
tp->pt1.y = -tp->min / 12;
tp->pt2.x = tp->min / 2;
tp->pt2.y = -tp->min / 12;
break;
case 1:
tp->pt1.x = tp->min / 12;
tp->pt1.y = -tp->min / 2;
tp->pt2.x = tp->min / 12;
tp->pt2.y = tp->min / 2;
break;
case 2:
tp->pt1.x = tp->min / 2;
tp->pt1.y = tp->min / 12;
tp->pt2.x = -tp->min / 2;
tp->pt2.y = tp->min / 12;
break;
case 3:
tp->pt1.x = -tp->min / 12;
tp->pt1.y = tp->min / 2;
tp->pt2.x = -tp->min / 12;
tp->pt2.y = -tp->min / 2;
break;
}
}
tp->level = 0;
tp->sign = 1;
tp->dir = NRAND(4);
tp->time = 0;
MI_CLEARWINDOW(mi);
if (MI_NPIXELS(mi) <= 2)
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi));
}
ENTRYPOINT void
init_gears (ModeInfo *mi)
{
gears_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
int i;
if (!bps) {
bps = (gears_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (gears_configuration));
if (!bps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_gears (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
if (!wire)
{
GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
}
{
double spin_speed = 0.5;
double wander_speed = 0.01;
double spin_accel = 0.25;
bp->rot = make_rotator (do_spin ? spin_speed : 0,
do_spin ? spin_speed : 0,
do_spin ? spin_speed : 0,
spin_accel,
do_wander ? wander_speed : 0,
True
);
bp->trackball = gltrackball_init ();
}
if (!(random() % 8))
{
planetary_gears (mi);
}
else
{
gear *g = 0;
int total_gears = MI_COUNT (mi);
int i;
if (total_gears <= 0)
total_gears = 3 + abs (BELLRAND (8) - 4); /* 3 - 7, mostly 3. */
bp->gears = (gear **) calloc (total_gears+2, sizeof(**bp->gears));
bp->ngears = 0;
for (i = 0; i < total_gears; i++)
g = place_new_gear (mi, g);
}
/* Center gears in scene. */
{
GLfloat minx=99999, miny=99999, maxx=-99999, maxy=-99999;
int i;
for (i = 0; i < bp->ngears; i++)
{
gear *g = bp->gears[i];
if (g->x - g->r < minx) minx = g->x - g->r;
if (g->x + g->r > maxx) maxx = g->x + g->r;
if (g->y - g->r < miny) miny = g->y - g->r;
if (g->y + g->r > maxy) maxy = g->y + g->r;
}
bp->bbox.x1 = minx;
bp->bbox.y1 = miny;
bp->bbox.x2 = maxx;
bp->bbox.y2 = maxy;
}
/* Now render each gear into its display list.
*/
for (i = 0; i < bp->ngears; i++)
{
gear *g = bp->gears[i];
g->dlist = glGenLists (1);
if (! g->dlist)
{
check_gl_error ("glGenLists");
abort();
}
glNewList (g->dlist, GL_COMPILE);
g->polygons += draw_involute_gear (g, wire);
glEndList ();
}
if (bp->planetary_p)
armature (mi);
}
ENTRYPOINT void init_jigglypuff(ModeInfo *mi)
{
jigglystruct *js;
int subdivs;
if(!jss) {
jss = (jigglystruct*)
calloc(MI_NUM_SCREENS(mi), sizeof(jigglystruct));
if(!jss) {
fprintf(stderr, "%s: No..memory...must...abort..\n", progname);
exit(1);
}
}
js = &jss[MI_SCREEN(mi)];
js->do_wireframe = MI_IS_WIREFRAME(mi);
# ifdef HAVE_JWZGLES
js->do_wireframe = 0; /* GL_LINE unimplemented */
# endif
js->shininess = shininess;
subdivs = (complexity==1) ? 4 : (complexity==2) ? 5
: (complexity==3) ? 6 : 5;
js->spooky = spooky << (subdivs-3);
if(!parse_color(js)) {
fprintf(stderr, "%s: Bad color specification: '%s'.\n", progname, color);
exit(-1);
}
if(random_parms)
randomize_parameters(js);
js->angle = frand(180);
js->axis = frand(M_PI);
js->shape = tesselated_tetrahedron(1, subdivs, js);
if(!do_tetrahedron)
solid_spherify(js->shape, 1);
if(js->color_style == COLOR_STYLE_CLOWNBARF)
clownbarf_colorize(js->shape);
calculate_parameters(js, subdivs);
if((js->glx_context = init_GL(mi)) != NULL) {
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(js->glx_context));
setup_opengl(mi, js);
reshape_jigglypuff(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
else {
MI_CLEARWINDOW(mi);
}
js->trackball = gltrackball_init();
/* _DEBUG("distance : %f\nhold : %f\nspherify : %f\ndamping : %f\ndfact : %f\n",
js->stable_distance, js->hold_strength, js->spherify_strength,
js->damping_velocity, js->damping_factor);
_DEBUG("wire : %d\nspooky : %d\nstyle : %d\nshininess : %d\n",
js->do_wireframe, js->spooky, js->color_style, js->shininess);*/
}
ENTRYPOINT void init_projectiveplane(ModeInfo *mi)
{
projectiveplanestruct *pp;
if (projectiveplane == NULL)
{
projectiveplane =
(projectiveplanestruct *)calloc(MI_NUM_SCREENS(mi),
sizeof(projectiveplanestruct));
if (projectiveplane == NULL)
return;
}
pp = &projectiveplane[MI_SCREEN(mi)];
pp->trackballs[0] = gltrackball_init(True);
pp->trackballs[1] = gltrackball_init(True);
pp->current_trackball = 0;
pp->button_pressed = False;
/* Set the display mode. */
if (!strcasecmp(mode,"random"))
{
display_mode = random() % NUM_DISPLAY_MODES;
}
else if (!strcasecmp(mode,"wireframe"))
{
display_mode = DISP_WIREFRAME;
}
else if (!strcasecmp(mode,"surface"))
{
display_mode = DISP_SURFACE;
}
else if (!strcasecmp(mode,"transparent"))
{
display_mode = DISP_TRANSPARENT;
}
else
{
display_mode = random() % NUM_DISPLAY_MODES;
}
/* Orientation marks don't make sense in wireframe mode. */
if (display_mode == DISP_WIREFRAME)
marks = False;
/* Set the appearance. */
if (!strcasecmp(appear,"random"))
{
appearance = random() % NUM_APPEARANCES;
}
else if (!strcasecmp(appear,"solid"))
{
appearance = APPEARANCE_SOLID;
}
else if (!strcasecmp(appear,"distance-bands"))
{
appearance = APPEARANCE_DISTANCE_BANDS;
}
else if (!strcasecmp(appear,"direction-bands"))
{
appearance = APPEARANCE_DIRECTION_BANDS;
}
else
{
appearance = random() % NUM_APPEARANCES;
}
/* Set the color mode. */
if (!strcasecmp(color_mode,"random"))
{
colors = random() % NUM_COLORS;
}
else if (!strcasecmp(color_mode,"two-sided"))
{
colors = COLORS_TWOSIDED;
}
else if (!strcasecmp(color_mode,"distance"))
{
colors = COLORS_DISTANCE;
}
else if (!strcasecmp(color_mode,"direction"))
{
colors = COLORS_DIRECTION;
}
else if (!strcasecmp(color_mode,"depth"))
{
colors = COLORS_DEPTH;
}
else
{
colors = random() % NUM_COLORS;
}
/* Set the view mode. */
if (!strcasecmp(view_mode,"random"))
{
view = random() % NUM_VIEW_MODES;
}
else if (!strcasecmp(view_mode,"walk"))
{
view = VIEW_WALK;
}
else if (!strcasecmp(view_mode,"turn"))
{
view = VIEW_TURN;
}
else if (!strcasecmp(view_mode,"walk-turn"))
{
view = VIEW_WALKTURN;
}
else
{
view = random() % NUM_VIEW_MODES;
}
/* Set the 3d projection mode. */
if (!strcasecmp(proj_3d,"random"))
{
/* Orthographic projection only makes sense in turn mode. */
if (view == VIEW_TURN)
projection_3d = random() % NUM_DISP_3D_MODES;
else
projection_3d = DISP_3D_PERSPECTIVE;
}
else if (!strcasecmp(proj_3d,"perspective"))
{
projection_3d = DISP_3D_PERSPECTIVE;
}
else if (!strcasecmp(proj_3d,"orthographic"))
{
projection_3d = DISP_3D_ORTHOGRAPHIC;
}
else
{
/* Orthographic projection only makes sense in turn mode. */
if (view == VIEW_TURN)
projection_3d = random() % NUM_DISP_3D_MODES;
else
projection_3d = DISP_3D_PERSPECTIVE;
}
/* Set the 4d projection mode. */
if (!strcasecmp(proj_4d,"random"))
{
projection_4d = random() % NUM_DISP_4D_MODES;
}
else if (!strcasecmp(proj_4d,"perspective"))
{
projection_4d = DISP_4D_PERSPECTIVE;
}
else if (!strcasecmp(proj_4d,"orthographic"))
{
projection_4d = DISP_4D_ORTHOGRAPHIC;
}
else
{
projection_4d = random() % NUM_DISP_4D_MODES;
}
/* Modify the speeds to a useful range in walk-and-turn mode. */
if (view == VIEW_WALKTURN)
{
speed_wx *= 0.2;
speed_wy *= 0.2;
speed_wz *= 0.2;
speed_xy *= 0.2;
speed_xz *= 0.2;
speed_yz *= 0.2;
}
/* make multiple screens rotate at slightly different rates. */
pp->speed_scale = 0.9 + frand(0.3);
if ((pp->glx_context = init_GL(mi)) != NULL)
{
reshape_projectiveplane(mi,MI_WIDTH(mi),MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
init(mi);
}
else
{
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_logo (ModeInfo *mi)
{
logo_configuration *dc;
int do_gasket = get_boolean_resource(mi->dpy, "doGasket", "Boolean");
int do_helix = get_boolean_resource(mi->dpy, "doHelix", "Boolean");
int do_ladder = do_helix && get_boolean_resource(mi->dpy, "doLadder", "Boolean");
if (!do_gasket && !do_helix)
{
fprintf (stderr, "%s: no helix or gasket?\n", progname);
exit (1);
}
if (!dcs) {
dcs = (logo_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (logo_configuration));
if (!dcs) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
dc = &dcs[MI_SCREEN(mi)];
if ((dc->glx_context = init_GL(mi)) != NULL) {
gl_init(mi);
reshape_logo (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
dc->wall_facets = get_integer_resource(mi->dpy, "wallFacets", "Integer");
dc->tube_facets = get_integer_resource(mi->dpy, "tubeFacets", "Integer");
dc->clockwise = get_boolean_resource(mi->dpy, "clockwise", "Boolean");
dc->turns = get_float_resource(mi->dpy, "turns", "Float");
dc->turn_spacing = get_float_resource(mi->dpy, "turnSpacing", "Float");
dc->bar_spacing = get_float_resource(mi->dpy, "barSpacing", "Float");
dc->wall_height = get_float_resource(mi->dpy, "wallHeight", "Float");
dc->wall_thickness = get_float_resource(mi->dpy, "wallThickness", "Float");
dc->tube_thickness = get_float_resource(mi->dpy, "tubeThickness", "Float");
dc->wall_taper = get_float_resource(mi->dpy, "wallTaper", "Float");
dc->gasket_size = get_float_resource(mi->dpy, "gasketSize", "Float");
dc->gasket_depth = get_float_resource(mi->dpy, "gasketDepth", "Float");
dc->gasket_thickness = get_float_resource(mi->dpy, "gasketThickness", "Float");
dc->speed = get_float_resource(mi->dpy, "speed", "Float");
{
XColor xcolor;
char *color_name = get_string_resource (mi->dpy, "foreground", "Foreground");
char *s2;
for (s2 = color_name + strlen(color_name) - 1; s2 > color_name; s2--)
if (*s2 == ' ' || *s2 == '\t')
*s2 = 0;
else
break;
if (! XParseColor (MI_DISPLAY(mi), mi->xgwa.colormap, color_name, &xcolor))
{
fprintf (stderr, "%s: can't parse color %s\n", progname, color_name);
exit (1);
}
dc->color[0] = xcolor.red / 65535.0;
dc->color[1] = xcolor.green / 65535.0;
dc->color[2] = xcolor.blue / 65535.0;
dc->color[3] = 1.0;
}
dc->trackball = gltrackball_init ();
dc->gasket_spinnery.probability = 0.1;
dc->gasket_spinnerx.probability = 0.1;
dc->gasket_spinnerz.probability = 1.0;
dc->helix_spinnerz.probability = 0.6;
dc->scene_spinnerx.probability = 0.1;
dc->scene_spinnery.probability = 0.0;
if (dc->speed > 0) /* start off with the gasket in motion */
{
dc->gasket_spinnerz.spinning_p = True;
dc->gasket_spinnerz.speed = (0.002
* ((random() & 1) ? 1 : -1)
* dc->speed);
}
glPushMatrix();
dc->helix_list = glGenLists (1);
glNewList (dc->helix_list, GL_COMPILE);
glRotatef(126, 0, 0, 1);
if (do_ladder) make_ladder (dc, 0, 0);
if (do_helix) make_helix (dc, 0, 0);
glRotatef(180, 0, 0, 1);
if (do_helix) make_helix (dc, 0, 0);
glEndList ();
glPopMatrix();
glPushMatrix();
dc->helix_list_wire = glGenLists (1);
glNewList (dc->helix_list_wire, GL_COMPILE);
/* glRotatef(126, 0, 0, 1); wtf? */
if (do_ladder) make_ladder (dc, 1, 1);
if (do_helix) make_helix (dc, 1, 1);
glRotatef(180, 0, 0, 1);
if (do_helix) make_helix (dc, 1, 1);
glEndList ();
glPopMatrix();
glPushMatrix();
dc->helix_list_facetted = glGenLists (1);
glNewList (dc->helix_list_facetted, GL_COMPILE);
glRotatef(126, 0, 0, 1);
if (do_ladder) make_ladder (dc, 1, 0);
if (do_helix) make_helix (dc, 1, 0);
glRotatef(180, 0, 0, 1);
if (do_helix) make_helix (dc, 1, 0);
glEndList ();
glPopMatrix();
dc->gasket_list = glGenLists (1);
glNewList (dc->gasket_list, GL_COMPILE);
if (do_gasket) make_gasket (dc, 0);
glEndList ();
dc->gasket_list_wire = glGenLists (1);
glNewList (dc->gasket_list_wire, GL_COMPILE);
if (do_gasket) make_gasket (dc, 1);
glEndList ();
/* When drawing both solid and wireframe objects,
make sure the wireframe actually shows up! */
glEnable (GL_POLYGON_OFFSET_FILL);
glPolygonOffset (1.0, 1.0);
}
/*-
* init_swirl
*
* Initialise things for swirling
*
* - win is the window to draw in
*/
void
init_swirl(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
swirlstruct *sp;
/* does the swirls array exist? */
if (swirls == NULL) {
int i;
/* allocate an array, one entry for each screen */
if ((swirls = (swirlstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (swirlstruct))) == NULL)
return;
/* initialise them all */
for (i = 0; i < MI_NUM_SCREENS(mi); i++)
initialise_swirl(&swirls[i]);
}
/* get a pointer to this swirl */
sp = &(swirls[MI_SCREEN(mi)]);
sp->mi = mi;
/* get window parameters */
sp->width = MI_WIDTH(mi);
sp->height = MI_HEIGHT(mi);
sp->depth = MI_DEPTH(mi);
sp->rdepth = sp->depth;
sp->visual = MI_VISUAL(mi);
if (sp->depth > 16)
sp->depth = 16;
/* initialise image for speeding up drawing */
if (!initialise_image(display, sp)) {
free_swirl(display, sp);
return;
}
MI_CLEARWINDOW(mi);
if (!sp->gc) {
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XColor color;
#ifndef STANDALONE
sp->fg = MI_FG_PIXEL(mi);
sp->bg = MI_BG_PIXEL(mi);
#endif
sp->blackpixel = MI_BLACK_PIXEL(mi);
sp->whitepixel = MI_WHITE_PIXEL(mi);
if ((sp->cmap = XCreateColormap(display, window,
MI_VISUAL(mi), AllocNone)) == None) {
free_swirl(display, sp);
return;
}
XSetWindowColormap(display, window, sp->cmap);
(void) XParseColor(display, sp->cmap, "black", &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_BLACK_PIXEL(mi) = color.pixel;
(void) XParseColor(display, sp->cmap, "white", &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_WHITE_PIXEL(mi) = color.pixel;
#ifndef STANDALONE
(void) XParseColor(display, sp->cmap, background, &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_BG_PIXEL(mi) = color.pixel;
(void) XParseColor(display, sp->cmap, foreground, &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_FG_PIXEL(mi) = color.pixel;
#endif
sp->colors = (XColor *) NULL;
sp->ncolors = 0;
}
if ((sp->gc = XCreateGC(display, MI_WINDOW(mi),
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_swirl(display, sp);
return;
}
}
MI_CLEARWINDOW(mi);
/* Set up colour map */
sp->direction = (LRAND() & 1) ? 1 : -1;
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (sp->colors != NULL) {
if (sp->ncolors && !sp->no_colors)
free_colors(display, sp->cmap, sp->colors, sp->ncolors);
free(sp->colors);
sp->colors = (XColor *) NULL;
}
sp->ncolors = MI_NCOLORS(mi);
if (sp->ncolors < 2)
sp->ncolors = 2;
if (sp->ncolors <= 2)
sp->mono_p = True;
else
sp->mono_p = False;
if (sp->mono_p)
sp->colors = (XColor *) NULL;
else
if ((sp->colors = (XColor *) malloc(sizeof (*sp->colors) *
(sp->ncolors + 1))) == NULL) {
free_swirl(display, sp);
return;
}
sp->cycle_p = has_writable_cells(mi);
if (sp->cycle_p) {
if (MI_IS_FULLRANDOM(mi)) {
if (!NRAND(8))
sp->cycle_p = False;
else
sp->cycle_p = True;
} else {
sp->cycle_p = cycle_p;
}
}
if (!sp->mono_p) {
if (!(LRAND() % 10))
make_random_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, True, &sp->cycle_p);
else if (!(LRAND() % 2))
make_uniform_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, &sp->cycle_p);
else
make_smooth_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, &sp->cycle_p);
}
XInstallColormap(display, sp->cmap);
if (sp->ncolors < 2) {
sp->ncolors = 2;
sp->no_colors = True;
} else
sp->no_colors = False;
if (sp->ncolors <= 2)
sp->mono_p = True;
if (sp->mono_p)
sp->cycle_p = False;
}
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (sp->mono_p) {
sp->cur_color = MI_BLACK_PIXEL(mi);
}
}
/* resolution starts off chunky */
sp->resolution = MIN_RES + 1;
/* calculate the pixel step for this resulution */
sp->r = (1 << (sp->resolution - 1));
/* how many knots? */
sp->n_knots = random_no((unsigned int) MI_COUNT(mi) / 2) +
MI_COUNT(mi) + 1;
/* what type of knots? */
sp->knot_type = ALL; /* for now */
/* use two_plane mode occaisionally */
if (random_no(100) <= TWO_PLANE_PCNT) {
sp->two_plane = sp->first_plane = True;
sp->max_resolution = 2;
} else
sp->two_plane = False;
/* fix the knot values */
if (!create_knots(sp)) {
free_swirl(display, sp);
return;
}
/* we are off */
sp->started = True;
sp->drawing = False;
}
ENTRYPOINT void
init_planet (ModeInfo * mi)
{
planetstruct *gp;
int screen = MI_SCREEN(mi);
Bool wire = MI_IS_WIREFRAME(mi);
if (planets == NULL) {
if ((planets = (planetstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (planetstruct))) == NULL)
return;
}
gp = &planets[screen];
if ((gp->glx_context = init_GL(mi)) != NULL) {
reshape_planet(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
{
char *f = get_string_resource(mi->dpy, "imageForeground", "Foreground");
char *b = get_string_resource(mi->dpy, "imageBackground", "Background");
char *s;
if (!f) f = strdup("white");
if (!b) b = strdup("black");
for (s = f + strlen(f)-1; s > f; s--)
if (*s == ' ' || *s == '\t')
*s = 0;
for (s = b + strlen(b)-1; s > b; s--)
if (*s == ' ' || *s == '\t')
*s = 0;
if (!XParseColor(mi->dpy, mi->xgwa.colormap, f, &gp->fg))
{
fprintf(stderr, "%s: unparsable color: \"%s\"\n", progname, f);
exit(1);
}
if (!XParseColor(mi->dpy, mi->xgwa.colormap, b, &gp->bg))
{
fprintf(stderr, "%s: unparsable color: \"%s\"\n", progname, f);
exit(1);
}
free (f);
free (b);
}
{
double spin_speed = 0.1;
double wander_speed = 0.005;
gp->rot = make_rotator (do_roll ? spin_speed : 0,
do_roll ? spin_speed : 0,
0, 1,
do_wander ? wander_speed : 0,
True);
gp->z = frand (1.0);
gp->tilt = frand (23.4);
gp->trackball = gltrackball_init (True);
}
if (wire)
do_texture = False;
if (do_texture)
setup_texture (mi);
if (do_stars)
init_stars (mi);
/* construct the polygons of the planet
*/
gp->platelist = glGenLists(1);
glNewList (gp->platelist, GL_COMPILE);
glFrontFace(GL_CCW);
glPushMatrix();
glRotatef (90, 1, 0, 0);
unit_sphere (resolution, resolution, wire);
glPopMatrix();
glEndList();
gp->shadowlist = glGenLists(1);
glNewList (gp->shadowlist, GL_COMPILE);
glFrontFace(GL_CCW);
unit_dome (resolution, resolution, wire);
glEndList();
/* construct the polygons of the latitude/longitude/axis lines.
*/
gp->latlonglist = glGenLists(1);
glNewList (gp->latlonglist, GL_COMPILE);
glPushMatrix ();
glRotatef (90, 1, 0, 0); /* unit_sphere is off by 90 */
glRotatef (8, 0, 1, 0); /* line up the time zones */
unit_sphere (12, 24, 1);
unit_sphere (12, 24, 1);
glBegin(GL_LINES);
glVertex3f(0, -2, 0);
glVertex3f(0, 2, 0);
glEnd();
glPopMatrix ();
glEndList();
}
void
init_dragon(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int size = MI_SIZE(mi);
dragonstruct *dp;
if (dragons == NULL) {
if ((dragons = (dragonstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (dragonstruct))) == NULL)
return;
}
dp = &dragons[MI_SCREEN(mi)];
dp->generation = 0;
dp->redrawing = 0;
if (MI_NPIXELS(mi) <= 2) {
if (dp->stippledGC == None) {
XGCValues gcv;
gcv.fill_style = FillOpaqueStippled;
if ((dp->stippledGC = XCreateGC(display, window,
GCFillStyle, &gcv)) == None) {
free_dragon(display, dp);
return;
}
}
if (dp->graypix == None) {
if ((dp->graypix = XCreateBitmapFromData(display, window,
(char *) gray1_bits, gray1_width, gray1_height)) == None) {
free_dragon(display, dp);
return;
}
}
}
free_struct(dp);
if (MI_NPIXELS(mi) > 2)
dp->color = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
if ((dp->cellList = (CellList **) calloc(STATES,
sizeof (CellList *))) == NULL) {
free_dragon(display, dp);
return;
}
if ((dp->ncells = (int *) calloc(STATES, sizeof (int))) == NULL) {
free_dragon(display, dp);
return;
}
dp->addlist = 0;
if (MI_IS_FULLRANDOM(mi)) {
dp->vertical = (Bool) (LRAND() & 1);
} else {
dp->vertical = vertical;
}
dp->width = MI_WIDTH(mi);
dp->height = MI_HEIGHT(mi);
{
int nccols, ncrows, i;
if (!dp->vertical) {
dp->height = MI_WIDTH(mi);
dp->width = MI_HEIGHT(mi);
}
if (dp->width < 8)
dp->width = 8;
if (dp->height < 8)
dp->height = 8;
if (size < -MINSIZE)
dp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
dp->ys = MAX(MINSIZE, MIN(dp->width, dp->height) / MINGRIDSIZE);
else
dp->ys = MINSIZE;
} else
dp->ys = MIN(size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE));
dp->xs = dp->ys;
nccols = MAX(dp->width / dp->xs - 2, 2);
ncrows = MAX(dp->height / dp->ys - 1, 4);
dp->ncols = nccols / 2;
dp->nrows = 2 * (ncrows / 4);
dp->xb = (dp->width - dp->xs * nccols) / 2 + dp->xs / 2;
dp->yb = (dp->height - dp->ys * (ncrows / 2) * 2) / 2 -
dp->ys / 4;
for (i = 0; i < 6; i++) {
if (dp->vertical) {
dp->hexagon[i].x =
dp->xs * hexagonUnit[i].x;
dp->hexagon[i].y =
((dp->ys + 1) * hexagonUnit[i].y /
2) * 4 / 3;
} else {
dp->hexagon[i].y =
dp->xs * hexagonUnit[i].x;
dp->hexagon[i].x =
((dp->ys + 1) * hexagonUnit[i].y /
2) * 4 / 3;
}
}
}
MI_CLEARWINDOW(mi);
if ((dp->oldcell = (unsigned char *)
calloc(dp->ncols * dp->nrows,
sizeof (unsigned char))) == NULL) {
free_dragon(display, dp);
return;
}
if (!SetSoup(mi)) {
free_dragon(display, dp);
return;
}
}
/* Called to init the mode. */
void
init_penrose(ModeInfo * mi)
{
tiling_c *tp;
fringe_node_c *fp;
int i, size;
if (tilings == NULL) {
if ((tilings = (tiling_c *) calloc(MI_NUM_SCREENS(mi),
sizeof (tiling_c))) == NULL)
return;
}
tp = &tilings[MI_SCREEN(mi)];
if (MI_IS_FULLRANDOM(mi))
tp->ammann = (Bool) (LRAND() & 1);
else
tp->ammann = ammann;
tp->done = False;
tp->busyLoop = 0;
tp->failures = 0;
tp->width = MI_WIDTH(mi);
tp->height = MI_HEIGHT(mi);
if (MI_NPIXELS(mi) > 2) {
tp->thick_color = NRAND(MI_NPIXELS(mi));
/* Insure good contrast */
tp->thin_color = (NRAND(2 * MI_NPIXELS(mi) / 3) + tp->thick_color +
MI_NPIXELS(mi) / 6) % MI_NPIXELS(mi);
} else {
if (LRAND() & 1) {
tp->thick_color = MI_WHITE_PIXEL(mi);
tp->thin_color = MI_BLACK_PIXEL(mi);
} else {
tp->thick_color = MI_BLACK_PIXEL(mi);
tp->thin_color = MI_WHITE_PIXEL(mi);
}
}
size = MI_SIZE(mi);
if (size < -MINSIZE)
tp->edge_length = NRAND(MIN(-size, MAX(MINSIZE,
MIN(tp->width, tp->height) / 2)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
tp->edge_length = MAX(MINSIZE, MIN(tp->width, tp->height) / 2);
else
tp->edge_length = MINSIZE;
} else
tp->edge_length = MIN(size, MAX(MINSIZE,
MIN(tp->width, tp->height) / 2));
tp->origin.x = (tp->width / 2 + NRAND(tp->width)) / 2;
tp->origin.y = (tp->height / 2 + NRAND(tp->height)) / 2;
tp->fringe.n_nodes = 2;
if (tp->fringe.nodes != NULL)
free_penrose(tp);
if (tp->fringe.nodes != NULL || tp->forced.first != 0) {
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr, "Weirdness in init_penrose()\n");
(void) fprintf(stderr, "tp->fringe.nodes = NULL && tp->forced.first = 0\n");
}
free_penrose(tp); /* Try again */
tp->done = True;
}
tp->forced.n_nodes = tp->forced.n_visible = 0;
if ((fp = tp->fringe.nodes = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
if (fp == 0) {
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr, "Weirdness in init_penrose()\n");
(void) fprintf(stderr, "fp = 0\n");
}
if ((fp = tp->fringe.nodes = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
tp->done = True;
}
/* First vertex. */
fp->rule_mask = (1 << N_VERTEX_RULES) - 1;
fp->list_ptr = 0;
if ((fp->prev = fp->next = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
if (fp->next == 0) {
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr, "Weirdness in init_penrose()\n");
(void) fprintf(stderr, "fp->next = 0\n");
}
if ((fp->prev = fp->next = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
tp->done = True;
}
fp->n_tiles = 0;
fp->loc = tp->origin;
fp->off_screen = False;
for (i = 0; i < 5; i++)
fp->fived[i] = 0;
/* Second vertex. */
*(fp->next) = *fp;
fp->next->prev = fp->next->next = fp;
fp = fp->next;
i = NRAND(5);
fp->fived[i] = 2 * NRAND(2) - 1;
fived_to_loc(fp->fived, tp, &(fp->loc));
/* That's it! We have created our first edge. */
}
ENTRYPOINT void
init_sonar (ModeInfo *mi)
{
sonar_configuration *sp;
int wire = MI_IS_WIREFRAME(mi);
if (!sps) {
sps = (sonar_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (sonar_configuration));
if (!sps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
sp = &sps[MI_SCREEN(mi)];
sp->glx_context = init_GL(mi);
reshape_sonar (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */
if (!wire)
{
GLfloat pos[4] = {0.05, 0.07, 1.00, 0.0};
GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0};
GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};
glEnable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glShadeModel(GL_SMOOTH);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
}
sp->trackball = gltrackball_init ();
sp->rot = make_rotator (0, 0, 0, 0, speed * 0.003, True);
sp->texfont = load_texture_font (MI_DISPLAY(mi), "font");
check_gl_error ("loading font");
sp->table_list = glGenLists (1);
glNewList (sp->table_list, GL_COMPILE);
sp->table_polys = draw_table (mi);
glEndList ();
sp->screen_list = glGenLists (1);
glNewList (sp->screen_list, GL_COMPILE);
sp->screen_polys = draw_screen (mi, False, False);
glEndList ();
sp->grid_list = glGenLists (1);
glNewList (sp->grid_list, GL_COMPILE);
sp->grid_polys = draw_screen (mi, True, False);
glEndList ();
sp->sweep_list = glGenLists (1);
glNewList (sp->sweep_list, GL_COMPILE);
sp->sweep_polys = draw_screen (mi, False, True);
glEndList ();
sp->start_time = double_time ();
sp->sweep_offset = random() % 60;
sp->sweep_th = -1;
}
ENTRYPOINT void
init_fliptext (ModeInfo *mi)
{
int wire = MI_IS_WIREFRAME(mi);
fliptext_configuration *sc;
if (!scs) {
scs = (fliptext_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (fliptext_configuration));
if (!scs) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
sc = &scs[MI_SCREEN(mi)];
sc->lines = (line **) calloc (max_lines+1, sizeof(char *));
}
sc = &scs[MI_SCREEN(mi)];
sc->dpy = MI_DISPLAY(mi);
if ((sc->glx_context = init_GL(mi)) != NULL) {
reshape_fliptext (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
program = get_string_resource (mi->dpy, "program", "Program");
{
int cw, lh;
sc->texfont = load_texture_font (MI_DISPLAY(mi), "font");
check_gl_error ("loading font");
cw = texture_string_width (sc->texfont, "n", &lh);
sc->char_width = cw;
sc->line_height = lh;
}
if (!wire)
{
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
glEnable (GL_ALPHA_TEST);
glEnable (GL_TEXTURE_2D);
/* "Anistropic filtering helps for quadrilateral-angled textures.
A sharper image is accomplished by interpolating and filtering
multiple samples from one or more mipmaps to better approximate
very distorted textures. This is the next level of filtering
after trilinear filtering." */
if (strstr ((char *) glGetString(GL_EXTENSIONS),
"GL_EXT_texture_filter_anisotropic"))
{
GLfloat anisotropic = 0.0;
glGetFloatv (GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropic);
if (anisotropic >= 1.0)
glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
anisotropic);
}
}
/* The default font is (by fiat) "18 points".
Interpret the user's font size request relative to that.
*/
sc->font_scale = 3 * (font_size / 18.0);
if (target_columns <= 2) target_columns = 2;
/* Figure out what the wrap column should be, in font-coordinate pixels.
Compute it from the given -columns value, but don't let it be wider
than the screen.
*/
{
GLfloat maxw = 110 * sc->line_height / sc->font_scale; /* magic... */
sc->font_wrap_pixels = target_columns * sc->char_width;
if (sc->font_wrap_pixels > maxw ||
sc->font_wrap_pixels <= 0)
sc->font_wrap_pixels = maxw;
}
sc->buf_size = target_columns * max_lines;
sc->buf = (char *) calloc (1, sc->buf_size);
sc->subproc_relaunch_delay = 2 * 1000; /* 2 seconds */
alignment_random_p = False;
if (!alignment_str || !*alignment_str ||
!strcasecmp(alignment_str, "left"))
alignment = -1;
else if (!strcasecmp(alignment_str, "center") ||
!strcasecmp(alignment_str, "middle"))
alignment = 0;
else if (!strcasecmp(alignment_str, "right"))
alignment = 1;
else if (!strcasecmp(alignment_str, "random"))
alignment = -1, alignment_random_p = True;
else
{
fprintf (stderr,
"%s: alignment must be left/center/right/random, not \"%s\"\n",
progname, alignment_str);
exit (1);
}
launch_text_generator (sc);
if (max_lines < 1) max_lines = 1;
min_lines = max_lines * 0.66;
if (min_lines > max_lines - 3) min_lines = max_lines - 4;
if (min_lines < 1) min_lines = 1;
parse_color (mi, "foreground",
get_string_resource(mi->dpy, "foreground", "Foreground"),
sc->color);
sc->top_margin = (sc->char_width * 100);
sc->bottom_margin = -sc->top_margin;
reshape_fliptext (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); /* compute left/right */
}
