ENTRYPOINT void
init_boxed(ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
/* Colormap cmap; */
/* Boolean rgba, doublebuffer, cmap_installed; */
boxedstruct *gp;
MI_INIT(mi, boxed, free_boxed);
gp = &boxed[screen];
gp->window = MI_WINDOW(mi);
if ((gp->glx_context = init_GL(mi)) != NULL) {
reshape_boxed(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
if (!glIsList(gp->listobjects)) {
gp->listobjects = glGenLists(3);
gp->gllists[0] = 0;
gp->gllists[1] = 0;
gp->gllists[2] = 0;
}
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_voronoi (ModeInfo *mi)
{
voronoi_configuration *vp;
MI_INIT (mi, vps);
vp = &vps[MI_SCREEN(mi)];
vp->glx_context = init_GL(mi);
vp->point_size = point_size;
if (vp->point_size < 0) vp->point_size = 10;
if (MI_WIDTH(mi) > 2560) vp->point_size *= 2; /* Retina displays */
vp->ncolors = 128;
vp->colors = (XColor *) calloc (vp->ncolors, sizeof(XColor));
make_smooth_colormap (0, 0, 0,
vp->colors, &vp->ncolors,
False, False, False);
reshape_voronoi (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
vp->mode = MODE_ADDING;
vp->adding = npoints * 2;
vp->last_time = 0;
}
ENTRYPOINT void init_providence(ModeInfo *mi)
{
providencestruct *mp;
MI_INIT(mi, providence);
mp = &providence[MI_SCREEN(mi)];
mp->trackball = gltrackball_init (False);
mp->position0[0] = 1;
mp->position0[1] = 5;
mp->position0[2] = 1;
mp->position0[3] = 1;
mp->camera_velocity = -8.0;
mp->mono = MI_IS_MONO(mi);
mp->wire = MI_IS_WIREFRAME(mi);
# ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */
mp->wire = 0;
# endif
/* make multiple screens rotate at slightly different rates. */
mp->theta_scale = 0.7 + frand(0.6);
if((mp->glx_context = init_GL(mi)) != NULL) {
reshape_providence(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
/* glDrawBuffer(GL_BACK); */
pinit(mp);
}
else
MI_CLEARWINDOW(mi);
}
ENTRYPOINT void init_cube21(ModeInfo *mi)
{
cube21_conf *cp;
MI_INIT(mi, cube21);
cp = &cube21[MI_SCREEN(mi)];
cp->trackball = gltrackball_init (False);
if(!cp->texp) {
init_posc(cp);
make_texture(cp);
}
#ifdef HAVE_MOBILE
size *= 2;
#endif
if ((cp->glx_context = init_GL(mi)) != NULL) {
init_gl(mi);
init_cp(cp);
reshape_cube21(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void init_queens(ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
Queenscreen *qs;
int poly_counts[PIECES];
wire = MI_IS_WIREFRAME(mi);
# ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */
wire = 0;
# endif
MI_INIT (mi, qss, NULL);
qs = &qss[screen];
qs->window = MI_WINDOW(mi);
if((qs->glx_context = init_GL(mi)))
reshape_queens(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
else
MI_CLEARWINDOW(mi);
qs->trackball = gltrackball_init (False);
qs->BOARDSIZE = 8; /* 8 cuz its classic */
chessmodels_gen_lists(-1, poly_counts);
qs->queen_list = QUEEN;
qs->queen_polys = poly_counts[QUEEN];
/* find a solution */
go(qs);
}
ENTRYPOINT void
init_stairs (ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
stairsstruct *sp;
MI_INIT (mi, stairs);
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);
}
ENTRYPOINT void
init_cube (ModeInfo *mi)
{
int i;
cube_configuration *cc;
MI_INIT (mi, ccs);
cc = &ccs[MI_SCREEN(mi)];
if ((cc->glx_context = init_GL(mi)) != NULL) {
reshape_cube (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
cc->trackball = gltrackball_init (False);
cc->ncolors = 256;
cc->colors = (XColor *) calloc(cc->ncolors, sizeof(XColor));
reset_colors (mi);
init_wave (mi);
cc->ncubes = MI_COUNT (mi);
if (cc->ncubes < 1) cc->ncubes = 1;
cc->cubes = (cube *) calloc (sizeof(cube), cc->ncubes);
for (i = 0; i < cc->ncubes; i++)
{
/* Set the size to roughly cover a 2x2 square on average. */
GLfloat scale = 1.8 / sqrt (cc->ncubes);
cube *cube = &cc->cubes[i];
double th = -(skew ? frand(skew) : 0) * M_PI / 180;
cube->x = (frand(1)-0.5);
cube->y = (frand(1)-0.5);
cube->z = frand(0.12);
cube->cth = cos(th);
cube->sth = sin(th);
cube->w = scale * (frand(1) + 0.2);
cube->d = scale * (frand(1) + 0.2);
if (cube->x < cc->min_x) cc->min_x = cube->x;
if (cube->y < cc->min_y) cc->min_y = cube->y;
if (cube->x > cc->max_x) cc->max_x = cube->x;
if (cube->y > cc->max_y) cc->max_y = cube->y;
}
/* Sorting by depth improves frame rate slightly. With 6000 polygons we get:
3.9 FPS unsorted;
3.1 FPS back to front;
4.3 FPS front to back.
*/
qsort (cc->cubes, cc->ncubes, sizeof(*cc->cubes), cmp_cubes);
}
ENTRYPOINT void
init_slideshow (ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
slideshow_state *ss;
int wire = MI_IS_WIREFRAME(mi);
MI_INIT (mi, sss);
ss = &sss[screen];
if ((ss->glx_context = init_GL(mi)) != NULL) {
reshape_slideshow (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
if (debug_p)
fprintf (stderr, "%s: pan: %d; fade: %d; img: %d; zoom: %d%%\n",
blurb(), pan_seconds, fade_seconds, image_seconds, zoom);
sanity_check(mi);
if (debug_p)
fprintf (stderr, "%s: pan: %d; fade: %d; img: %d; zoom: %d%%\n\n",
blurb(), pan_seconds, fade_seconds, image_seconds, zoom);
glDisable (GL_LIGHTING);
glDisable (GL_DEPTH_TEST);
glDepthMask (GL_FALSE);
glEnable (GL_CULL_FACE);
glCullFace (GL_BACK);
if (! wire)
{
glEnable (GL_TEXTURE_2D);
glShadeModel (GL_SMOOTH);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
if (debug_p) glLineWidth (3);
ss->font_data = load_texture_font (mi->dpy, "titleFont");
if (debug_p)
hack_resources();
ss->now = double_time();
ss->dawn_of_time = ss->now;
ss->prev_frame_time = ss->now;
ss->awaiting_first_image_p = True;
alloc_image (mi);
}
ENTRYPOINT void
init_stream (ModeInfo *mi)
{
stream_configuration *es;
streamtime current_time;
MI_INIT (mi, ess);
es = &ess[MI_SCREEN(mi)];
es->glx_context = init_GL (mi);
reshape_stream (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
gettime (¤t_time);
es->start_time = GETSECS(current_time) * 1000 + GETMSECS(current_time);
es->num_streams = num_streams;
es->streams = (flare_stream *) calloc (es->num_streams, sizeof(flare_stream));
init_flare_stream (&es->streams[0], 150, 0, 50, 0, 300);
init_flare_stream (&es->streams[1], 150, 0, 0, 0, 150);
init_flare_stream (&es->streams[2], 150, 0, 90, 60, 250);
init_flare_stream (&es->streams[3], 150, 0, -100, 30, 160);
init_flare_stream (&es->streams[4], 150, 0, 50, -100, 340);
init_flare_stream (&es->streams[5], 150, 0, -50, 50, 270 );
init_flare_stream (&es->streams[6], 150, 0, 100, 50, 180);
init_flare_stream (&es->streams[7], 150, 0, -30, 90, 130);
init_flare_stream (&es->streams[8], 150, 0, 150, 10, 200);
init_flare_stream (&es->streams[9], 150, 0, 100, -100, 210);
init_flare_stream (&es->streams[10], 150, 0, 190, 160, 220);
init_flare_stream (&es->streams[11], 150, 0, -200, 130, 230);
init_flare_stream (&es->streams[12], 150, 0, 150, -200, 240);
init_flare_stream (&es->streams[13], 150, 0, -150, 250, 160);
init_flare_stream (&es->streams[14], 150, 0, 200, 150, 230);
init_flare_stream (&es->streams[15], 150, 0, -130, 190, 250);
{
double spin_speed = 0.5 * global_speed;
double wander_speed = 0.02 * global_speed;
double spin_accel = 1.1;
es->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);
es->trackball = gltrackball_init (True);
}
}
ENTRYPOINT void init_screenflip(ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
Screenflip *c;
MI_INIT(mi, screenflip);
c = &screenflip[screen];
c->window = MI_WINDOW(mi);
c->trackball = gltrackball_init (False);
if ((c->glx_context = init_GL(mi)) != NULL) {
reshape_screenflip(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
c->winh = MI_WIN_HEIGHT(mi);
c->winw = MI_WIN_WIDTH(mi);
c->qw = QW;
c->qh = QH;
c->qx = -6;
c->qy = 6;
c->rx = c->ry = 1;
c->odrot = 1;
c->show_colors[0] = c->show_colors[1] =
c->show_colors[2] = c->show_colors[3] = 1;
if (! MI_IS_WIREFRAME(mi))
{
glShadeModel(GL_SMOOTH);
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDisable(GL_LIGHTING);
}
if (strstr ((char *) glGetString(GL_EXTENSIONS),
"GL_EXT_texture_filter_anisotropic"))
glGetFloatv (GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &c->anisotropic);
else
c->anisotropic = 0.0;
glGenTextures(1, &c->texid);
c->first_image_p = True;
getSnapshot(mi);
}
ENTRYPOINT void
init_atlantis(ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
atlantisstruct *ap;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
MI_INIT(mi, atlantis, free_atlantis);
ap = &atlantis[screen];
ap->num_sharks = MI_COUNT(mi);
if (ap->sharks == NULL) {
if ((ap->sharks = (fishRec *) calloc(ap->num_sharks,
sizeof (fishRec))) == NULL) {
/* free everything up to now */
(void) free((void *) atlantis);
atlantis = NULL;
return;
}
}
ap->sharkspeed = MI_CYCLES(mi); /* has influence on the "width"
of the movement */
ap->sharksize = MI_SIZE(mi); /* has influence on the "distance"
of the sharks */
ap->whalespeed = whalespeed;
ap->wire = MI_IS_WIREFRAME(mi);
if (MI_IS_DEBUG(mi)) {
(void) fprintf(stderr,
"%s:\n\tnum_sharks=%d\n\tsharkspeed=%.1f\n\tsharksize=%d\n\twhalespeed=%.1f\n\twireframe=%s\n",
MI_NAME(mi),
ap->num_sharks,
ap->sharkspeed,
ap->sharksize,
ap->whalespeed,
ap->wire ? "yes" : "no"
);
}
if ((ap->glx_context = init_GL(mi)) != NULL) {
reshape_atlantis(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
Init(mi);
AllDisplay(ap);
glXSwapBuffers(display, window);
} else {
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_fadeplot (ModeInfo * mi)
{
fadeplotstruct *fp;
MI_INIT (mi, fadeplots, free_fadeplot);
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(mi);
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);
}
ENTRYPOINT void
init_hexstrut (ModeInfo *mi)
{
hexstrut_configuration *bp;
MI_INIT (mi, bps, free_hexstrut);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_hexstrut (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
{
double spin_speed = 0.002;
double wander_speed = 0.003;
double spin_accel = 1.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);
bp->trackball = gltrackball_init (True);
}
/* Let's tilt the scene a little. */
gltrackball_reset (bp->trackball,
-0.4 + frand(0.8),
-0.4 + frand(0.8));
if (thickness < 0.05) thickness = 0.05;
if (thickness < 0.05) MI_IS_WIREFRAME(mi) = True;
if (thickness > 1.7) thickness = 1.7;
if (speed > 2) speed = 2;
bp->ncolors = 64;
bp->colors = (XColor *) calloc(bp->ncolors, sizeof(XColor));
make_smooth_colormap (0, 0, 0,
bp->colors, &bp->ncolors,
False, 0, False);
make_plane (mi);
}
ENTRYPOINT void
init_bit (ModeInfo *mi)
{
bit_configuration *bp;
int i;
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_bit (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
{
double spin_speed = 3.0;
double wander_speed = 0.03 * speed;
double spin_accel = 4.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);
bp->trackball = gltrackball_init (False);
}
for (i = 0; i < countof(bp->dlists); i++)
{
bp->dlists[i] = glGenLists (1);
glNewList (bp->dlists[i], GL_COMPILE);
bp->polys [i] = make_bit (mi, i);
glEndList ();
}
bp->frequency = 0.30 / speed; /* parity around 3x/second */
bp->confidence = 0.06; /* provide answer 1/15 or so */
for (i = 0; i < countof(bp->histogram); i++)
bp->histogram[i] = 128 + (random() % 16) - 8;
}
ENTRYPOINT void init_antinspect(ModeInfo * mi)
{
antinspectstruct *mp;
MI_INIT(mi, antinspect);
mp = &antinspect[MI_SCREEN(mi)];
mp->step = NRAND(90);
mp->ant_position = NRAND(90);
mp->trackball = gltrackball_init (False);
if ((mp->glx_context = init_GL(mi)) != NULL) {
reshape_antinspect(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
pinit();
}
else
MI_CLEARWINDOW(mi);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
ENTRYPOINT void
init_lissie (ModeInfo * mi)
{
lissstruct *lp;
unsigned char ball;
MI_INIT (mi, lisses, 0);
lp = &lisses[MI_SCREEN(mi)];
lp->width = MI_WIDTH(mi);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
#endif
lp->height = MI_HEIGHT(mi);
lp->nlissies = MI_COUNT(mi);
if (lp->nlissies < -MINLISSIES) {
if (lp->lissie) {
(void) free((void *) lp->lissie);
lp->lissie = (lissiestruct *) NULL;
}
lp->nlissies = NRAND(-lp->nlissies - MINLISSIES + 1) + MINLISSIES;
} else if (lp->nlissies < MINLISSIES)
lp->nlissies = MINLISSIES;
lp->loopcount = 0;
if (lp->lissie == NULL)
if ((lp->lissie = (lissiestruct *) calloc(lp->nlissies,
sizeof (lissiestruct))) == NULL)
return;
MI_CLEARWINDOW(mi);
lp->painted = False;
for (ball = 0; ball < (unsigned char) lp->nlissies; ball++)
initlissie(mi, &lp->lissie[ball]);
}
ENTRYPOINT void
init_pulsar(ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
pulsarstruct *gp;
MI_INIT (mi, Pulsar);
gp = &Pulsar[screen];
gp->window = MI_WINDOW(mi);
gp->scale_x = gp->scale_y = gp->scale_z = 1;
if ((gp->glx_context = init_GL(mi)) != NULL) {
reshape_pulsar(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
initializeGL(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
}
/* xextrusion initialization routine */
ENTRYPOINT void
init_extrusion (ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
extrusionstruct *gp;
if (MI_IS_WIREFRAME(mi)) do_light = 0;
MI_INIT(mi, Extrusion, NULL);
gp = &Extrusion[screen];
gp->window = MI_WINDOW(mi);
if ((gp->glx_context = init_GL(mi)) != NULL) {
reshape_extrusion(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
initializeGL(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
chooseExtrusionExample(mi);
} else {
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_rubikblocks(ModeInfo *mi)
{
rubikblocks_conf *cp;
MI_INIT(mi, rubikblocks);
cp = &rubikblocks[MI_SCREEN(mi)];
if(tex)
make_texture(cp);
if ((cp->glx_context = init_GL(mi)) != NULL)
{
init_gl(mi);
init_cp(cp);
init_lists(cp);
reshape_rubikblocks(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
else
{
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_morph3d(ModeInfo * mi)
{
morph3dstruct *mp;
MI_INIT (mi, morph3d);
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);
}
}
ENTRYPOINT void init_cubicgrid(ModeInfo *mi)
{
cubicgrid_conf *cp;
MI_INIT(mi, cubicgrid);
cp = &cubicgrid[MI_SCREEN(mi)];
if ((cp->glx_context = init_GL(mi)) != NULL) {
init_gl(mi);
reshape_cubicgrid(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
{
double spin_speed = 0.045 * speed;
double spin_accel = 0.005 * speed;
cp->rot = make_rotator (spin_speed, spin_speed, spin_speed,
spin_accel, 0, True);
cp->trackball = gltrackball_init (True);
}
}
ENTRYPOINT void init_sballs(ModeInfo * mi)
{
sballsstruct *sb;
MI_INIT(mi, sballs, free_sballs);
sb = &sballs[MI_SCREEN(mi)];
sb->trackball = gltrackball_init (True);
if ((sb->glx_context = init_GL(mi)) != NULL) {
#ifndef STANDALONE
Reshape(mi); /* xlock mode */
#else
reshape_sballs(mi,MI_WIDTH(mi),MI_HEIGHT(mi)); /* xscreensaver mode */
#endif
glDrawBuffer(GL_BACK);
Init(mi);
} else {
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_grav(ModeInfo * mi)
{
unsigned char ball;
gravstruct *gp;
MI_INIT (mi, gravs);
gp = &gravs[MI_SCREEN(mi)];
gp->width = MI_WIDTH(mi);
gp->height = MI_HEIGHT(mi);
gp->sr = STARRADIUS;
gp->nplanets = MI_COUNT(mi);
if (gp->nplanets < 0) {
if (gp->planets) {
(void) free((void *) gp->planets);
gp->planets = (planetstruct *) NULL;
}
gp->nplanets = NRAND(-gp->nplanets) + 1; /* Add 1 so its not too boring */
}
if (gp->planets == NULL) {
if ((gp->planets = (planetstruct *) calloc(gp->nplanets,
sizeof (planetstruct))) == NULL)
return;
}
MI_CLEARWINDOW(mi);
if (MI_NPIXELS(mi) > 2)
gp->starcolor = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
else
gp->starcolor = MI_WHITE_PIXEL(mi);
for (ball = 0; ball < (unsigned char) gp->nplanets; ball++)
init_planet(mi, &gp->planets[ball]);
}
ENTRYPOINT void
init_ball (ModeInfo *mi)
{
ball_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
if (! wire)
build_texture (mi);
reshape_ball (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
bp->th = 180 - frand(360);
if (MI_COUNT(mi) < 10)
MI_COUNT(mi) = 10;
if (MI_COUNT(mi) > 200)
MI_COUNT(mi) = 200;
{
double spin_speed = 0.1;
double wander_speed = 0.003;
double spin_accel = 1;
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);
bp->trackball = gltrackball_init (True);
}
build_ball (mi);
if (!wire)
{
GLfloat color[4] = {0.5, 0.5, 0.5, 1};
GLfloat cspec[4] = {1, 1, 1, 1};
static const GLfloat shiny = 10;
static GLfloat pos0[4] = { 0.5, -1, -0.5, 0};
static GLfloat pos1[4] = {-0.75, -1, 0, 0};
static GLfloat amb[4] = {0, 0, 0, 1};
static GLfloat dif[4] = {1, 1, 1, 1};
static GLfloat spc[4] = {1, 1, 1, 1};
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
color[0] += frand(0.2);
color[1] += frand(0.2);
color[2] += frand(0.2);
cspec[0] -= frand(0.2);
cspec[1] -= frand(0.2);
cspec[2] -= frand(0.2);
glLightfv(GL_LIGHT0, GL_POSITION, pos0);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
glLightfv(GL_LIGHT1, GL_POSITION, pos1);
glLightfv(GL_LIGHT1, GL_AMBIENT, amb);
glLightfv(GL_LIGHT1, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT1, GL_SPECULAR, spc);
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT, GL_SPECULAR, cspec);
glMateriali (GL_FRONT, GL_SHININESS, shiny);
}
}
ENTRYPOINT void
init_spheremonics (ModeInfo *mi)
{
spheremonics_configuration *cc;
MI_INIT (mi, ccs);
cc = &ccs[MI_SCREEN(mi)];
if ((cc->glx_context = init_GL(mi)) != NULL) {
gl_init(mi);
reshape_spheremonics (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
{
Bool spinx=False, spiny=False, spinz=False;
double spin_speed = 1.0;
double wander_speed = 0.03;
char *s = do_spin;
while (*s)
{
if (*s == 'x' || *s == 'X') spinx = True;
else if (*s == 'y' || *s == 'Y') spiny = True;
else if (*s == 'z' || *s == 'Z') spinz = True;
else if (*s == '0') ;
else
{
fprintf (stderr,
"%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n",
progname, do_spin);
exit (1);
}
s++;
}
cc->rot = make_rotator (spinx ? spin_speed : 0,
spinz ? spin_speed : 0,
spiny ? spin_speed : 0,
1.0,
do_wander ? wander_speed : 0,
(spinx && spiny && spinz));
cc->trackball = gltrackball_init (True);
}
cc->tracer = -1;
cc->mesher = -1;
cc->resolution = res;
cc->font_data = load_texture_font (mi->dpy, "labelfont");
cc->dlist = glGenLists(1);
cc->dlist2 = glGenLists(1);
cc->m_max = 4; /* 9? */
{
unsigned int i;
for (i = 0; i < countof(cc->dm); i++)
cc->dm[i] = 1; /* going up! */
/* Generate a few more times so we don't always start off with a sphere */
for (i = 0; i < 5; i++)
tweak_parameters (mi);
}
generate_spheremonics(mi);
}
ENTRYPOINT void
init_camera (ModeInfo *mi)
{
camera_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
int i;
MI_INIT (mi, bps, 0);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_camera (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
if (!wire)
{
GLfloat pos[4] = {0.4, 0.2, 0.4, 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] = {1.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);
}
bp->user_trackball = gltrackball_init (False);
bp->dlists = (GLuint *) calloc (countof(all_objs)+1, sizeof(GLuint));
for (i = 0; i < countof(all_objs); i++)
bp->dlists[i] = glGenLists (1);
for (i = 0; i < countof(all_objs); i++)
{
const struct gllist *gll = *all_objs[i];
char *key = 0;
GLfloat spec1[4] = {1.00, 1.00, 1.00, 1.0};
GLfloat spec2[4] = {0.40, 0.40, 0.70, 1.0};
GLfloat *spec = spec1;
GLfloat shiny = 20;
glNewList (bp->dlists[i], GL_COMPILE);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glRotatef (-90, 1, 0, 0);
glRotatef (180, 0, 0, 1);
glScalef (6, 6, 6);
glBindTexture (GL_TEXTURE_2D, 0);
switch (i) {
case CAMERA_BODY: key = "bodyColor"; break;
case CAMERA_CAP: key = "capColor"; break;
case CAMERA_HINGE: key = "hingeColor"; break;
case CAMERA_MOUNT: key = "mountColor"; break;
case CAMERA_LENS: key = "lensColor"; spec = spec2; break;
case GROUND: key = "groundColor"; spec = spec2; shiny = 128; break;
default: abort(); break;
}
parse_color (mi, key, bp->component_colors[i]);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
switch (i) {
case GROUND:
if (! ground)
ground = (struct gllist *) calloc (1, sizeof(*ground));
ground->points = draw_ground (mi, bp->component_colors[i]);
break;
default:
renderList (gll, wire);
/* glColor3f (1, 1, 1); renderListNormals (gll, 100, True); */
/* glColor3f (1, 1, 0); renderListNormals (gll, 100, False); */
break;
}
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEndList ();
}
bp->ncameras = MI_COUNT(mi);
if (bp->ncameras <= 0) bp->ncameras = 1;
bp->cameras = (camera *) calloc (bp->ncameras, sizeof (camera));
{
GLfloat range = (MI_COUNT(mi) <= 2) ? 4 : 5.5;
GLfloat extent;
GLfloat spacing = range / bp->ncameras;
if (spacing < 0.7) spacing = 0.7;
extent = spacing * (bp->ncameras - 1);
for (i = 0; i < bp->ncameras; i++)
{
camera *c = &bp->cameras[i];
c->state = IDLE;
c->pos.x = i*spacing - extent/2;
c->pos.z += 0.7;
if (spacing < 1.6)
c->pos.z = (i & 1 ? 1.1 : -0.3);
c->focus.x = c->pos.x;
c->focus.y = c->pos.y + 1;
c->focus.z = c->pos.z + BEAM_ZOFF;
c->pitch = -50;
}
}
# ifdef DEBUG
if (!debug_p)
# endif
/* Let's tilt the floor a little. */
gltrackball_reset (bp->user_trackball,
-0.70 + frand(1.58),
-0.30 + frand(0.40));
}
ENTRYPOINT void
init_ball (ModeInfo *mi)
{
ball_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_ball (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 = 10.0;
double wander_speed = 0.12;
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,
True);
bp->trackball = gltrackball_init (True);
}
bp->ncolors = 128;
bp->colors = (XColor *) calloc(bp->ncolors, sizeof(XColor));
make_smooth_colormap (0, 0, 0,
bp->colors, &bp->ncolors,
False, 0, False);
bp->spikes = (int *) calloc(MI_COUNT(mi), sizeof(*bp->spikes) * 2);
bp->ball_list = glGenLists (1);
bp->spike_list = glGenLists (1);
glNewList (bp->ball_list, GL_COMPILE);
unit_sphere (SPHERE_STACKS, SPHERE_SLICES, wire);
glEndList ();
glNewList (bp->spike_list, GL_COMPILE);
cone (0, 0, 0,
0, 1, 0,
1, 0, SPIKE_FACES, SMOOTH_SPIKES, False, wire);
glEndList ();
randomize_spikes (mi);
}
ENTRYPOINT void init_hypertorus(ModeInfo *mi)
{
hypertorusstruct *hp;
MI_INIT(mi, hyper, NULL);
hp = &hyper[MI_SCREEN(mi)];
hp->trackballs[0] = gltrackball_init(True);
hp->trackballs[1] = gltrackball_init(True);
hp->current_trackball = 0;
hp->button_pressed = False;
/* Set the display mode. */
if (!strcasecmp(mode,"wireframe") || !strcasecmp(mode,"0"))
{
display_mode = DISP_WIREFRAME;
}
else if (!strcasecmp(mode,"surface") || !strcasecmp(mode,"1"))
{
display_mode = DISP_SURFACE;
}
else if (!strcasecmp(mode,"transparent") || !strcasecmp(mode,"2"))
{
display_mode = DISP_TRANSPARENT;
}
else
{
display_mode = DISP_SURFACE;
}
/* Set the appearance. */
if (!strcasecmp(appear,"solid") || !strcasecmp(appear,"0"))
{
appearance = APPEARANCE_SOLID;
}
else if (!strcasecmp(appear,"bands") || !strcasecmp(appear,"1"))
{
appearance = APPEARANCE_BANDS;
num_spirals = 0;
}
else if (!strcasecmp(appear,"spirals-1") || !strcasecmp(appear,"3"))
{
appearance = APPEARANCE_SPIRALS;
num_spirals = 1;
}
else if (!strcasecmp(appear,"spirals-2") || !strcasecmp(appear,"4"))
{
appearance = APPEARANCE_SPIRALS;
num_spirals = 2;
}
else if (!strcasecmp(appear,"spirals-4") || !strcasecmp(appear,"5"))
{
appearance = APPEARANCE_SPIRALS;
num_spirals = 4;
}
else if (!strcasecmp(appear,"spirals-8") || !strcasecmp(appear,"6"))
{
appearance = APPEARANCE_SPIRALS;
num_spirals = 8;
}
else if (!strcasecmp(appear,"spirals-16") || !strcasecmp(appear,"7"))
{
appearance = APPEARANCE_SPIRALS;
num_spirals = 16;
}
else
{
appearance = APPEARANCE_BANDS;
num_spirals = 0;
}
/* Set the color mode. */
if (!strcasecmp(color_mode,"twosided"))
{
colors = COLORS_TWOSIDED;
}
else if (!strcasecmp(color_mode,"colorwheel"))
{
colors = COLORS_COLORWHEEL;
}
else
{
colors = COLORS_COLORWHEEL;
}
/* Set the 3d projection mode. */
if (!strcasecmp(proj_3d,"perspective") || !strcasecmp(proj_3d,"0"))
{
projection_3d = DISP_3D_PERSPECTIVE;
}
else if (!strcasecmp(proj_3d,"orthographic") || !strcasecmp(proj_3d,"1"))
{
projection_3d = DISP_3D_ORTHOGRAPHIC;
}
else
{
projection_3d = DISP_3D_PERSPECTIVE;
}
/* Set the 4d projection mode. */
if (!strcasecmp(proj_4d,"perspective") || !strcasecmp(proj_4d,"0"))
{
projection_4d = DISP_4D_PERSPECTIVE;
}
else if (!strcasecmp(proj_4d,"orthographic") || !strcasecmp(proj_4d,"1"))
{
projection_4d = DISP_4D_ORTHOGRAPHIC;
}
else
{
projection_4d = DISP_4D_PERSPECTIVE;
}
/* make multiple screens rotate at slightly different rates. */
hp->speed_scale = 0.9 + frand(0.3);
if ((hp->glx_context = init_GL(mi)) != NULL)
{
reshape_hypertorus(mi,MI_WIDTH(mi),MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
init(mi);
}
else
{
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
init_splitflap (ModeInfo *mi)
{
splitflap_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
int i;
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_splitflap (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
bp->first_time_p = True;
if (!mode_str || !*mode_str || !strcasecmp(mode_str, "text"))
{
bp->clock_p = 0;
}
else if (!strcasecmp (mode_str, "clock") ||
!strcasecmp (mode_str, "clock12"))
{
bp->clock_p = 12;
grid_width = 8;
grid_height = 1;
}
else if (!strcasecmp (mode_str, "clock24"))
{
bp->clock_p = 24;
grid_width = 6;
grid_height = 1;
}
else
{
fprintf (stderr,
"%s: `mode' must be text, clock12 or clock24: not `%s'\n",
progname, mode_str);
exit (1);
}
if (! bp->clock_p)
{
bp->tc = textclient_open (MI_DISPLAY (mi));
bp->text[0] = 0;
if (grid_width > 10)
textclient_reshape (bp->tc,
grid_width, grid_height,
grid_width, grid_height,
0);
}
if (bp->clock_p)
speed /= 4;
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
if (!wire)
{
GLfloat pos[4] = {0.4, 0.2, 0.4, 0.0};
/* GLfloat amb[4] = {0.0, 0.0, 0.0, 1.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] = {1.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);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
{
double spin_speed = 0.5;
double wander_speed = 0.005;
double tilt_speed = 0.001;
double spin_accel = 0.5;
char *s = do_spin;
while (*s)
{
if (*s == 'x' || *s == 'X') bp->spinx = True;
else if (*s == 'y' || *s == 'Y') bp->spiny = True;
else if (*s == 'z' || *s == 'Z') bp->spinz = True;
else if (*s == '0') ;
else
{
fprintf (stderr,
"%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n",
progname, do_spin);
exit (1);
}
s++;
}
bp->rot = make_rotator (bp->spinx ? spin_speed : 0,
bp->spiny ? spin_speed : 0,
bp->spinz ? spin_speed : 0,
spin_accel,
do_wander ? wander_speed : 0,
False);
bp->rot2 = (face_front_p
? make_rotator (0, 0, 0, 0, tilt_speed, True)
: 0);
bp->trackball = gltrackball_init (False);
}
bp->dlists = (GLuint *) calloc (countof(all_objs)+1, sizeof(GLuint));
for (i = 0; i < countof(all_objs); i++)
bp->dlists[i] = glGenLists (1);
parse_color (mi, "textColor", bp->text_color);
for (i = 0; i < countof(all_objs); i++)
{
const struct gllist *gll = *all_objs[i];
char *key = 0;
GLfloat spec[4] = {0.4, 0.4, 0.4, 1.0};
GLfloat shiny = 80; /* 0-128 */
glNewList (bp->dlists[i], GL_COMPILE);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glRotatef (-90, 1, 0, 0);
glBindTexture (GL_TEXTURE_2D, 0);
switch (i) {
case SPLITFLAP_QUARTER_FRAME:
key = "frameColor";
break;
case SPLITFLAP_OUTER_FRAME:
key = "caseColor";
break;
case SPLITFLAP_DISC_QUARTER:
key = (wire ? "frameColor" : "discColor");
break;
case SPLITFLAP_FIN_EDGE_HALF:
case SPLITFLAP_FIN_FACE_HALF:
key = "finColor";
break;
default:
abort();
}
parse_color (mi, key, bp->component_colors[i]);
if (wire && i == SPLITFLAP_FIN_EDGE_HALF)
bp->component_colors[i][0] =
bp->component_colors[i][1] =
bp->component_colors[i][2] = 0.7;
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
switch (i) {
case SPLITFLAP_OUTER_FRAME:
if (! splitflap_obj_outer_frame)
splitflap_obj_outer_frame =
(struct gllist *) calloc (1, sizeof(*splitflap_obj_outer_frame));
splitflap_obj_outer_frame->points = draw_outer_frame(mi);
break;
default:
renderList (gll, wire);
break;
}
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEndList ();
}
if (grid_width < 1) grid_width = 1;
if (grid_height < 1) grid_height = 1;
bp->flappers = (flapper *) calloc (grid_width * grid_height,
sizeof (flapper));
for (i = 0; i < grid_width * grid_height; i++)
{
flapper *f = &bp->flappers[i];
if (!bp->clock_p)
{
f->spool = ascii_spool;
f->spool_size = countof (ascii_spool);
}
else
{
switch (i) {
case 0:
if (bp->clock_p == 12)
{
f->spool = digit_s1_spool;
f->spool_size = countof (digit_s1_spool);
}
else
{
f->spool = digit_01_spool;
f->spool_size = countof (digit_01_spool);
}
break;
case 1: case 3: case 5:
f->spool = digit_spool;
f->spool_size = countof (digit_spool);
break;
case 2: case 4:
f->spool = digit_05_spool;
f->spool_size = countof (digit_05_spool);
break;
case 6:
f->spool = ap_spool;
f->spool_size = countof (ap_spool);
break;
case 7:
f->spool = m_spool;
f->spool_size = countof (m_spool);
break;
default:
abort();
}
}
f->target_index = random() % f->spool_size;
/* f->target_index = 0; */
f->current_index = f->target_index;
f->missing = (((random() % 10) == 0)
? (random() % f->spool_size)
: -1);
}
bp->font_data = load_texture_font (mi->dpy, "flapFont");
init_textures (mi);
reshape_splitflap (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
ENTRYPOINT void
init_unicrud (ModeInfo *mi)
{
unicrud_configuration *bp;
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_unicrud (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
{
double spin_speed = 0.05;
double wander_speed = 0.01;
double spin_accel = 1.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);
bp->trackball = gltrackball_init (True);
}
bp->title_font = load_texture_font (mi->dpy, "titleFont");
bp->char_font = load_texture_font (mi->dpy, "font");
bp->state = IN;
bp->ratio = 0;
bp->spin_direction = (random() & 1) ? 1 : -1;
if (matches ("all", do_block))
do_block = strdup("");
{
char *s;
for (s = do_block; *s; s++)
if (*s == '_') *s = ' ';
}
if (matches ("help", do_block))
{
int i;
fprintf (stderr,
"%s: --blocks must contain one or more of these,"
" separated by commas:\n\n", progname);
for (i = 0; i < countof(unicode_block_names); i++)
{
const char *n = unicode_block_names[i].name;
if (*n == '*')
continue;
if (!strncmp (n, "Unassigned", 10) ||
!strncmp (n, "Combining", 9))
continue;
fprintf (stderr, "\t%s\n", n);
}
fprintf (stderr, "\n");
exit (1);
}
/* Make sure all elements in --block are valid.
*/
if (*do_block)
{
char *token = strdup (do_block ? do_block : "");
char *otoken = token;
char *name;
while ((name = strtok (token, ","))) {
token = 0;
name = strip (name);
if (*name)
{
Bool match = False;
int i;
for (i = 0; i < countof(unicode_block_names); i++)
{
const char *n = unicode_block_names[i].name;
if (*n == '*')
continue;
if (!strncmp (n, "Unassigned", 10) ||
!strncmp (n, "Combining", 9))
continue;
if (!strcasecmp (name, n))
{
match = True;
break;
}
}
if (! match)
{
fprintf (stderr, "%s: unknown block name: \"%s\"\n",
progname, name);
fprintf (stderr, "%s: use '--block help' for a list\n",
progname);
exit (1);
}
}
}
free (otoken);
}
pick_unichar (mi);
}
