ENTRYPOINT void change_projectiveplane(ModeInfo *mi)
{
projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)];
if (!pp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi),MI_WINDOW(mi),*(pp->glx_context));
init(mi);
}
ENTRYPOINT void change_antinspect(ModeInfo * mi)
{
antinspectstruct *mp = &antinspect[MI_SCREEN(mi)];
if (!mp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(mp->glx_context));
pinit();
}
ENTRYPOINT void
draw_blocktube (ModeInfo *mi)
{
blocktube_configuration *lp = &lps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
entity *cEnt = NULL;
int loop = 0;
if (!lp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(lp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (do_texture) {
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glBindTexture(GL_TEXTURE_2D, lp->envTexture);
}
for (loop = 0; loop < MAX_ENTITIES; loop++) {
cEnt = &lp->entities[loop];
glLoadIdentity();
glTranslatef(0.0f, 0.0f, lp->zoom);
glRotatef(lp->tilt, 1.0f, 0.0f, 0.0f);
glRotatef(cEnt->angle, 0.0f, 0.0f, 1.0f);
glTranslatef(cEnt->position[0], cEnt->position[1], cEnt->position[2]);
glColor4ub((int)(lp->currentR * cEnt->tVal),
(int)(lp->currentG * cEnt->tVal),
(int)(lp->currentB * cEnt->tVal), 255);
draw_block(mi, cEnt);
entityTick(lp, cEnt);
}
tick(lp);
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
ENTRYPOINT Bool
sponge_handle_event (ModeInfo *mi, XEvent *event)
{
sponge_configuration *sp = &sps[MI_SCREEN(mi)];
if (gltrackball_event_handler (event, sp->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&sp->button_down_p))
return True;
else if (event->xany.type == KeyPress)
{
KeySym keysym;
char c = 0;
XLookupString (&event->xkey, &c, 1, &keysym, 0);
if (c == '+' || c == '=' ||
keysym == XK_Up || keysym == XK_Right || keysym == XK_Next)
{
sp->draw_tick = speed;
sp->current_depth += (sp->current_depth > 0 ? 1 : -1);
sp->current_depth--;
return True;
}
else if (c == '-' || c == '_' ||
keysym == XK_Down || keysym == XK_Left || keysym == XK_Prior)
{
sp->draw_tick = speed;
sp->current_depth -= (sp->current_depth > 0 ? 1 : -1);
sp->current_depth--;
return True;
}
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
goto DEF;
}
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
DEF:
sp->draw_tick = speed;
return True;
}
return False;
}
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
draw_fadeplot (ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
int i, j, temp;
fadeplotstruct *fp;
if (fadeplots == NULL)
return;
fp = &fadeplots[MI_SCREEN(mi)];
if (fp->stab == NULL)
return;
MI_IS_DRAWN(mi) = True;
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XDrawPoints(display, window, gc, fp->pts, fp->maxpts, CoordModeOrigin);
if (MI_NPIXELS(mi) > 2) {
XSetForeground(display, gc, MI_PIXEL(mi, fp->pix));
if (++fp->pix >= MI_NPIXELS(mi))
fp->pix = 0;
} else
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
temp = 0;
for (j = 0; j < fp->nbstep; j++) {
for (i = 0; i < fp->maxpts / fp->nbstep; i++) {
fp->pts[temp].x =
fp->stab[(fp->st.x + fp->speed.x * j + i * fp->step.x) % fp->angles] *
fp->factor.x + fp->width / 2 - fp->min;
fp->pts[temp].y =
fp->stab[(fp->st.y + fp->speed.y * j + i * fp->step.y) % fp->angles] *
fp->factor.y + fp->height / 2 - fp->min;
temp++;
}
}
XDrawPoints(display, window, gc, fp->pts, temp, CoordModeOrigin);
fp->st.x = (fp->st.x + fp->speed.x) % fp->angles;
fp->st.y = (fp->st.y + fp->speed.y) % fp->angles;
fp->temps++;
if ((fp->temps % (fp->angles / 2)) == 0) {
fp->temps = fp->temps % fp->angles * 5;
if ((fp->temps % (fp->angles)) == 0)
fp->speed.y = (fp->speed.y + 1) % 30 + 1;
if ((fp->temps % (fp->angles * 2)) == 0)
fp->speed.x = (fp->speed.x) % 20;
if ((fp->temps % (fp->angles * 3)) == 0)
fp->step.y = (fp->step.y + 1) % 2 + 1;
MI_CLEARWINDOW(mi);
}
}
ENTRYPOINT void
free_unicrud (ModeInfo *mi)
{
unicrud_configuration *bp = &bps[MI_SCREEN(mi)];
if (!bp->glx_context) return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *bp->glx_context);
if (bp->trackball) gltrackball_free (bp->trackball);
if (bp->rot) free_rotator (bp->rot);
if (bp->title_font) free_texture_font (bp->title_font);
if (bp->char_font) free_texture_font (bp->char_font);
}
ENTRYPOINT void
init_atlantis(ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
atlantisstruct *ap;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (atlantis == NULL) {
if ((atlantis = (atlantisstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (atlantisstruct))) == NULL)
return;
}
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
change_atlantis(ModeInfo * mi)
{
atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
if (!ap->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(ap->glx_context));
Init(mi);
}
ENTRYPOINT void
change_moebius (ModeInfo * mi)
{
moebiusstruct *mp = &moebius[MI_SCREEN(mi)];
if (!mp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(mp->glx_context));
pinit(mi);
}
ENTRYPOINT void
draw_stonerview (ModeInfo *mi)
{
stonerview_configuration *bp = &bps[MI_SCREEN(mi)];
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
glPushMatrix ();
gltrackball_rotate (bp->trackball);
win_draw(bp->st);
if (! bp->button_down_p)
move_increment(bp->st);
glPopMatrix ();
mi->polygon_count = NUM_ELS;
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(MI_DISPLAY (mi), MI_WINDOW(mi));
}
ENTRYPOINT void
change_pipes (ModeInfo * mi)
{
pipesstruct *pp = &pipes[MI_SCREEN(mi)];
if (!pp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(pp->glx_context));
pinit(mi, 1);
}
ENTRYPOINT void
change_stairs (ModeInfo * mi)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
if (!sp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(sp->glx_context));
pinit();
}
ENTRYPOINT Bool
hop_handle_event (ModeInfo *mi, XEvent *event)
{
if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
MI_CLEARWINDOW(mi);
init_hop (mi);
return True;
}
return False;
}
void
draw_blot(ModeInfo * mi)
{
blotstruct *bp;
XPoint *xp;
int x, y, k;
if (blots == NULL)
return;
bp = &blots[MI_SCREEN(mi)];
xp = bp->pointBuffer;
if (xp == NULL)
init_blot(mi);
MI_IS_DRAWN(mi) = True;
if (MI_NPIXELS(mi) > 2) {
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_PIXEL(mi, bp->pix));
if (++bp->pix >= MI_NPIXELS(mi))
bp->pix = 0;
}
x = bp->xmid;
y = bp->ymid;
k = bp->size;
while (k >= 4) {
x += (NRAND(1 + (bp->offset << 1)) - bp->offset);
y += (NRAND(1 + (bp->offset << 1)) - bp->offset);
k--;
xp->x = x;
xp->y = y;
xp++;
if (bp->xsym) {
k--;
xp->x = bp->width - x;
xp->y = y;
xp++;
}
if (bp->ysym) {
k--;
xp->x = x;
xp->y = bp->height - y;
xp++;
}
if (bp->xsym && bp->ysym) {
k--;
xp->x = bp->width - x;
xp->y = bp->height - y;
xp++;
}
}
XDrawPoints(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
bp->pointBuffer, (bp->size - k), CoordModeOrigin);
if (++bp->count > MI_CYCLES(mi))
init_blot(mi);
}
ENTRYPOINT void
change_cage (ModeInfo * mi)
{
cagestruct *cp = &cage[MI_SCREEN(mi)];
if (!cp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(cp->glx_context));
pinit(mi);
}
static void DrawEllipse(ModeInfo * mi, dropstruct *drop, unsigned long color)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
int w = 2 * drop->radius;
int h = (drop->radius * 2) / 3;
XSetForeground(display, gc, color);
XDrawArc(display, window, gc,
drop->drop.x - w, drop->drop.y - h, 2 * w + 1, 2 * h + 1, 0, 360 * 64);
}
static void
draw_line(ModeInfo * mi, XPoint * points, int number, GC to_use, int offset)
{
int i;
for (i = 0; i < number - 1; i++) {
if (points[i].y <= points[i + 1].y)
XDrawLine(MI_DISPLAY(mi), MI_WINDOW(mi), to_use, points[i].x + offset,
points[i].y, points[i + 1].x + offset, points[i + 1].y);
else {
if (points[i].x < points[i + 1].x)
XDrawLine(MI_DISPLAY(mi), MI_WINDOW(mi), to_use, points[i].x +
offset, points[i].y + offset, points[i + 1].x + offset,
points[i + 1].y + offset);
else
XDrawLine(MI_DISPLAY(mi), MI_WINDOW(mi), to_use, points[i].x -
offset, points[i].y + offset, points[i + 1].x - offset,
points[i + 1].y + offset);
}
}
}
static void
startup_blurb (ModeInfo *mi)
{
molecule_configuration *mc = &mcs[MI_SCREEN(mi)];
const char *s = "Constructing molecules...";
print_gl_string (mi->dpy, mc->xfont3, mc->font3_dlist,
mi->xgwa.width, mi->xgwa.height,
10, mi->xgwa.height - 10,
s, False);
glFinish();
glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
}
ENTRYPOINT void
draw_noof (ModeInfo *mi)
{
int i;
noof_configuration *bp = &bps[MI_SCREEN(mi)];
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
mi->polygon_count = 0;
/**
if((random() & 0xff) == 0x34){
glClear(GL_COLOR_BUFFER_BIT);
}
if((tko & 0x1f) == 0x1f){
glEnable(GL_BLEND);
glColor4f(0.0, 0.0, 0.0, 0.09);
glRectf(0.0, 0.0, wd, ht);
glDisable(GL_BLEND);
#ifdef __sgi
sginap(0);
#endif
}
*/
gravity(bp, -2.0);
for (i = 0; i < N_SHAPES; i++) {
motionUpdate(bp, i);
colorUpdate(bp, i);
mi->polygon_count += drawleaf(bp, i);
}
if (mi->fps_p) do_fps (mi);
glFinish();
if (dbuf_p)
glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
}
void
init_galaxy(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
unistruct *gp;
if (universes == NULL) {
if ((universes = (unistruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (unistruct))) == NULL)
return;
}
gp = &universes[MI_SCREEN(mi)];
gp->f_hititerations = MI_CYCLES(mi);
gp->clip.left = 0;
gp->clip.top = 0;
gp->clip.right = MI_WIDTH(mi);
gp->clip.bottom = MI_HEIGHT(mi);
gp->scale = (double) (gp->clip.right + gp->clip.bottom) / 8.0;
gp->midx = gp->clip.right / 2;
gp->midy = gp->clip.bottom / 2;
if (MI_IS_FULLRANDOM(mi)) {
gp->fisheye = !(NRAND(3));
if (!gp->fisheye)
gp->tracks = (Bool) (LRAND() & 1);
} else {
gp->fisheye = fisheye;
gp->tracks = tracks;
}
if (!startover(mi))
return;
if (gp->fisheye) {
if (gp->pixmap != None)
XFreePixmap(display, gp->pixmap);
if ((gp->pixmap = XCreatePixmap(display, MI_WINDOW(mi),
MI_WIDTH(mi), MI_HEIGHT(mi),
MI_DEPTH(mi))) == None) {
gp->fisheye = False;
}
}
if (gp->fisheye) {
XSetGraphicsExposures(display, MI_GC(mi), False);
gp->scale *= Z_OFFSET;
gp->star_scale_Z = (gp->scale * .005);
/* don't want any exposure events from XCopyPlane */
}
}
void
init_gasket(ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
gasketstruct *gp;
if (gasket == NULL)
{
if ((gasket = (gasketstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (gasketstruct))) == NULL)
return;
}
gp = &gasket[screen];
gp->window = MI_WINDOW(mi);
gp->rotx = FLOATRAND(1.0) * RANDSIGN();
gp->roty = FLOATRAND(1.0) * RANDSIGN();
gp->rotz = FLOATRAND(1.0) * RANDSIGN();
/* bell curve from 0-1.5 degrees, avg 0.75 */
gp->dx = (FLOATRAND(1) + FLOATRAND(1) + FLOATRAND(1)) / (360*2);
gp->dy = (FLOATRAND(1) + FLOATRAND(1) + FLOATRAND(1)) / (360*2);
gp->dz = (FLOATRAND(1) + FLOATRAND(1) + FLOATRAND(1)) / (360*2);
gp->d_max = gp->dx * 2;
gp->ddx = 0.00006 + FLOATRAND(0.00003);
gp->ddy = 0.00006 + FLOATRAND(0.00003);
gp->ddz = 0.00006 + FLOATRAND(0.00003);
gp->ddx = 0.00001;
gp->ddy = 0.00001;
gp->ddz = 0.00001;
intens_factor = intensity / 65536000.0;
gp->ncolors = 255;
gp->colors = (XColor *) calloc(gp->ncolors, sizeof(XColor));
make_smooth_colormap (mi, None,
gp->colors, &gp->ncolors,
False, (Bool *) NULL);
if ((gp->glx_context = init_GL(mi)) != NULL)
{
reshape_gasket(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
pinit(mi);
}
else
{
MI_CLEARWINDOW(mi);
}
}
static void
drawcell(ModeInfo * mi, int col, int row, unsigned char state)
{
dragonstruct *dp = &dragons[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
GC gc;
if (!state) {
XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
gc = MI_GC(mi);
} else if (state == 1) {
XSetForeground(display, MI_GC(mi), MI_BLACK_PIXEL(mi));
gc = MI_GC(mi);
} else if (MI_NPIXELS(mi) > 2) {
XSetForeground(display, MI_GC(mi), dp->color);
gc = MI_GC(mi);
} else {
XGCValues gcv;
gcv.stipple = dp->graypix;
gcv.foreground = MI_WHITE_PIXEL(mi);
gcv.background = MI_BLACK_PIXEL(mi);
XChangeGC(display, dp->stippledGC,
GCStipple | GCForeground | GCBackground, &gcv);
gc = dp->stippledGC;
}
{
int ccol = 2 * col + !(row & 1), crow = 2 * row;
dp->hexagon[0].x = dp->xb + ccol * dp->xs;
dp->hexagon[0].y = dp->yb + crow * dp->ys;
if (dp->xs == 1 && dp->ys == 1)
XDrawPoint(display, MI_WINDOW(mi),
gc, dp->hexagon[0].x, dp->hexagon[0].y);
else
XFillPolygon(display, MI_WINDOW(mi), gc,
dp->hexagon, 6, Convex, CoordModePrevious);
}
}
static void
tik_tak_drawobject(ModeInfo * mi, tik_takobject * object0 )
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
tik_takstruct *tiktak = &tik_taks[MI_SCREEN(mi)];
XFillPolygon(display, window, tiktak->gc, object0->xy ,
object0->num_point * 2 + 2 , Complex , CoordModeOrigin);
if ( object0->inner )
XFillPolygon(display, window, tiktak->gc, object0->xy1 ,
object0->num_point1 * 2 + 2 , Complex , CoordModeOrigin);
}
static void
startup_blurb (ModeInfo *mi)
{
molecule_configuration *mc = &mcs[MI_SCREEN(mi)];
const char *s = "Constructing molecules...";
print_title_string (mi, s,
MI_WIDTH(mi) - (string_width (mc->xfont2, s) + 40),
10 + mc->xfont2->ascent + mc->xfont2->descent,
mc->xfont2->ascent + mc->xfont2->descent);
glFinish();
glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
firstcall = False;
}
static void
fillcell(ModeInfo * mi, GC gc, int col, int row)
{
antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
if (ap->neighbors == 6) {
int ccol = 2 * col + !(row & 1), crow = 2 * row;
ap->shape.hexagon[0].x = ap->xb + ccol * ap->xs;
ap->shape.hexagon[0].y = ap->yb + crow * ap->ys;
if (ap->xs == 1 && ap->ys == 1)
XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
ap->shape.hexagon[0].x, ap->shape.hexagon[0].y);
else
XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
ap->shape.hexagon, 6, Convex, CoordModePrevious);
} else if (ap->neighbors == 4 || ap->neighbors == 8) {
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
ap->xb + ap->xs * col, ap->yb + ap->ys * row,
ap->xs - (ap->xs > 3), ap->ys - (ap->ys > 3));
} else { /* TRI */
int orient = (col + row) % 2; /* O left 1 right */
ap->shape.triangle[orient][0].x = ap->xb + col * ap->xs;
ap->shape.triangle[orient][0].y = ap->yb + row * ap->ys;
if (ap->xs <= 3 || ap->ys <= 3)
XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
((orient) ? -1 : 1) + ap->shape.triangle[orient][0].x,
ap->shape.triangle[orient][0].y);
else {
if (orient)
ap->shape.triangle[orient][0].x += (ap->xs / 2 - 1);
else
ap->shape.triangle[orient][0].x -= (ap->xs / 2 - 1);
XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
ap->shape.triangle[orient], 3, Convex, CoordModePrevious);
}
}
}
ENTRYPOINT void release_wip24(ModeInfo *mi) {
wip24_state* state = states + MI_SCREEN(mi);
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(state->glx_context));
for (unsigned int i = 0; i < 4; i++)
glDeleteTextures(1, &state->channels[i].texture);
glDeleteFramebuffers(1, &state->framebuffer);
glDeleteTextures(1, &state->fb_texture);
glDeleteProgram(state->program);
free_texture_font(state->font);
glXDestroyContext(MI_DISPLAY(mi), *state->glx_context);
free(state->glx_context);
}
void
release_molecule(ModeInfo * mi)
{
if (mcs != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
molecule_configuration *mc = &mcs[screen];
#if 0
int i;
for (i = 0; i < mc->nmolecules; i++) {
molecule *m = &mc->molecules[i];
if (m->atoms) {
free(m->atoms);
m->atoms = (molecule_atom *) NULL;
}
if (m->bonds) {
free(m->bonds);
m->bonds = (molecule_bond *) NULL;
}
if (m->label) {
free(m->label);
m->label = (char *) NULL;
}
}
if (mc->molecules) {
free(mc->molecules);
mc->molecules = (molecule *) NULL;
}
#endif
if (mc->glx_context) {
/* Display lists MUST be freed while their glXContext is current. */
#ifdef WIN32
wglMakeCurrent(hdc, mc->glx_context);
#else
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(mc->glx_context));
#endif
/* Free font stuff */
free_fonts (mi);
}
}
free(mcs);
mcs = (molecule_configuration *) NULL;
}
FreeAllGL(mi);
}
static void
loading_msg (ModeInfo *mi, int n)
{
carousel_state *ss = &sss[MI_SCREEN(mi)];
int wire = MI_IS_WIREFRAME(mi);
char text[100];
GLfloat scale;
if (wire) return;
if (n == 0)
sprintf (text, "Loading images...");
else
sprintf (text, "Loading images... (%d%%)",
(int) (n * 100 / MI_COUNT(mi)));
if (ss->loading_sw == 0) /* only do this once, so that the string doesn't move. */
ss->loading_sw = texture_string_width (ss->texfont, text, &ss->loading_sh);
scale = ss->loading_sh / (GLfloat) MI_HEIGHT(mi);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, MI_WIDTH(mi), 0, MI_HEIGHT(mi));
glTranslatef ((MI_WIDTH(mi) - ss->loading_sw) / 2,
(MI_HEIGHT(mi) - ss->loading_sh) / 2,
0);
glColor3f (1, 1, 0);
glEnable (GL_TEXTURE_2D);
glDisable (GL_DEPTH_TEST);
print_texture_string (ss->texfont, text);
glEnable (GL_DEPTH_TEST);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glFinish();
glXSwapBuffers (MI_DISPLAY (mi), MI_WINDOW(mi));
}
ENTRYPOINT void draw_pulsar(ModeInfo * mi)
{
pulsarstruct *gp = &Pulsar[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!gp->glx_context)
return;
glXMakeCurrent(display, window, *gp->glx_context);
drawScene(mi);
if (mi->fps_p) do_fps (mi);
glXSwapBuffers(display, window);
}
