ENTRYPOINT void
draw_voronoi (ModeInfo *mi)
{
voronoi_configuration *vp = &vps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!vp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(vp->glx_context));
glShadeModel(GL_FLAT);
glEnable(GL_POINT_SMOOTH);
/* glEnable(GL_LINE_SMOOTH);*/
/* glEnable(GL_POLYGON_SMOOTH);*/
glEnable (GL_DEPTH_TEST);
glDepthFunc (GL_LEQUAL);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mi->polygon_count = 0;
draw_cells (mi);
move_points (vp);
prune_points (vp);
state_change (mi);
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
/*
*-----------------------------------------------------------------------------
* Called by the mainline code periodically to update the display.
*-----------------------------------------------------------------------------
*/
ENTRYPOINT void draw_hypertorus(ModeInfo *mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
hypertorusstruct *hp;
if (hyper == NULL)
return;
hp = &hyper[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!hp->glx_context)
return;
glXMakeCurrent(display,window,*(hp->glx_context));
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
display_hypertorus(mi);
if (MI_IS_FPS(mi))
do_fps (mi);
glFlush();
glXSwapBuffers(display,window);
}
/*
*-----------------------------------------------------------------------------
* Called by the mainline code periodically to update the display.
*-----------------------------------------------------------------------------
*/
ENTRYPOINT void
draw_atlantis(ModeInfo * mi)
{
atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
MI_IS_DRAWN(mi) = True;
if (!ap->glx_context)
return;
glXMakeCurrent(display, window, *(ap->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(current_device_rotation(), 0, 0, 1);
AllDisplay(ap);
Animate(ap);
glPopMatrix();
if (mi->fps_p) do_fps (mi);
glXSwapBuffers(display, window);
}
ENTRYPOINT void draw_screenflip(ModeInfo *mi)
{
Screenflip *c = &screenflip[MI_SCREEN(mi)];
Window w = MI_WINDOW(mi);
Display *disp = MI_DISPLAY(mi);
if (!c->glx_context)
return;
/* Wait for the first image; for subsequent images, load them in the
background while animating. */
if (c->waiting_for_image_p && c->first_image_p)
return;
glXMakeCurrent(disp, w, *c->glx_context);
glBindTexture(GL_TEXTURE_2D, c->texid);
if (c->regrab)
getSnapshot(mi);
display(c, MI_IS_WIREFRAME(mi));
if(mi->fps_p) do_fps(mi);
glFinish();
glXSwapBuffers(disp, w);
}
/* draw the extrusion once */
ENTRYPOINT void
draw_extrusion(ModeInfo * mi)
{
extrusionstruct *gp = &Extrusion[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
static const GLfloat color[4] = {0.6, 0.6, 0.4, 1.0};
/* static const GLfloat spec[4] = {0.6, 0.6, 0.6, 1.0}; */
/* static const GLfloat shiny = 40.0; */
double x, y, z;
if (!gp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(gp->glx_context));
glPushMatrix();
gltrackball_rotate (gp->trackball);
get_rotation (gp->rot, &x, &y, &z,
!(gp->button_down_p || gp->button2_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);
/* track the mouse only if a button is down. */
if (gp->button2_down_p)
{
gp->mouse_dx += gp->mouse_x - gp->mouse_start_x;
gp->mouse_dy += gp->mouse_y - gp->mouse_start_y;
gp->mouse_start_x = gp->mouse_x;
gp->mouse_start_y = gp->mouse_y;
}
{
float scale = (max_lastx - min_lastx);
get_position (gp->rot, &x, &y, &z,
!(gp->button_down_p || gp->button2_down_p));
lastx = x * scale + min_lastx + gp->mouse_dx;
lasty = y * scale + min_lasty + gp->mouse_dy;
}
glScalef(0.5, 0.5, 0.5);
/* glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec); */
/* glMateriali (GL_FRONT_AND_BACK, GL_SHININESS, shiny); */
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glFrontFace(GL_CCW);
funcs_ptr[gp->extrusion_number].DrawStuff();
glPopMatrix();
if (mi->fps_p) do_fps (mi);
glXSwapBuffers(display, window);
}
ENTRYPOINT void
draw_bubble3d(ModeInfo * mi)
{
struct context *c = &contexts[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
MI_IS_DRAWN(mi) = True;
if (!c->glx_context)
return;
glXMakeCurrent(display, window, *(c->glx_context));
glb_config.polygon_count = 0;
glPushMatrix();
glRotatef(current_device_rotation(), 0, 0, 1);
do_display(c);
glPopMatrix();
mi->polygon_count = glb_config.polygon_count;
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
void
draw_gasket(ModeInfo * mi)
{
gasketstruct *gp = &gasket[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int angle_incr = 1;
if (!gp->glx_context) return;
glDrawBuffer(GL_BACK);
if (max_depth > 10)
max_depth = 10;
MI_IS_DRAWN(mi) = True;
glXMakeCurrent(display, window, *(gp->glx_context));
draw(mi);
/* rotate */
gp->angle = (int) (gp->angle + angle_incr) % 360;
rotate(&gp->rotx, &gp->dx, &gp->ddx, gp->d_max, MI_IS_VERBOSE(mi));
rotate(&gp->roty, &gp->dy, &gp->ddy, gp->d_max, MI_IS_VERBOSE(mi));
rotate(&gp->rotz, &gp->dz, &gp->ddz, gp->d_max, MI_IS_VERBOSE(mi));
/* if (mi->fps_p) do_fps (mi); */
if (MI_IS_FPS(mi)) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
ENTRYPOINT void
draw_ball (ModeInfo *mi)
{
ball_configuration *bp = &bps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glRotatef(current_device_rotation(), 0, 0, 1);
{
double x, y, z;
get_position (bp->rot, &x, &y, &z, !bp->button_down_p);
glTranslatef((x - 0.5) * 6,
(y - 0.5) * 6,
(z - 0.5) * 2);
gltrackball_rotate (bp->trackball);
get_rotation (bp->rot, &x, &y, &z, !bp->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);
}
mi->polygon_count = 0;
glRotatef (50, 1, 0, 0);
glScalef (4, 4, 4);
glRotatef (bp->th, 0, 0, 1);
if (! bp->button_down_p)
{
bp->th += (bp->th > 0 ? speed : -speed);
while (bp->th > 360) bp->th -= 360;
while (bp->th < -360) bp->th += 360;
}
mi->polygon_count += draw_ball_1 (mi);
glPopMatrix ();
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
ENTRYPOINT void
draw_glschool(ModeInfo *mi)
{
Window window = MI_WINDOW(mi);
Display *dpy = MI_DISPLAY(mi);
glschool_configuration *sc = &scs[MI_SCREEN(mi)];
if (!sc->context) {
fprintf(stderr, "no context\n");
return;
}
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(sc->context));
if ((sc->goalCounter % GoalChgFreq) == 0)
newGoal(sc->school);
sc->goalCounter++;
sc->rotCounter++;
sc->rotCounter = (sc->rotCounter%360);
applyMovements(sc->school);
drawSchool(sc->colors, sc->school, sc->bboxList, sc->goalList, sc->fishList, sc->rotCounter, sc->drawGoal, sc->drawBBox);
computeAccelerations(sc->school);
if (mi->fps_p)
do_fps(mi);
glFinish();
glXSwapBuffers(dpy, window);
}
/*
*-----------------------------------------------------------------------------
* Called by the mainline code periodically to update the display.
*-----------------------------------------------------------------------------
*/
ENTRYPOINT void draw_projectiveplane(ModeInfo *mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
projectiveplanestruct *pp;
if (projectiveplane == NULL)
return;
pp = &projectiveplane[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!pp->glx_context)
return;
glXMakeCurrent(display,window,*(pp->glx_context));
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
display_projectiveplane(mi);
if (MI_IS_FPS(mi))
do_fps (mi);
glFlush();
glXSwapBuffers(display,window);
}
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_antinspect(ModeInfo * mi)
{
antinspectstruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!antinspect)
return;
mp = &antinspect[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();
mi->polygon_count = 0;
/* position camera --- this works well, we can peer inside
the antbubble */
glTranslatef(0.0, 0.0, -10.0);
# 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, 1/h, 1/h);
glRotatef(o, 0, 0, 1);
}
# endif
gltrackball_rotate(mp->trackball);
glRotatef((15.0/2.0 + 15.0*sin(mp->ant_step/100.0)), 1.0, 0.0, 0.0);
glRotatef(30.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
if (!draw_antinspect_strip(mi)) {
MI_ABORT(mi);
return;
}
glPopMatrix();
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
mp->step += 0.025;
}
ENTRYPOINT void draw_jigglypuff(ModeInfo *mi)
{
jigglystruct *js = &jss[MI_SCREEN(mi)];
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(js->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-10);
# 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, 1/h, 1/h);
}
# endif
glRotatef(js->angle, sin(js->axis), cos(js->axis), -sin(js->axis));
glTranslatef(0, 0, 5);
if(!(js->button_down)) {
if((js->angle += js->speed) >= 360.0f ) {
js->angle -= 360.0f;
}
if((js->axis+=0.01f) >= 2*M_PI ) {
js->axis -= 2*M_PI;
}
}
gltrackball_rotate(js->trackball);
if(js->color_style == COLOR_STYLE_CYCLE) {
int i;
vector_add(js->jiggly_color, js->color_dir, js->jiggly_color);
for(i=0; i<3; i++) {
if(js->jiggly_color[i] > 1.0 || js->jiggly_color[i] < 0.3) {
js->color_dir[i] = (-js->color_dir[i]);
js->jiggly_color[i] += js->color_dir[i];
}
}
glColor4fv(js->jiggly_color);
}
mi->polygon_count = jigglypuff_render(js);
if(MI_IS_FPS(mi))
do_fps(mi);
glFinish();
update_shape(js);
glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
}
ENTRYPOINT void
draw_boing (ModeInfo *mi)
{
boing_configuration *bp = &bps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
mi->polygon_count = 0;
glShadeModel(GL_SMOOTH);
glEnable(GL_NORMALIZE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (! bp->button_down_p)
tick_physics (mi);
glPushMatrix ();
gltrackball_rotate (bp->trackball);
glLightfv (GL_LIGHT0, GL_POSITION, bp->lightpos);
glDisable (GL_CULL_FACE);
glDisable (GL_DEPTH_TEST);
glEnable (GL_LINE_SMOOTH);
glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
draw_box (mi);
draw_shadow (mi);
glEnable (GL_CULL_FACE);
glEnable (GL_DEPTH_TEST);
draw_ball (mi);
if (scanlines_p)
draw_scanlines (mi);
glPopMatrix ();
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
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);
}
ENTRYPOINT void draw_antspotlight(ModeInfo * mi)
{
antspotlightstruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!antspotlight)
return;
mp = &antspotlight[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if(!mp->glx_context)
return;
/* Just keep running before the texture has come in. */
/* if (mp->waiting_for_image_p) return; */
glXMakeCurrent(display, window, *(mp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
/* position camera */
/* follow focused ant */
glTranslatef(0.0, 0.0, -6.0 - mp->mag);
glRotatef(35.0, 1.0, 0.0, 0.0);
gltrackball_rotate(mp->trackball);
glTranslatef(-mp->ant->position[0], mp->ant->position[1], -mp->ant->position[2]);
/* stable position */
/* glTranslatef(0.0, 0.0, -10.0 - mag); */
/* gltrackball_rotate(mp->trackball); */
/* glRotatef(40.0, 1.0, 0.0, 0.0); */
/* glRotatef(20.0, 0.0, 1.0, 0.0); */
draw_antspotlight_strip(mi);
++mp->ticks;
glPopMatrix();
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
}
ENTRYPOINT void
draw_hexstrut (ModeInfo *mi)
{
hexstrut_configuration *bp = &bps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
glShadeModel(GL_SMOOTH);
glDisable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glDisable(GL_CULL_FACE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
{
double x, y, z;
get_position (bp->rot, &x, &y, &z, !bp->button_down_p);
glTranslatef((x - 0.5) * 6,
(y - 0.5) * 6,
(z - 0.5) * 12);
gltrackball_rotate (bp->trackball);
get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p);
glRotatef (z * 360, 0.0, 0.0, 1.0);
}
mi->polygon_count = 0;
glScalef (30, 30, 30);
if (! bp->button_down_p)
tick_triangles (mi);
draw_triangles (mi);
glPopMatrix ();
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
ENTRYPOINT void
draw_cube (ModeInfo *mi)
{
cube_configuration *bp = &bps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glRotatef(current_device_rotation(), 0, 0, 1);
gltrackball_rotate (bp->trackball);
glScalef (2, 2, 2);
mi->polygon_count = 0;
# if 0
{
floater F;
F.x = F.y = F.z = 0;
F.dx = F.dy = F.dz = 0;
F.ddx = F.ddy = F.ddz = 0;
F.rot = make_rotator (0, 0, 0, 1, 0, False);
glRotatef (45, 0, 1, 0);
draw_floater (mi, &F);
}
# else
for (i = 0; i < bp->nfloaters; i++)
{
floater *f = &bp->floaters[i];
draw_floater (mi, f);
tick_floater (mi, f);
}
# endif
glPopMatrix ();
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
ENTRYPOINT void draw_providence(ModeInfo * mi)
{
providencestruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!providence)
return;
mp = &providence[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();
/* modify camera */
if(fabs(mp->camera_velocity) > EPSILON) {
mp->camera_z = max(min(mp->camera_z + 0.1*mp->camera_velocity, -4.0), -12.0);
mp->camera_velocity = 0.95*mp->camera_velocity;
}
/* rotate providence */
glTranslatef(0.0, 0.0, mp->camera_z + sin(mp->theta/4.0));
glRotatef(10.0+20.0*sin(mp->theta/2.0), 1.0, 0.0, 0.0);
gltrackball_rotate(mp->trackball);
glRotatef(mp->theta * 180.0 / Pi, 0.0, -1.0, 0.0);
/* draw providence */
draw_providence_strip(mi);
glPopMatrix();
if(MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
/* update */
mp->currenttime += 1.0 / FPS;
mp->theta = mp->currenttime / 2.0 * mp->theta_scale;
update_particles(mp);
}
ENTRYPOINT void draw_jigglypuff(ModeInfo *mi)
{
jigglystruct *js = &jss[MI_SCREEN(mi)];
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(js->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-10);
glRotatef(js->angle, sin(js->axis), cos(js->axis), -sin(js->axis));
glTranslatef(0, 0, 5);
if(!(js->button_down)) {
if((js->angle += js->speed) >= 360.0f ) {
js->angle -= 360.0f;
}
if((js->axis+=0.01f) >= 2*M_PI ) {
js->axis -= 2*M_PI;
}
}
/* Do it twice because we don't track the device's orientation. */
glRotatef( current_device_rotation(), 0, 0, 1);
gltrackball_rotate(js->trackball);
glRotatef(-current_device_rotation(), 0, 0, 1);
if(js->color_style == COLOR_STYLE_CYCLE) {
int i;
vector_add(js->jiggly_color, js->color_dir, js->jiggly_color);
for(i=0; i<3; i++) {
if(js->jiggly_color[i] > 1.0 || js->jiggly_color[i] < 0.3) {
js->color_dir[i] = (-js->color_dir[i]);
js->jiggly_color[i] += js->color_dir[i];
}
}
glColor4fv(js->jiggly_color);
}
mi->polygon_count = jigglypuff_render(js);
if(MI_IS_FPS(mi))
do_fps(mi);
glFinish();
update_shape(js);
glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
}
ENTRYPOINT void draw_antinspect(ModeInfo * mi)
{
antinspectstruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!antinspect)
return;
mp = &antinspect[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();
glRotatef(current_device_rotation(), 0, 0, 1);
mi->polygon_count = 0;
/* position camera --- this works well, we can peer inside
the antbubble */
glTranslatef(0.0, 0.0, -10.0);
gltrackball_rotate(mp->trackball);
glRotatef((15.0/2.0 + 15.0*sin(mp->ant_step/100.0)), 1.0, 0.0, 0.0);
glRotatef(30.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
if (!draw_antinspect_strip(mi)) {
release_antinspect(mi);
return;
}
glPopMatrix();
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
mp->step += 0.025;
}
ENTRYPOINT void
draw_hydrostat (ModeInfo *mi)
{
hydrostat_configuration *bp = &bps[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
if (!bp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glScalef (0.03, 0.03, 0.03);
# ifdef USE_TRACKBALL
gltrackball_rotate (bp->trackball);
# endif
mi->polygon_count = 0;
if (opacity_arg < 1.0)
qsort (bp->squids, MI_COUNT(mi), sizeof(*bp->squids), cmp_squid);
for (i = 0; i < MI_COUNT(mi); i++)
{
squid *sq = bp->squids[i];
move_squid (mi, sq);
draw_squid (mi, sq);
if (opacity_arg < 1.0)
glClear (GL_DEPTH_BUFFER_BIT);
}
if (! (random() % 700)) /* Reverse the flow every now and then */
current_arg = -current_arg;
glPopMatrix ();
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
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;
}
ENTRYPOINT void draw_commander(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
commander_conf *cp = &commander[MI_SCREEN(mi)];
if (!cp->glx_context) return;
/*MI_IS_DRAWN(mi) = True;*/
glXMakeCurrent(display, window, *(cp->glx_context));
if (!draw_main(cp)) {
release_commander(mi);
return;
}
mi->polygon_count = cp->npoints;
if (MI_IS_FPS(mi)) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
ENTRYPOINT void draw_queens(ModeInfo *mi)
{
Queenscreen *qs = &qss[MI_SCREEN(mi)];
Window w = MI_WINDOW(mi);
Display *disp = MI_DISPLAY(mi);
if(!qs->glx_context)
return;
glXMakeCurrent(disp, w, *(qs->glx_context));
mi->polygon_count = display(qs);
if(mi->fps_p) do_fps(mi);
glFinish();
glXSwapBuffers(disp, w);
}
ENTRYPOINT void
draw_klein(ModeInfo * mi)
{
kleinstruct *kp = &klein[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!kp->glx_context) return;
glDrawBuffer(GL_BACK);
glXMakeCurrent(display, window, *(kp->glx_context));
draw(mi);
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
ENTRYPOINT void draw_cubicgrid(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
cubicgrid_conf *cp;
if (!cubicgrid) return;
cp = &cubicgrid[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if (!cp->glx_context) return;
glXMakeCurrent(display, window, *(cp->glx_context));
if (!draw_main(cp)) {
release_cubicgrid(mi);
return;
}
if (MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
}
/* draw the gflux once */
ENTRYPOINT void draw_gflux(ModeInfo * mi)
{
gfluxstruct *gp = &gfluxes[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!gp->glx_context) return;
/* Just keep running before the texture has come in. */
/* if (gp->waiting_for_image_p) return; */
glXMakeCurrent(display, window, *(gp->glx_context));
calcGrid(gp);
mi->polygon_count = gp->drawFunc(gp);
if (mi->fps_p) do_fps (mi);
glXSwapBuffers(display, window);
}
ENTRYPOINT void
draw_superquadrics(ModeInfo * mi)
{
superquadricsstruct *sp = &superquadrics[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!sp->glx_context)
return;
glXMakeCurrent(display, window, *(sp->glx_context));
mi->polygon_count = NextSuperquadricDisplay(sp);
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
ENTRYPOINT void draw_bang (ModeInfo *mi)
{
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GLfloat camx, camz;
float r = 10.0;
int LightPos[4] = {-10,0,0,1};
int MatSpec [4] = {1,1,1,1};
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bang->glx_context));
glMaterialiv(GL_FRONT_AND_BACK,GL_SPECULAR,MatSpec);
glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,100);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* set camera position */
camx = r*sin(bang->alpha) + 0.5;
camz = r*cos(bang->alpha) + 0.5;
bang->alpha += 0.01;
if (bang->alpha == 360)
{
bang->alpha = 0;
}
gluLookAt(camx, 0.0, camz, 0.0, 0.0, 0.0, 0, 1, 0);
glLightiv(GL_LIGHT0, GL_POSITION, LightPos);
/* gluLookAt(10, 0.0, 10, 0, 0, 0, 0, 1, 0);*/
glPushMatrix ();
drawsphere(0.1, 0.0, 0.0, 0.0);
drawsphere(0.5, 3.0, 0.0, 0.0);
drawsphere(1.0, 6.0, 0.0, 0.0);
glPopMatrix ();
if (MI_IS_FPS(mi)) do_fps (mi);
glXSwapBuffers(dpy, window);
}
