Bool
fixedColors(ModeInfo * mi)
{
Bool temp;
#ifdef FORCEFIXEDCOLORS
/* pretending a fixed colourmap */
return TRUE;
#else
/* get information about the default visual */
temp = (!((MI_NPIXELS(mi) > 2) &&
(MI_VISUALCLASS(mi) != StaticGray) &&
(MI_VISUALCLASS(mi) != StaticColor) &&
(MI_VISUALCLASS(mi) != TrueColor) &&
#if 0
/*-
* This may fix wrong colors (possibly unreadable text) in password window
*/
!MI_IS_ICONIC(mi) &&
#endif
!MI_IS_INROOT(mi) &&
MI_IS_INSTALL(mi)));
#endif
if (debug) {
(void) printf("%s colors on screen %d\n", (temp) ? "fixed" : "writeable",
MI_SCREEN(mi));
}
return temp;
}
static void
paint_fly(ModeInfo * mi, Fly * f)
{
EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int x = f->x, y = f->y;
if (MI_IS_ICONIC(mi)) {
/* don't need to unpaint when iconic
* ep->flyGC has stipple set, don't use when iconic
*/
XSetForeground(display, MI_GC(mi), f->pixel);
XFillArc(display, window, MI_GC(mi), x, y,
f->width, f->height, 90 * 64, 360 * 64);
} else {
unpaint_fly(mi, f);
XSetForeground(display, ep->flyGC, f->pixel);
#ifdef XBM_GRELB
if (ep->fly2pix != None) {
XSetStipple(display, ep->flyGC, (f->vy <= 0) ? ep->flypix : ep->fly2pix);
} else
#endif
XSetStipple(display, ep->flyGC, ep->flypix);
XSetTSOrigin(display, ep->flyGC, x, y);
#ifdef FLASH
XSetFillStyle(display, ep->flyGC, FillStippled);
#else
XSetFillStyle(display, ep->flyGC, FillOpaqueStippled);
#endif
XFillRectangle(display, window, ep->flyGC,
x, y, f->width, f->height);
XFlush(display);
}
}
ENTRYPOINT void
draw_moebius (ModeInfo * mi)
{
moebiusstruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (moebius == NULL)
return;
mp = &moebius[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!mp->glx_context)
return;
glXMakeCurrent(display, window, *(mp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.0, 0.0, -10.0);
/* Do it twice because we don't track the device's orientation. */
glRotatef( current_device_rotation(), 0, 0, 1);
gltrackball_rotate (mp->trackball);
glRotatef(-current_device_rotation(), 0, 0, 1);
if (!MI_IS_ICONIC(mi)) {
glScalef(Scale4Window * mp->WindH / mp->WindW, Scale4Window, Scale4Window);
} else {
glScalef(Scale4Iconic * mp->WindH / mp->WindW, Scale4Iconic, Scale4Iconic);
}
{
double x, y, z;
get_rotation (mp->rot, &x, &y, &z, !mp->button_down_p);
glRotatef (x * 360, 1.0, 0.0, 0.0);
glRotatef (y * 360, 0.0, 1.0, 0.0);
glRotatef (z * 360, 0.0, 0.0, 1.0);
}
/* moebius */
if (!draw_moebius_strip(mi)) {
release_moebius(mi);
return;
}
glPopMatrix();
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
mp->step += 0.025;
}
ENTRYPOINT void
draw_cage (ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
cagestruct *cp;
if (cage == NULL)
return;
cp = &cage[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!cp->glx_context)
return;
glXMakeCurrent(display, window, *(cp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.0, 0.0, -10.0);
if (!MI_IS_ICONIC(mi)) {
glScalef(Scale4Window * cp->WindH / cp->WindW, Scale4Window, Scale4Window);
} else {
glScalef(Scale4Iconic * cp->WindH / cp->WindW, Scale4Iconic, Scale4Iconic);
}
/* cage */
glRotatef(cp->step * 100, 0, 0, 1);
glRotatef(25 + cos(cp->step * 5) * 6, 1, 0, 0);
glRotatef(204.5 - sin(cp->step * 5) * 8, 0, 1, 0);
if (!draw_impossiblecage(cp, MI_IS_WIREFRAME(mi))) {
release_cage(mi);
return;
}
glPopMatrix();
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
cp->step += 0.025;
}
void
draw_image(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
GC gc;
imagestruct *ip;
if (ims == NULL)
return;
ip = &ims[MI_SCREEN(mi)];
if (ip->icons == NULL)
return;
if (icononly && !MI_IS_ICONIC(mi))
return;
gc = (message && *message) ? MI_GC(mi) : ip->bgGC;
MI_IS_DRAWN(mi) = True;
XSetForeground(display, gc, ip->black);
if (ip->border.x < 0)
ip->image_offset.x = -NRAND(-ip->border.x);
else if (ip->border.x > 0)
ip->image_offset.x = NRAND(ip->border.x);
else
ip->image_offset.x = 0;
if (ip->border.y < 0)
ip->image_offset.y = -NRAND(-ip->border.y);
else if (ip->border.y > 0)
ip->image_offset.y = NRAND(ip->border.y);
else
ip->image_offset.y = 0;
for (i = 0; i < ip->iconcount; i++) {
ip->icons[i].x = NRAND(ip->ncols);
ip->icons[i].y = NRAND(ip->nrows);
ip->icons[i].color = NRAND(MI_NPIXELS(mi));
if (ip->ncols * ip->nrows > ip->iconcount &&
ip->icons[i].x >= 0)
XFillRectangle(display, window, gc,
ip->pixw * ip->icons[i].x + ip->image_offset.x,
ip->pixh * ip->icons[i].y + ip->image_offset.y,
ip->pixw, ip->pixh);
}
drawImages(mi);
}
static void
set_window_title(ModeInfo * mi)
{
XTextProperty prop;
char *buf;
unsigned int status;
buf = (char *) malloc(strlen(MI_NAME(mi)) + strlen(MI_DESC(mi)) + 3);
(void) sprintf(buf, "%s: %s", MI_NAME(mi), MI_DESC(mi));
status = XStringListToTextProperty(&buf, 1, &prop);
if (status != 0) {
XSetWMName(MI_DISPLAY(mi), MI_WINDOW(mi), &prop);
XFree((caddr_t) prop.value);
}
free(buf);
if (MI_IS_ICONIC(mi) && description) {
modeDescription(mi);
}
}
static void
unpaint_fly(ModeInfo * mi, Fly * f)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
if (MI_IS_ICONIC(mi)) {
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XFillArc(display, window, gc, f->oldx, f->oldy,
f->width, f->height, 90 * 64, 360 * 64);
} else {
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
#ifdef FLASH
XFillRectangle(display, window, gc,
f->oldx, f->oldy, f->width, f->height);
#else
ERASE_IMAGE(display, window, gc, f->x, f->y,
f->oldx, f->oldy, f->width, f->height);
#endif
}
}
static void
init_fly(ModeInfo * mi, Fly * f)
{
EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)];
int win_width = MI_WIDTH(mi);
int win_height = MI_HEIGHT(mi);
(void) memset((char *) f, 0, sizeof (Fly)); /* clear everything to zero */
f->side = FLY_SIDE_LEFT;
if (!MI_IS_ICONIC(mi))
{
f->width = ep->flywidth;
f->height = ep->flyheight;
f->vx = NRAND(15) + 1; /* random horiz velocity */
} else
{
/* image is just a dot when iconic */
f->width = f->height = FLY_ICON_SIZE;
f->vx = NRAND(4) + 1; /* slower when iconic */
}
f->y = NRAND(win_height);
if (f->y > (win_height / 2)) {
f->side = FLY_SIDE_RIGHT; /* change to right side */
f->y -= win_height / 2; /* start in top half */
f->x = win_width - f->width; /* move to right of screen */
f->vx = -(f->vx); /* flip direction */
}
f->oldx = -(f->width); /* prevent undraw 1st time */
if (MI_NPIXELS(mi) <= 2) {
f->pixel = MI_WHITE_PIXEL(mi); /* always white when mono */
} else {
f->pixel = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
}
}
ENTRYPOINT void
draw_stairs (ModeInfo * mi)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
GLfloat rot = current_device_rotation();
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!sp->glx_context)
return;
glXMakeCurrent(display, window, *(sp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(rot, 0, 0, 1);
if ((rot > 45 && rot < 135) ||
(rot < -45 && rot > -135))
{
GLfloat s = MI_WIDTH(mi) / (GLfloat) MI_HEIGHT(mi);
glScalef (s, 1/s, 1);
}
glTranslatef(0.0, 0.0, -10.0);
if (!MI_IS_ICONIC(mi)) {
glScalef(Scale4Window * sp->WindH / sp->WindW, Scale4Window, Scale4Window);
} else {
glScalef(Scale4Iconic * sp->WindH / sp->WindW, Scale4Iconic, Scale4Iconic);
}
gltrackball_rotate (sp->trackball);
glTranslatef(0, 0.5, 0);
glRotatef(44.5, 1, 0, 0);
glRotatef(50, 0, 1, 0);
if (!sp->rotating) {
if ((LRAND() % 500) == 0)
sp->rotating = (LRAND() & 1) ? 1 : -1;
}
if (sp->rotating) {
glRotatef(sp->rotating * sp->step, 0, 1, 0);
if (sp->step >= 360) {
sp->rotating = 0;
sp->step = 0;
}
# ifndef DEBUG
if (!sp->button_down_p)
sp->step += 2;
# endif /* DEBUG */
}
draw_stairs_internal(mi);
# ifdef DEBUG
{
int i, j;
# ifdef DEBUG_PATH
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glBegin (GL_LINE_LOOP);
# endif /* DEBUG_PATH */
for (i = 0; i < NPOSITIONS; i ++)
for (j = 0; j < SPHERE_TICKS; j++)
mi->polygon_count += draw_sphere(i, j);
# ifdef DEBUG_PATH
glEnd();
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
# endif /* DEBUG_PATH */
}
#else /* !DEBUG */
mi->polygon_count += draw_sphere(sp->sphere_position, sp->sphere_tick);
#endif /* !DEBUG */
if (sp->button_down_p)
;
else if (++sp->sphere_tick >= SPHERE_TICKS)
{
sp->sphere_tick = 0;
if (++sp->sphere_position >= NPOSITIONS)
sp->sphere_position = 0;
}
glPopMatrix();
if (mi->fps_p) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
}
static void DrawFire(ModeInfo * mi)
{
int j;
firestruct *fs = &fire[MI_SCREEN(mi)];
Bool wire = MI_IS_WIREFRAME(mi);
if (do_trackmouse && !MI_IS_ICONIC(mi))
trackmouse(mi);
if (do_wander)
{
GLfloat x, y, z;
# define SINOID(SCALE,SIZE) \
((((1 + sin((frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2)
x = SINOID(0.031, 0.85);
y = SINOID(0.017, 0.25);
z = SINOID(0.023, 0.85);
frame++;
fs->obs[0] = x + DEF_OBS[0];
fs->obs[1] = y + DEF_OBS[1];
fs->obs[2] = z + DEF_OBS[2];
fs->dir[1] = y;
fs->dir[2] = z;
}
glEnable(GL_DEPTH_TEST);
if (fs->fog)
glEnable(GL_FOG);
else
glDisable(GL_FOG);
glDepthMask(GL_TRUE);
glClearColor(0.5, 0.5, 0.8, 1.0); /* sky in the distance */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
calcposobs(fs);
gluLookAt(fs->obs[0], fs->obs[1], fs->obs[2],
fs->obs[0] + fs->dir[0], fs->obs[1] + fs->dir[1],
fs->obs[2] + fs->dir[2], 0.0, 1.0, 0.0);
glEnable(GL_TEXTURE_2D);
/* draw ground using the computed texture */
#ifdef HAVE_GLBINDTEXTURE
if (do_texture) {
glColor4f(1.0,1.0,1.0,1.0); /* white to get texture in it's true color */
glBindTexture(GL_TEXTURE_2D, fs->groundid);
}
else
#endif /* HAVE_GLBINDTEXTURE */
glColor4f(0.54, 0.27, 0.07, 1.0); /* untextured ground color */
glBegin(GL_QUADS);
glTexCoord2fv(qt[0]);
glVertex3fv(q[0]);
glTexCoord2fv(qt[1]);
glVertex3fv(q[1]);
glTexCoord2fv(qt[2]);
glVertex3fv(q[2]);
glTexCoord2fv(qt[3]);
glVertex3fv(q[3]);
glEnd();
glAlphaFunc(GL_GEQUAL, 0.9);
#ifdef HAVE_GLBINDTEXTURE
if (fs->num_trees)
{
/* here do_texture IS True - and color used is white */
glEnable(GL_ALPHA_TEST);
glBindTexture(GL_TEXTURE_2D,fs->treeid);
for(j=0;j<fs->num_trees;j++)
drawtree(fs->treepos[j].x ,fs->treepos[j].y ,fs->treepos[j].z );
glDisable(GL_ALPHA_TEST);
}
#endif /* HAVE_GLBINDTEXTURE */
glDisable(GL_TEXTURE_2D);
glDepthMask(GL_FALSE);
if (fs->shadows) {
/* draw shadows with black color */
glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES);
for (j = 0; j < fs->np; j++) {
glColor4f(black[0], black[1], black[2], fs->p[j].c[0][3]);
glVertex3f(fs->p[j].p[0][0], 0.1, fs->p[j].p[0][2]);
glColor4f(black[0], black[1], black[2], fs->p[j].c[1][3]);
glVertex3f(fs->p[j].p[1][0], 0.1, fs->p[j].p[1][2]);
glColor4f(black[0], black[1], black[2], fs->p[j].c[2][3]);
glVertex3f(fs->p[j].p[2][0], 0.1, fs->p[j].p[2][2]);
}
glEnd();
}
glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES);
for (j = 0; j < fs->np; j++) {
/* draw particles: colors are computed in setpart */
glColor4fv(fs->p[j].c[0]);
glVertex3fv(fs->p[j].p[0]);
glColor4fv(fs->p[j].c[1]);
glVertex3fv(fs->p[j].p[1]);
glColor4fv(fs->p[j].c[2]);
glVertex3fv(fs->p[j].p[2]);
setpart(fs, &fs->p[j]);
}
glEnd();
/* draw rain particles if no fire particles */
if (!fs->np)
{
float timeused = gettimerain();
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glBegin(GL_LINES);
for (j = 0; j < NUMPART; j++) {
glColor4f(0.7f,0.95f,1.0f,0.0f);
glVertex3fv(fs->r[j].oldpos);
glColor4f(0.3f,0.7f,1.0f,1.0f);
glVertex3fv(fs->r[j].pos);
setpartrain(fs, &fs->r[j],timeused);
}
glEnd();
glShadeModel(GL_FLAT);
}
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_FOG);
/* manage framerate display */
if (MI_IS_FPS(mi)) do_fps (mi);
glPopMatrix();
}
void
draw_morph3d(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
morph3dstruct *mp;
if (morph3d == NULL)
return;
mp = &morph3d[MI_SCREEN(mi)];
if (!mp->glx_context)
return;
MI_IS_DRAWN(mi) = True;
#ifdef WIN32
wglMakeCurrent(hdc, mp->glx_context);
#else
glXMakeCurrent(display, window, *(mp->glx_context));
#endif
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.0, 0.0, -10.0);
if (!MI_IS_ICONIC(mi)) {
glScalef(Scale4Window * mp->WindH / mp->WindW, Scale4Window, Scale4Window);
glTranslatef(2.5 * mp->WindW / mp->WindH * sin(mp->step * 1.11), 2.5 * cos(mp->step * 1.25 * 1.11), 0);
} else {
glScalef(Scale4Iconic * mp->WindH / mp->WindW, Scale4Iconic, Scale4Iconic);
}
glRotatef(mp->step * 100, 1, 0, 0);
glRotatef(mp->step * 95, 0, 1, 0);
glRotatef(mp->step * 90, 0, 0, 1);
mp->seno = (sin(mp->step) + 1.0 / 3.0) * (4.0 / 5.0) * mp->Magnitude;
if (mp->VisibleSpikes) {
#ifdef DEBUG_CULL_FACE
int loop;
for (loop = 0; loop < 20; loop++)
mp->MaterialColor[loop] = MaterialGray;
#endif
glDisable(GL_CULL_FACE);
} else {
#ifdef DEBUG_CULL_FACE
int loop;
for (loop = 0; loop < 20; loop++)
mp->MaterialColor[loop] = MaterialWhite;
#endif
glEnable(GL_CULL_FACE);
}
mp->draw_object(mi);
glPopMatrix();
glFlush();
if (MI_IS_FPS(mi)) do_fps (mi);
glXSwapBuffers(display, window);
mp->step += 0.05;
}
void
init_eyes(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
EyeScrInfo *ep;
int i;
/*-
* Initialization that only needs to be done once. If the
* release hook is called, this stuff may be freed and this
* function will have to allocate it again next time the
* init hook is called.
*/
if (eye_info == NULL) {
if ((eye_info = (EyeScrInfo *) calloc(MI_NUM_SCREENS(mi),
sizeof (EyeScrInfo))) == NULL)
return;
}
ep = &eye_info[MI_SCREEN(mi)];
if (ep->flypix == None) {
getPixmap(mi, window, FLY_WIDTH, FLY_HEIGHT, FLY_BITS,
&(ep->flywidth), &(ep->flyheight), &(ep->flypix),
&(ep->graphics_format));
if (ep->flypix == None) {
free_eyes(display, ep);
return;
}
#ifdef XBM_GRELB
if (ep->graphics_format == IS_XBM) {
ep->graphics_format =0;
getPixmap(mi, window,
FLY2_WIDTH, FLY2_HEIGHT, FLY2_BITS,
&(ep->fly2width), &(ep->fly2height), &(ep->fly2pix),
&(ep->graphics_format));
if (ep->fly2pix == None) {
free_eyes(display, ep);
return;
}
}
#endif
}
if (ep->flyGC == None) {
XGCValues gcv;
gcv.foreground = MI_BLACK_PIXEL(mi);
gcv.background = MI_BLACK_PIXEL(mi);
if ((ep->flyGC = XCreateGC(display, window,
GCForeground | GCBackground, &gcv)) == None) {
free_eyes(display, ep);
return;
}
}
if (ep->eyeGC == None) {
if ((ep->eyeGC = XCreateGC(display, window,
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_eyes(display, ep);
return;
}
}
ep->time = 0;
/* don't want any exposure events from XCopyArea */
XSetGraphicsExposures(display, ep->eyeGC, False);
freePairsOfEyes(display, ep);
if (MI_IS_ICONIC(mi))
ep->num_eyes = 1;
else {
ep->num_eyes = MI_COUNT(mi);
/* MAX_EYES is used or one may quickly run out of memory */
if (ep->num_eyes > MAX_EYES)
ep->num_eyes = MAX_EYES;
if (ep->num_eyes < 0) {
if (ep->num_eyes < -MAX_EYES)
ep->num_eyes = NRAND(MAX_EYES) + 1;
else
ep->num_eyes = NRAND(-ep->num_eyes) + 1; /* Add 1 so its not too boring */
}
}
if (!ep->eyes) {
if ((ep->eyes = (Eyes *) calloc(ep->num_eyes, sizeof (Eyes))) == NULL) {
free_eyes(display, ep);
return;
}
}
for (i = 0; i < ep->num_eyes; i++) { /* place each eye pair */
/* don't assume None == 0 */
ep->eyes[i].pixmap = None;
create_eyes(mi, &(ep->eyes[i]), ep->eyes, ep->num_eyes);
}
init_fly(mi, &(ep->fly)); /* init the bouncer */
if (trackmouse && !ep->cursor) { /* Create an invisible cursor */
Pixmap bit;
XColor black;
black.red = 0;
black.green = 0;
black.blue = 0;
black.flags = DoRed | DoGreen | DoBlue;
if ((bit = XCreatePixmapFromBitmapData(display, window,
(char *) "\000", 1, 1, MI_BLACK_PIXEL(mi),
MI_BLACK_PIXEL(mi), 1)) == None) {
free_eyes(display, ep);
return;
}
if ((ep->cursor = XCreatePixmapCursor(display, bit, bit,
&black, &black, 0, 0)) == None) {
free_eyes(display, ep);
return;
}
XFreePixmap(display, bit);
}
XDefineCursor(display, window, ep->cursor);
MI_CLEARWINDOW(mi);
}
static void
paint_eyes(ModeInfo * mi, Eyes * e, Fly * f, Eyes * eyes, int num_eyes)
{
EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = ep->eyeGC;
Bool iconic = MI_IS_ICONIC(mi);
int focusx = (f->x + (f->width / 2)) - e->x;
int focusy = (f->y + (f->height / 2)) - e->y;
Pixmap pix = e->pixmap;
TPoint point;
int i;
if (pix == None) {
e->time_to_die = 0; /* "should not happen" */
}
if (ep->time >= e->time_to_die) {
/* Sorry Bud, your time is up */
if (e->painted) {
/* only unpaint it if previously painted */
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XFillRectangle(display, window, gc, e->x, e->y, e->width, e->height);
}
/* randomly place the eyes elsewhere */
create_eyes(mi, e, eyes, num_eyes);
pix = e->pixmap; /* pixmap may have changed */
}
/* If the bouncer would intersect this pair of eyes, force the
* eyes to move. This simplifies the code, because we do not
* have to deal with drawing the bouncer on top of the eyes.
* When trying to do so, there was too much annoying flashing
* and ghost images from the undraw. I decided to observe the
* KISS principle and keep it simple. I think the effect is
* better also.
* We must draw the flyer on the eyes when iconic, but that is
* easy because the eyes repaint the whole box each time.
*/
if ((!iconic) && (fly_touches_eye(f, e))) {
e->time_to_die = 0;
}
if (e->time_to_die == 0) {
return; /* collides with something */
}
/* set the point to look at and compute the pupil position */
point.x = Tx(focusx, focusy, &e->transform);
point.y = Ty(focusx, focusy, &e->transform);
computePupil(0, point, &(e->pupil[0]));
computePupil(1, point, &(e->pupil[1]));
if (e->painted) {
/* if still looking at the same point, do nothing further */
if (TPointEqual(e->pupil[0], e->last_pupil[0]) &&
TPointEqual(e->pupil[1], e->last_pupil[1])) {
return;
}
}
for (i = 0; i < 2; i++) {
/* update the eye, calculates the changed rectangle */
make_eye(mi, pix, e, i, False);
/* Only blit the change if the full image has been painted */
if (e->painted) {
/* copy the changed rectangle out to the screen */
XCopyArea(display, pix, window, gc,
e->bbox.x, e->bbox.y,
(int) e->bbox.width, (int) e->bbox.height,
e->x + e->bbox.x, e->y + e->bbox.y);
}
/* remember where we're looking, for the next time around */
e->last_pupil[i] = e->pupil[i];
}
/* always do full paint when iconic, eliminates need to track fly */
if (iconic || (!e->painted)) {
XCopyArea(display, pix, window, gc, 0, 0,
e->width, e->height, e->x, e->y);
}
/* when iconic, pretend to never paint, causes full paint each time */
if (!iconic) {
e->painted++; /* note that a paint has been done */
}
}
static void
create_eyes(ModeInfo * mi, Eyes * e, Eyes * eyes, int num_eyes)
{
EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int win_width = MI_WIDTH(mi);
int win_height = MI_HEIGHT(mi);
unsigned long black_pixel = MI_BLACK_PIXEL(mi);
unsigned long white_pixel = MI_WHITE_PIXEL(mi);
Bool iconic = MI_IS_ICONIC(mi);
Pixmap pix = e->pixmap; /* preserve pixmap handle */
int w = e->width; /* remember last w/h */
int h = e->height;
int npixels = MI_NPIXELS(mi); /* num colors in colormap */
int cycs = MI_CYCLES(mi); /* affects eye lifetime */
int maxw = win_width / 2; /* widest eyes can be */
int color, lid_color;
int i;
(void) memset((char *) e, 0, sizeof (Eyes)); /* wipe everything */
e->pixmap = pix; /* remember Pixmap handle */
/* sanity check the cycles value */
if (cycs < 1)
cycs = 1;
if (cycs > MAX_CYCLES)
cycs = MAX_CYCLES;
e->time_to_die = (unsigned long) LIFE_MIN + NRAND(LIFE_RANGE);
e->time_to_die *= (unsigned long) cycs; /* multiply life by cycles */
e->time_to_die += ep->time;
e->pupil_pixel = black_pixel; /* pupil is always black */
if (MI_NPIXELS(mi) <= 2) {
/* TODO: stipple the eyelid? */
e->eyelid_pixel = black_pixel;
e->eyeball_pixel = white_pixel;
} else {
lid_color = NRAND(npixels);
e->eyelid_pixel = MI_PIXEL(mi, lid_color);
while ((color = NRAND(npixels + 5)) == lid_color) {
/* empty */
}
if (color >= npixels) {
/* give white a little better chance */
e->eyeball_pixel = white_pixel;
} else {
e->eyeball_pixel = MI_PIXEL(mi, color);
}
}
if (iconic) {
/* only one pair of eyes, fills entire window */
e->width = win_width;
e->height = win_height;
} else {
if (maxw - MIN_EYE_SIZE > MIN_EYE_SIZE)
e->width = NRAND(maxw - MIN_EYE_SIZE) + MIN_EYE_SIZE;
else
e->width = NRAND(MIN_EYE_SIZE) + MIN_EYE_SIZE;
e->x = (win_width - e->width > 0) ? NRAND(win_width - e->width) : 0;
e->height = NRAND(e->width * 3 / 4) + (e->width / 4);
e->y = (win_height - e->height > 0) ? NRAND(win_height - e->height) : 0;
/* check for overlap with other eyes */
for (i = 0; i < num_eyes; i++) {
if (&eyes[i] == e) { /* that's me */
continue;
}
if (eyes_overlap(e, &eyes[i])) {
/* collision, force retry on next cycle */
e->time_to_die = 0;
break;
}
}
}
/* If the Pixmap is smaller than the new size, make it bigger */
if ((e->width > w) || (e->height > h)) {
if (e->pixmap != None) {
XFreePixmap(display, e->pixmap);
}
if ((e->pixmap = XCreatePixmap(display, window,
e->width, e->height, MI_DEPTH(mi))) == None) {
e->width = e->height = 0;
return;
}
}
/* Set the transformation matrix for this set of eyes
* If iconic, make the eyes image one pixel shorter and
* skinnier, they seem to fit in the icon box better that way.
*/
SetTransform(&e->transform, 0, (iconic) ? e->width - 1 : e->width,
(iconic) ? e->height - 1 : e->height, 0,
W_MIN_X, W_MAX_X, W_MIN_Y, W_MAX_Y);
/* clear the offscreen pixmap to background color */
XSetForeground(display, ep->eyeGC, black_pixel);
XFillRectangle(display, (Drawable) e->pixmap, ep->eyeGC, 0, 0, e->width, e->height);
/* make the full eye images in the offscreen Pixmap */
make_eye(mi, e->pixmap, e, 0, True);
make_eye(mi, e->pixmap, e, 1, True);
}
ENTRYPOINT void
draw_morph3d(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
morph3dstruct *mp;
if (morph3d == NULL)
return;
mp = &morph3d[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!mp->glx_context)
return;
mi->polygon_count = 0;
glXMakeCurrent(display, window, *(mp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.0, 0.0, -10.0);
if (!MI_IS_ICONIC(mi)) {
glScalef(Scale4Window * mp->WindH / mp->WindW, Scale4Window, Scale4Window);
glTranslatef(2.5 * mp->WindW / mp->WindH * sin(mp->step * 1.11), 2.5 * cos(mp->step * 1.25 * 1.11), 0);
} else {
glScalef(Scale4Iconic * mp->WindH / mp->WindW, Scale4Iconic, Scale4Iconic);
}
# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
{
GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
int o = (int) current_device_rotation();
if (o != 0 && o != 180 && o != -180)
glScalef (1/h, h, 1);
}
# endif
glRotatef(mp->step * 100, 1, 0, 0);
glRotatef(mp->step * 95, 0, 1, 0);
glRotatef(mp->step * 90, 0, 0, 1);
mp->seno = (sin(mp->step) + 1.0 / 3.0) * (4.0 / 5.0) * mp->Magnitude;
if (mp->VisibleSpikes) {
#ifdef DEBUG_CULL_FACE
int loop;
for (loop = 0; loop < 20; loop++)
mp->MaterialColor[loop] = MaterialGray;
#endif
glDisable(GL_CULL_FACE);
} else {
#ifdef DEBUG_CULL_FACE
int loop;
for (loop = 0; loop < 20; loop++)
mp->MaterialColor[loop] = MaterialWhite;
#endif
glEnable(GL_CULL_FACE);
}
mp->draw_object(mi);
glPopMatrix();
if (MI_IS_FPS(mi)) do_fps (mi);
glXSwapBuffers(display, window);
mp->step += 0.05;
}
ENTRYPOINT void
init_rotor (ModeInfo * mi)
{
int x;
elem *pelem;
unsigned char wasiconified;
rotorstruct *rp;
if (rotors == NULL) {
if ((rotors = (rotorstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (rotorstruct))) == NULL)
return;
}
rp = &rotors[MI_SCREEN(mi)];
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
#endif
rp->prevcenterx = rp->centerx;
rp->prevcentery = rp->centery;
rp->centerx = MI_WIDTH(mi) / 2;
rp->centery = MI_HEIGHT(mi) / 2;
rp->redrawing = 0;
/*
* sometimes, you go into iconified view, only to see a really whizzy pattern
* that you would like to look more closely at. Normally, clicking in the
* icon reinitializes everything - but I don't, cuz I'm that kind of guy.
* HENCE, the wasiconified stuff you see here.
*/
wasiconified = rp->iconifiedscreen;
rp->iconifiedscreen = MI_IS_ICONIC(mi);
if (wasiconified && !rp->iconifiedscreen)
rp->firsttime = True;
else {
/* This is a fudge is needed since prevcenter may not be set when it comes
from the the random mode and return is pressed (and its not the first
mode that was running). This assumes that the size of the lock screen
window / size of the icon window = 12 */
if (!rp->prevcenterx)
rp->prevcenterx = rp->centerx * 12;
if (!rp->prevcentery)
rp->prevcentery = rp->centery * 12;
rp->num = MI_COUNT(mi);
if (rp->num < 0) {
rp->num = NRAND(-rp->num) + 1;
if (rp->elements != NULL) {
(void) free((void *) rp->elements);
rp->elements = (elem *) NULL;
}
}
if (rp->elements == NULL)
if ((rp->elements = (elem *) calloc(rp->num,
sizeof (elem))) == NULL) {
free_rotor(rp);
return;
}
rp->nsave = MI_CYCLES(mi);
if (rp->nsave <= 1)
rp->nsave = 2;
if (rp->save == NULL)
if ((rp->save = (XPoint *) malloc(rp->nsave *
sizeof (XPoint))) == NULL) {
free_rotor(rp);
return;
}
for (x = 0; x < rp->nsave; x++) {
rp->save[x].x = rp->centerx;
rp->save[x].y = rp->centery;
}
pelem = rp->elements;
for (x = rp->num; --x >= 0; pelem++) {
pelem->radius_drift_max = 1.0;
pelem->radius_drift_now = 1.0;
pelem->end_radius = 100.0;
pelem->ratio_drift_max = 1.0;
pelem->ratio_drift_now = 1.0;
pelem->end_ratio = 10.0;
}
if (MI_NPIXELS(mi) > 2)
rp->pix = NRAND(MI_NPIXELS(mi));
rp->rotor = 0;
rp->prev = 1;
rp->lastx = rp->centerx;
rp->lasty = rp->centery;
rp->angle = (float) NRAND((long) MAXANGLE) / 3.0;
rp->forward = rp->firsttime = True;
}
rp->linewidth = MI_SIZE(mi);
if (rp->linewidth == 0)
rp->linewidth = 1;
if (rp->linewidth < 0)
rp->linewidth = NRAND(-rp->linewidth) + 1;
MI_CLEARWINDOW(mi);
}
void
draw_molecule (ModeInfo *mi)
{
/* static time_t last = 0; */
time_t now = time ((time_t *) 0);
molecule_configuration *mc;
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (mcs == NULL)
return;
mc = &mcs[MI_SCREEN(mi)];
if (!mc->glx_context)
return;
MI_IS_DRAWN(mi) = True;
if (last + timeout <= now) /* randomize molecules every -timeout seconds */
{
if (mc->nmolecules == 1)
{
if (last != 0) goto SKIP;
mc->which = 0;
}
else if (last == 0)
{
mc->which = NRAND(mc->nmolecules);
}
else
{
int n = mc->which;
while (n == mc->which)
n = NRAND(mc->nmolecules);
mc->which = n;
}
last = now;
glNewList (mc->molecule_dlist, GL_COMPILE);
ensure_bounding_box_visible (mi);
if (MI_IS_ICONIC(mi))
{do_labels = False;
do_bonds = True;
do_titles = False;
}
else
{
do_labels = orig_do_labels;
do_bonds = orig_do_bonds;
do_titles = orig_do_titles;
}
cur_wire = orig_wire;
if (mc->molecule_size > mc->no_label_threshold)
do_labels = 0;
if (mc->molecule_size > mc->wireframe_threshold)
cur_wire = 1;
if (cur_wire)
do_bonds = 1;
build_molecule (mi);
glEndList();
}
SKIP:
glPushMatrix ();
glScalef(1.1, 1.1, 1.1);
{
GLfloat x, y, z;
if (do_wander)
{
static int frame = 0;
# define SINOID(SCALE,SIZE) \
((((1 + sin((frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2)
x = SINOID(0.031, 9.0);
y = SINOID(0.023, 9.0);
z = SINOID(0.017, 9.0);
frame++;
glTranslatef(x, y, z);
}
if (mc->spin_x || mc->spin_y || mc->spin_z)
{
x = mc->rotx;
y = mc->roty;
z = mc->rotz;
if (x < 0) x = 1 - (x + 1);
if (y < 0) y = 1 - (y + 1);
if (z < 0) z = 1 - (z + 1);
if (mc->spin_x) glRotatef(x * 360, 1.0, 0.0, 0.0);
if (mc->spin_y) glRotatef(y * 360, 0.0, 1.0, 0.0);
if (mc->spin_z) glRotatef(z * 360, 0.0, 0.0, 1.0);
rotate(&mc->rotx, &mc->dx, &mc->ddx, mc->d_max, MI_IS_VERBOSE(mi));
rotate(&mc->roty, &mc->dy, &mc->ddy, mc->d_max, MI_IS_VERBOSE(mi));
rotate(&mc->rotz, &mc->dz, &mc->ddz, mc->d_max, MI_IS_VERBOSE(mi));
}
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glCallList (mc->molecule_dlist);
glPopMatrix ();
if (MI_IS_FPS(mi)) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
