ENTRYPOINT void
init_triangle (ModeInfo * mi)
{
trianglestruct *tp;
short *tmp;
int i, dim, one;
if (triangles == NULL) {
if ((triangles = (trianglestruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (trianglestruct))) == NULL)
return;
}
tp = &triangles[MI_SCREEN(mi)];
tp->width = MI_WIN_WIDTH(mi);
tp->height = MI_WIN_HEIGHT(mi);
tp->init_now = 1;
tp->fast = 2;
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
tp->steps = MAX_STEPS;
do {
tp->size = 1 << --tp->steps;
} while (tp->size * 5 > tp->width);
tmp = tp->H;
for (i = 0; i < tp->size + 1; i++) {
tp->h[i] = tmp;
tmp += (tp->size) + 1 - i;
}
tp->stage = -1;
dim = MIN(tp->width, tp->height);
for (i = 0; i < 2 * tp->size + 1; i++) {
tp->xpos[i] = (short) ((((double) i)
/ ((double) (2 * tp->size)) * (RIGHT - LEFT) + LEFT)
* dim) + (tp->width - dim) / 2;
}
for (i = 0; i < (tp->size + 1); i++) {
tp->ypos[i] = (short) ((((double) i)
/ ((double) tp->size) * (BOTTOM - TOP) + TOP) * dim)
+ (tp->height - dim) / 2;
}
for (i = 0; i < tp->steps; i++) {
tp->delta[i] = ((short) (DELTA * dim)) >> i;
}
one = tp->delta[0];
if (one > 0)
for (i = 0; i < MAX_LEVELS; i++) {
tp->level[i] = (i * i) / one;
}
}
ENTRYPOINT void init_screenflip(ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
Screenflip *c;
if (screenflip == NULL) {
if ((screenflip = (Screenflip *) calloc(MI_NUM_SCREENS(mi),
sizeof(Screenflip))) == NULL)
return;
}
c = &screenflip[screen];
c->window = MI_WINDOW(mi);
c->trackball = gltrackball_init ();
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_galaxy(ModeInfo * mi)
{
unistruct *gp;
if (universes == NULL) {
if ((universes = (unistruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (unistruct))) == NULL)
return;
}
gp = &universes[MI_SCREEN(mi)];
# ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
dbufp = False;
# endif
gp->f_hititerations = MI_CYCLES(mi);
gp->scale = (double) (MI_WIN_WIDTH(mi) + MI_WIN_HEIGHT(mi)) / 8.0;
gp->midx = MI_WIN_WIDTH(mi) / 2;
gp->midy = MI_WIN_HEIGHT(mi) / 2;
startover(mi);
}
static
void
draw_mesh(ModeInfo * mi, trianglestruct * tp, int d, int count)
{
XPoint p[3];
int first = 1;
int y_0, y_1, y_2;
double dinv = 0.2 / d;
if ((tp->j == 0) && (tp->i == 0)) {
#if 0 /* jwz */
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
#else
{
int x = 0;
int y = 0;
int x2 = MI_WIN_WIDTH(mi);
int y2 = tp->ypos[0];
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_BLACK_PIXEL(mi));
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
x, y, x2, y2);
}
#endif
}
for (; (tp->j < tp->size) && (count > 0); tp->j += ((count) ? d : 0)) {
for (tp->i = (first) ? tp->i : 0, first = 0;
(tp->i < MAX_SIZE - tp->j) && (count > 0);
tp->i += d, count--) {
if (tp->i + tp->j < tp->size) {
calc_points1(tp, d, &y_0, &y_1, &y_2, p);
draw_atriangle(mi, p, y_0, y_1, y_2, dinv);
}
if (tp->i + tp->j + d < tp->size) {
calc_points2(tp, d, &y_0, &y_1, &y_2, p);
draw_atriangle(mi, p, y_0, y_1, y_2, dinv);
}
}
}
if (tp->j == tp->size) {
tp->init_now = 1;
}
}
ENTRYPOINT void
init_bouboule(ModeInfo * mi)
/***************/
/*-
* The stars init part was first inspirated from the net3d game starfield
* code. But net3d starfield is not really 3d starfield, and I needed real 3d,
* so only remains the net3d starfield initialization main idea, that is
* the stars distribution on a sphere (theta and omega computing)
*/
{
StarField *sp;
int size = MI_SIZE(mi);
int i;
double theta, omega;
if (starfield == NULL) {
if ((starfield = (StarField *) calloc(MI_NUM_SCREENS(mi),
sizeof (StarField))) == NULL)
return;
}
sp = &starfield[MI_SCREEN(mi)];
sp->width = MI_WIN_WIDTH(mi);
sp->height = MI_WIN_HEIGHT(mi);
/* use the right `black' pixel values: */
if (MI_WIN_IS_INSTALL(mi) && MI_WIN_IS_USE3D(mi)) {
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_NONE_COLOR(mi));
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
0, 0, sp->width, sp->height);
} else
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
if (size < -MINSIZE)
sp->max_star_size = NRAND(-size - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
sp->max_star_size = MINSIZE;
else
sp->max_star_size = size;
sp->NbStars = MI_BATCHCOUNT(mi);
if (sp->NbStars < -MINSTARS) {
if (sp->star) {
(void) free((void *) sp->star);
sp->star = NULL;
}
if (sp->xarc) {
(void) free((void *) sp->xarc);
sp->xarc = NULL;
}
if (sp->xarcleft) {
(void) free((void *) sp->xarcleft);
sp->xarcleft = NULL;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
if (sp->oldxarc) {
(void) free((void *) sp->oldxarc);
sp->oldxarc = NULL;
}
if (sp->oldxarcleft) {
(void) free((void *) sp->oldxarcleft);
sp->oldxarcleft = NULL;
}
#endif
sp->NbStars = NRAND(-sp->NbStars - MINSTARS + 1) + MINSTARS;
} else if (sp->NbStars < MINSTARS)
sp->NbStars = MINSTARS;
/* We get memory for lists of objects */
if (sp->star == NULL)
sp->star = (Star *) malloc(sp->NbStars * sizeof (Star));
if (sp->xarc == NULL)
sp->xarc = (XArc *) malloc(sp->NbStars * sizeof (XArc));
if (MI_WIN_IS_USE3D(mi) && sp->xarcleft == NULL)
sp->xarcleft = (XArc *) malloc(sp->NbStars * sizeof (XArc));
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
if (sp->oldxarc == NULL)
sp->oldxarc = (XArc *) malloc(sp->NbStars * sizeof (XArc));
if (MI_WIN_IS_USE3D(mi) && sp->oldxarcleft == NULL)
sp->oldxarcleft = (XArc *) malloc(sp->NbStars * sizeof (XArc));
#endif
{
/* We initialize evolving variables */
sininit(&sp->x,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
((double) sp->width) / 4.0,
3.0 * ((double) sp->width) / 4.0,
POSCANRAND);
sininit(&sp->y,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
((double) sp->height) / 4.0,
3.0 * ((double) sp->height) / 4.0,
POSCANRAND);
/* for z, we have to ensure that the bouboule does not get behind */
/* the eyes of the viewer. His/Her eyes are at 0. Because the */
/* bouboule uses the x-radius for the z-radius, too, we have to */
/* use the x-values. */
sininit(&sp->z,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
((double) sp->width / 2.0 + MINZVAL),
((double) sp->width / 2.0 + MAXZVAL),
POSCANRAND);
sininit(&sp->sizex,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
MIN(((double) sp->width) - sp->x.value,
sp->x.value) / 5.0,
MIN(((double) sp->width) - sp->x.value,
sp->x.value),
SIZECANRAND);
sininit(&sp->sizey,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
MAX(sp->sizex.value / MAX_SIZEX_SIZEY,
sp->sizey.maximum / 5.0),
MIN(sp->sizex.value * MAX_SIZEX_SIZEY,
MIN(((double) sp->height) -
sp->y.value,
sp->y.value)),
SIZECANRAND);
sininit(&sp->thetax,
NRAND(3142) / 1000.0, M_PI / (NRAND(200) + 200.0),
-M_PI, M_PI,
THETACANRAND);
sininit(&sp->thetay,
NRAND(3142) / 1000.0, M_PI / (NRAND(200) + 200.0),
-M_PI, M_PI,
THETACANRAND);
sininit(&sp->thetaz,
NRAND(3142) / 1000.0, M_PI / (NRAND(400) + 400.0),
-M_PI, M_PI,
THETACANRAND);
}
for (i = 0; i < sp->NbStars; i++) {
Star *star;
XArc *arc = NULL, *arcleft = NULL;
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
XArc *oarc = NULL, *oarcleft = NULL;
#endif
star = &(sp->star[i]);
arc = &(sp->xarc[i]);
if (MI_WIN_IS_USE3D(mi))
arcleft = &(sp->xarcleft[i]);
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc = &(sp->oldxarc[i]);
if (MI_WIN_IS_USE3D(mi))
oarcleft = &(sp->oldxarcleft[i]);
#endif
/* Elevation and bearing of the star */
theta = dtor((NRAND(1800)) / 10.0 - 90.0);
omega = dtor((NRAND(3600)) / 10.0 - 180.0);
/* Stars coordinates in a 3D space */
star->x = cos(theta) * sin(omega);
star->y = sin(omega) * sin(theta);
star->z = cos(omega);
/* We set the stars size */
star->size = NRAND(2 * sp->max_star_size);
if (star->size < sp->max_star_size)
star->size = 0;
else
star->size -= sp->max_star_size;
/* We set default values for the XArc lists elements */
arc->x = arc->y = 0;
if (MI_WIN_IS_USE3D(mi)) {
arcleft->x = arcleft->y = 0;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc->x = oarc->y = 0;
if (MI_WIN_IS_USE3D(mi)) {
oarcleft->x = oarcleft->y = 0;
}
#endif
arc->width = 2 + star->size;
arc->height = 2 + star->size;
if (MI_WIN_IS_USE3D(mi)) {
arcleft->width = 2 + star->size;
arcleft->height = 2 + star->size;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc->width = 2 + star->size;
oarc->height = 2 + star->size;
if (MI_WIN_IS_USE3D(mi)) {
oarcleft->width = 2 + star->size;
oarcleft->height = 2 + star->size;
}
#endif
arc->angle1 = 0;
arc->angle2 = 360 * 64;
if (MI_WIN_IS_USE3D(mi)) {
arcleft->angle1 = 0;
arcleft->angle2 = 360 * 64;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc->angle1 = 0;
oarc->angle2 = 360 * 64; /* ie. we draw whole disks:
* from 0 to 360 degrees */
if (MI_WIN_IS_USE3D(mi)) {
oarcleft->angle1 = 0;
oarcleft->angle2 = 360 * 64;
}
#endif
}
if (MI_NPIXELS(mi) > 2)
sp->colorp = NRAND(MI_NPIXELS(mi));
/* We set up the starfield color */
if (!MI_WIN_IS_USE3D(mi) && MI_NPIXELS(mi) > 2)
sp->color = MI_PIXEL(mi, sp->colorp);
else
sp->color = MI_WIN_WHITE_PIXEL(mi);
#if (ADAPT_ERASE == 1)
/* We initialize the adaptation code for screen erasing */
sp->hasbeenchecked = ADAPT_CHECKS * 2;
sp->rect_time = 0;
sp->xarc_time = 0;
#endif
}
ENTRYPOINT void
init_worm (ModeInfo * mi)
{
wormstruct *wp;
int size = MI_SIZE(mi);
int i, j;
if (worms == NULL) {
if ((worms = (wormstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (wormstruct))) == NULL)
return;
}
wp = &worms[MI_SCREEN(mi)];
if (MI_NPIXELS(mi) <= 2 || MI_WIN_IS_USE3D(mi))
wp->nc = 2;
else
wp->nc = MI_NPIXELS(mi);
if (wp->nc > NUMCOLORS)
wp->nc = NUMCOLORS;
free_worms(wp);
wp->nw = MI_BATCHCOUNT(mi);
if (wp->nw < -MINWORMS)
wp->nw = NRAND(-wp->nw - MINWORMS + 1) + MINWORMS;
else if (wp->nw < MINWORMS)
wp->nw = MINWORMS;
if (!wp->worm)
wp->worm = (wormstuff *) malloc(wp->nw * sizeof (wormstuff));
if (!wp->size)
wp->size = (int *) malloc(NUMCOLORS * sizeof (int));
wp->maxsize = (REDRAWSTEP + 1) * wp->nw; /* / wp->nc + 1; */
if (!wp->rects)
wp->rects =
(XRectangle *) malloc(wp->maxsize * NUMCOLORS * sizeof (XRectangle));
if (!init_table) {
init_table = 1;
for (i = 0; i < SEGMENTS; i++) {
sintab[i] = SINF(i * 2.0 * M_PI / SEGMENTS);
costab[i] = COSF(i * 2.0 * M_PI / SEGMENTS);
}
}
wp->xsize = MI_WIN_WIDTH(mi);
wp->ysize = MI_WIN_HEIGHT(mi);
wp->zsize = MAXZ - MINZ + 1;
if (MI_NPIXELS(mi) > 2)
wp->chromo = NRAND(MI_NPIXELS(mi));
if (size < -MINSIZE)
wp->circsize = NRAND(-size - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
wp->circsize = MINSIZE;
else
wp->circsize = size;
for (i = 0; i < wp->nc; i++) {
for (j = 0; j < wp->maxsize; j++) {
wp->rects[i * wp->maxsize + j].width = wp->circsize;
wp->rects[i * wp->maxsize + j].height = wp->circsize;
}
}
(void) memset((char *) wp->size, 0, wp->nc * sizeof (int));
wp->wormlength = (int) sqrt(wp->xsize + wp->ysize) *
MI_CYCLES(mi) / 8; /* Fudge this to something reasonable */
for (i = 0; i < wp->nw; i++) {
wp->worm[i].circ = (XPoint *) malloc(wp->wormlength * sizeof (XPoint));
wp->worm[i].diffcirc = (int *) malloc(wp->wormlength * sizeof (int));
for (j = 0; j < wp->wormlength; j++) {
wp->worm[i].circ[j].x = wp->xsize / 2;
wp->worm[i].circ[j].y = wp->ysize / 2;
if (MI_WIN_IS_USE3D(mi))
wp->worm[i].diffcirc[j] = 0;
}
wp->worm[i].dir = NRAND(SEGMENTS);
wp->worm[i].dir2 = NRAND(SEGMENTS);
wp->worm[i].tail = 0;
wp->worm[i].x = wp->xsize / 2;
wp->worm[i].y = wp->ysize / 2;
wp->worm[i].z = SCREENZ - MINZ;
wp->worm[i].redrawing = 0;
}
if (MI_WIN_IS_INSTALL(mi) && MI_WIN_IS_USE3D(mi)) {
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_NONE_COLOR(mi));
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
0, 0, wp->xsize, wp->ysize);
} else
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
}
