X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=hacks%2Fglx%2Fdangerball.c;fp=hacks%2Fglx%2Fdangerball.c;h=2dca4e0303a371816b6175b941c16953a742b157;hb=a445bdd3e3ba4abbee441844b6665b4c3c13d48c;hp=0000000000000000000000000000000000000000;hpb=3d9140a05b5272fed0883a0af0a71e30ef44d47f;p=xscreensaver diff --git a/hacks/glx/dangerball.c b/hacks/glx/dangerball.c new file mode 100644 index 00000000..2dca4e03 --- /dev/null +++ b/hacks/glx/dangerball.c @@ -0,0 +1,547 @@ +/* dangerball, Copyright (c) 2001 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#include + +extern XtAppContext app; + +#define PROGCLASS "DangerBall" +#define HACK_INIT init_ball +#define HACK_DRAW draw_ball +#define HACK_RESHAPE reshape_ball +#define sws_opts xlockmore_opts + +#define DEF_SPIN "True" +#define DEF_WANDER "True" +#define DEF_SPEED "0.05" + +#define DEFAULTS "*delay: 30000 \n" \ + "*count: 30 \n" \ + "*showFPS: False \n" \ + "*wireframe: False \n" \ + "*speed: " DEF_SPEED " \n" \ + "*spin: " DEF_SPIN "\n" \ + "*wander: " DEF_WANDER "\n" \ + + +#define SPHERE_SLICES 32 /* how densely to render spheres */ +#define SPHERE_STACKS 16 + + +#define SPIKE_FACES 12 /* how densely to render spikes */ + + +#undef countof +#define countof(x) (sizeof((x))/sizeof((*x))) + +#include "xlockmore.h" +#include "colors.h" +#include + +#ifdef USE_GL /* whole file */ + +#ifdef HAVE_UNAME +# include +#endif /* HAVE_UNAME */ + + +#include +#include "glutstroke.h" +#include "glut_roman.h" +#define GLUT_FONT (&glutStrokeRoman) + + +typedef struct { + GLXContext *glx_context; + + GLfloat rotx, roty, rotz; /* current object rotation */ + GLfloat dx, dy, dz; /* current rotational velocity */ + GLfloat ddx, ddy, ddz; /* current rotational acceleration */ + GLfloat d_max; /* max velocity */ + + GLuint ball_list; + GLuint spike_list; + + GLfloat pos; + int *spikes; + + int ncolors; + XColor *colors; + int ccolor; + int color_shift; + +} ball_configuration; + +static ball_configuration *bps = NULL; + +static char *do_spin; +static GLfloat speed; +static Bool do_wander; + +static XrmOptionDescRec opts[] = { + { "-spin", ".spin", XrmoptionNoArg, "True" }, + { "+spin", ".spin", XrmoptionNoArg, "False" }, + { "-speed", ".speed", XrmoptionSepArg, 0 }, + { "-wander", ".wander", XrmoptionNoArg, "True" }, + { "+wander", ".wander", XrmoptionNoArg, "False" } +}; + +static argtype vars[] = { + {(caddr_t *) &do_spin, "spin", "Spin", DEF_SPIN, t_Bool}, + {(caddr_t *) &do_wander, "wander", "Wander", DEF_WANDER, t_Bool}, + {(caddr_t *) &speed, "speed", "Speed", DEF_SPEED, t_Float}, +}; + +ModeSpecOpt sws_opts = {countof(opts), opts, countof(vars), vars, NULL}; + + + +static void +unit_spike (Bool wire) +{ + int i; + int faces = SPIKE_FACES; + GLfloat step = M_PI * 2 / faces; + GLfloat th; + + glFrontFace(GL_CW); + glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN); + + glNormal3f(0, 1, 0); + glVertex3f(0, 1, 0); + for (i = 0, th = 0; i <= faces; i++) + { + GLfloat x = cos (th); + GLfloat y = sin (th); + glNormal3f(x, 0, y); + glVertex3f(x, 0, y); + if (wire) glVertex3f(0, 1, 0); + th += step; + } + glEnd(); +} + + +/* lifted from glplanet */ +/* Function for determining points on the surface of the sphere */ +static void +parametric_sphere (float theta, float rho, GLfloat *vector) +{ + vector[0] = -sin(theta) * sin(rho); + vector[1] = cos(theta) * sin(rho); + vector[2] = cos(rho); +} + +/* lifted from glplanet */ +static void +unit_sphere (Bool wire) +{ + int stacks = SPHERE_STACKS; + int slices = SPHERE_SLICES; + + int i, j; + float drho, dtheta; + float rho, theta; + GLfloat vector[3]; + GLfloat ds, dt, t, s; + + if (!wire) + glShadeModel(GL_SMOOTH); + + /* Generate a sphere with quadrilaterals. + * Quad vertices are determined using a parametric sphere function. + * For fun, you could generate practically any parameteric surface and + * map an image onto it. + */ + drho = M_PI / stacks; + dtheta = 2.0 * M_PI / slices; + ds = 1.0 / slices; + dt = 1.0 / stacks; + + glFrontFace(GL_CCW); + glBegin( wire ? GL_LINE_LOOP : GL_QUADS ); + + t = 0.0; + for (i=0; i < stacks; i++) { + rho = i * drho; + s = 0.0; + for (j=0; j < slices; j++) { + theta = j * dtheta; + + glTexCoord2f (s,t); + parametric_sphere (theta, rho, vector); + glNormal3fv (vector); + parametric_sphere (theta, rho, vector); + glVertex3f (vector[0], vector[1], vector[2]); + + glTexCoord2f (s,t+dt); + parametric_sphere (theta, rho+drho, vector); + glNormal3fv (vector); + parametric_sphere (theta, rho+drho, vector); + glVertex3f (vector[0], vector[1], vector[2]); + + glTexCoord2f (s+ds,t+dt); + parametric_sphere (theta + dtheta, rho+drho, vector); + glNormal3fv (vector); + parametric_sphere (theta + dtheta, rho+drho, vector); + glVertex3f (vector[0], vector[1], vector[2]); + + glTexCoord2f (s+ds, t); + parametric_sphere (theta + dtheta, rho, vector); + glNormal3fv (vector); + parametric_sphere (theta + dtheta, rho, vector); + glVertex3f (vector[0], vector[1], vector[2]); + + s = s + ds; + } + t = t + dt; + } + glEnd(); +} + + + +/* Window management, etc + */ +void +reshape_ball (ModeInfo *mi, int width, int height) +{ + GLfloat h = (GLfloat) height / (GLfloat) width; + + glViewport (0, 0, (GLint) width, (GLint) height); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + + gluPerspective( 30.0, 1/h, 1.0, 100.0 ); + gluLookAt( 0.0, 0.0, 15.0, + 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -15.0); + + glClear(GL_COLOR_BUFFER_BIT); +} + + +static void +gl_init (ModeInfo *mi) +{ +/* ball_configuration *bp = &bps[MI_SCREEN(mi)]; */ + int wire = MI_IS_WIREFRAME(mi); + + static GLfloat pos[4] = {5.0, 5.0, 10.0, 1.0}; + + if (!wire) + { + glLightfv(GL_LIGHT0, GL_POSITION, pos); + glEnable(GL_CULL_FACE); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + } +} + + +/* lifted from lament.c */ +#define RAND(n) ((long) ((random() & 0x7fffffff) % ((long) (n)))) +#define RANDSIGN() ((random() & 1) ? 1 : -1) + +static void +rotate(GLfloat *pos, GLfloat *v, GLfloat *dv, GLfloat max_v) +{ + double ppos = *pos; + + /* tick position */ + if (ppos < 0) + ppos = -(ppos + *v); + else + ppos += *v; + + if (ppos > 1.0) + ppos -= 1.0; + else if (ppos < 0) + ppos += 1.0; + + if (ppos < 0) abort(); + if (ppos > 1.0) abort(); + *pos = (*pos > 0 ? ppos : -ppos); + + /* accelerate */ + *v += *dv; + + /* clamp velocity */ + if (*v > max_v || *v < -max_v) + { + *dv = -*dv; + } + /* If it stops, start it going in the other direction. */ + else if (*v < 0) + { + if (random() % 4) + { + *v = 0; + + /* keep going in the same direction */ + if (random() % 2) + *dv = 0; + else if (*dv < 0) + *dv = -*dv; + } + else + { + /* reverse gears */ + *v = -*v; + *dv = -*dv; + *pos = -*pos; + } + } + + /* Alter direction of rotational acceleration randomly. */ + if (! (random() % 120)) + *dv = -*dv; + + /* Change acceleration very occasionally. */ + if (! (random() % 200)) + { + if (*dv == 0) + *dv = 0.00001; + else if (random() & 1) + *dv *= 1.2; + else + *dv *= 0.8; + } +} + + +static void +randomize_spikes (ModeInfo *mi) +{ + ball_configuration *bp = &bps[MI_SCREEN(mi)]; + int i; + bp->pos = 0; + for (i = 0; i < MI_COUNT(mi); i++) + { + bp->spikes[i*2] = (random() % 360) - 180; + bp->spikes[i*2+1] = (random() % 180) - 90; + } + +# define ROT_SCALE 22 + for (i = 0; i < MI_COUNT(mi) * 2; i++) + bp->spikes[i] = (bp->spikes[i] / ROT_SCALE) * ROT_SCALE; + + if ((random() % 3) == 0) + bp->color_shift = random() % (bp->ncolors / 2); + else + bp->color_shift = 0; +} + +static void +draw_spikes (ModeInfo *mi) +{ + ball_configuration *bp = &bps[MI_SCREEN(mi)]; + GLfloat diam = 0.2; + GLfloat pos = bp->pos; + int i; + + if (pos < 0) pos = -pos; + + pos = (asin (0.5 + pos/2) - 0.5) * 2; + + for (i = 0; i < MI_COUNT(mi); i++) + { + glPushMatrix(); + glRotatef(bp->spikes[i*2], 0, 1, 0); + glRotatef(bp->spikes[i*2+1], 0, 0, 1); + glTranslatef(0.7, 0, 0); + glRotatef(-90, 0, 0, 1); + glScalef (diam, pos, diam); + glCallList (bp->spike_list); + glPopMatrix(); + } +} + + +static void +move_spikes (ModeInfo *mi) +{ + ball_configuration *bp = &bps[MI_SCREEN(mi)]; + + if (bp->pos >= 0) /* moving outward */ + { + bp->pos += speed; + if (bp->pos >= 1) /* reverse gears at apex */ + bp->pos = -1; + } + else /* moving inward */ + { + bp->pos += speed; + if (bp->pos >= 0) /* stop at end */ + randomize_spikes (mi); + } +} + + +void +init_ball (ModeInfo *mi) +{ + ball_configuration *bp; + int wire = MI_IS_WIREFRAME(mi); + + if (!bps) { + bps = (ball_configuration *) + calloc (MI_NUM_SCREENS(mi), sizeof (ball_configuration)); + if (!bps) { + fprintf(stderr, "%s: out of memory\n", progname); + exit(1); + } + + bp = &bps[MI_SCREEN(mi)]; + } + + bp = &bps[MI_SCREEN(mi)]; + + if ((bp->glx_context = init_GL(mi)) != NULL) { + gl_init(mi); + reshape_ball (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); + } + + bp->rotx = frand(1.0) * RANDSIGN(); + bp->roty = frand(1.0) * RANDSIGN(); + bp->rotz = frand(1.0) * RANDSIGN(); + + /* bell curve from 0-6 degrees, avg 3 */ + bp->dx = (frand(2) + frand(2) + frand(2)) / (360/2); + bp->dy = (frand(2) + frand(2) + frand(2)) / (360/2); + bp->dz = (frand(2) + frand(2) + frand(2)) / (360/2); + + bp->d_max = bp->dx * 2; + + bp->ddx = 0.00006 + frand(0.00003); + bp->ddy = 0.00006 + frand(0.00003); + bp->ddz = 0.00006 + frand(0.00003); + + 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 (wire); + glEndList (); + + glNewList (bp->spike_list, GL_COMPILE); + unit_spike (wire); + glEndList (); + + randomize_spikes (mi); +} + + +void +draw_ball (ModeInfo *mi) +{ + ball_configuration *bp = &bps[MI_SCREEN(mi)]; + Display *dpy = MI_DISPLAY(mi); + Window window = MI_WINDOW(mi); + int c2; + + static GLfloat color1[4] = {0.0, 0.0, 0.0, 1.0}; + static GLfloat color2[4] = {0.0, 0.0, 0.0, 1.0}; + + if (!bp->glx_context) + return; + + glShadeModel(GL_SMOOTH); + + glEnable(GL_DEPTH_TEST); + glEnable(GL_NORMALIZE); + glEnable(GL_CULL_FACE); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + 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.051, 8.0); + y = SINOID(0.037, 8.0); + z = SINOID(0.131, 13.0); + frame++; + glTranslatef(x, y, z); + } + + if (do_spin) + { + x = bp->rotx; + y = bp->roty; + z = bp->rotz; + if (x < 0) x = 1 - (x + 1); + if (y < 0) y = 1 - (y + 1); + if (z < 0) z = 1 - (z + 1); + + 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); + + rotate(&bp->rotx, &bp->dx, &bp->ddx, bp->d_max); + rotate(&bp->roty, &bp->dy, &bp->ddy, bp->d_max); + rotate(&bp->rotz, &bp->dz, &bp->ddz, bp->d_max); + } + } + + color1[0] = bp->colors[bp->ccolor].red / 65536.0; + color1[1] = bp->colors[bp->ccolor].green / 65536.0; + color1[2] = bp->colors[bp->ccolor].blue / 65536.0; + + c2 = (bp->ccolor + bp->color_shift) % bp->ncolors; + color2[0] = bp->colors[c2].red / 65536.0; + color2[1] = bp->colors[c2].green / 65536.0; + color2[2] = bp->colors[c2].blue / 65536.0; + + bp->ccolor++; + if (bp->ccolor >= bp->ncolors) bp->ccolor = 0; + + glScalef (2.0, 2.0, 2.0); + + move_spikes (mi); + + glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color1); + glCallList (bp->ball_list); + + glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color2); + draw_spikes (mi); + glPopMatrix (); + + if (mi->fps_p) do_fps (mi); + glFinish(); + + glXSwapBuffers(dpy, window); +} + +#endif /* USE_GL */