X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?p=xscreensaver;a=blobdiff_plain;f=hacks%2Fglx%2Fkaleidocycle.c;fp=hacks%2Fglx%2Fkaleidocycle.c;h=025e45b40f284c9cca869b59e8c535adc1dda79f;hp=0000000000000000000000000000000000000000;hb=4ade52359b6eba3621566dac79793a33aa4c915f;hpb=ff35d056d723c9a5ffe728dbba5f1c25e141be04 diff --git a/hacks/glx/kaleidocycle.c b/hacks/glx/kaleidocycle.c new file mode 100644 index 00000000..025e45b4 --- /dev/null +++ b/hacks/glx/kaleidocycle.c @@ -0,0 +1,566 @@ +/* kaleidocycle, Copyright (c) 2013 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. + * + * A loop of rotating tetrahedra. Created by jwz, July 2013. + * Inspired by, and some math borrowed from: + * http://www.kaleidocycles.de/pdf/kaleidocycles_theory.pdf + * http://intothecontinuum.tumblr.com/post/50873970770/an-even-number-of-at-least-8-regular-tetrahedra + */ + + +#define DEFAULTS "*delay: 30000 \n" \ + "*count: 16 \n" \ + "*showFPS: False \n" \ + "*wireframe: False \n" \ + +# define refresh_kaleidocycle 0 +# define release_kaleidocycle 0 +#undef countof +#define countof(x) (sizeof((x))/sizeof((*x))) + +#include "xlockmore.h" +#include "colors.h" +#include "normals.h" +#include "rotator.h" +#include "gltrackball.h" +#include + +#ifdef USE_GL /* whole file */ + +#define DEF_SPIN "Z" +#define DEF_WANDER "False" +#define DEF_SPEED "1.0" + +typedef struct { + GLXContext *glx_context; + rotator *rot, *rot2; + trackball_state *trackball; + Bool button_down_p; + + int min_count, max_count; + Bool startup_p; + + int ncolors; + XColor *colors; + int ccolor; + + GLfloat count; + GLfloat th, dth; + + enum { STATIC, IN, OUT } mode, prev_mode; + +} kaleidocycle_configuration; + +static kaleidocycle_configuration *bps = NULL; + +static char *do_spin; +static GLfloat speed; +static Bool do_wander; + +static XrmOptionDescRec opts[] = { + { "-spin", ".spin", XrmoptionSepArg, 0 }, + { "+spin", ".spin", XrmoptionNoArg, "" }, + { "-wander", ".wander", XrmoptionNoArg, "True" }, + { "+wander", ".wander", XrmoptionNoArg, "False" }, + { "-speed", ".speed", XrmoptionSepArg, 0 }, +}; + +static argtype vars[] = { + {&do_spin, "spin", "Spin", DEF_SPIN, t_String}, + {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool}, + {&speed, "speed", "Speed", DEF_SPEED, t_Float}, +}; + +ENTRYPOINT ModeSpecOpt kaleidocycle_opts = {countof(opts), opts, countof(vars), vars, NULL}; + + + +/* Window management, etc + */ +ENTRYPOINT void +reshape_kaleidocycle (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); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + gluLookAt( 0.0, 0.0, 30.0, + 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0); + + glClear(GL_COLOR_BUFFER_BIT); +} + + +ENTRYPOINT Bool +kaleidocycle_handle_event (ModeInfo *mi, XEvent *event) +{ + kaleidocycle_configuration *bp = &bps[MI_SCREEN(mi)]; + + if (event->xany.type == ButtonPress && + event->xbutton.button == Button1) + { + bp->button_down_p = True; + gltrackball_start (bp->trackball, + event->xbutton.x, event->xbutton.y, + MI_WIDTH (mi), MI_HEIGHT (mi)); + return True; + } + else if (event->xany.type == ButtonRelease && + event->xbutton.button == Button1) + { + bp->button_down_p = False; + return True; + } + else if (event->xany.type == ButtonPress && + (event->xbutton.button == Button4 || + event->xbutton.button == Button5 || + event->xbutton.button == Button6 || + event->xbutton.button == Button7)) + { + gltrackball_mousewheel (bp->trackball, event->xbutton.button, 5, + !!event->xbutton.state); + return True; + } + else if (event->xany.type == MotionNotify && + bp->button_down_p) + { + gltrackball_track (bp->trackball, + event->xmotion.x, event->xmotion.y, + MI_WIDTH (mi), MI_HEIGHT (mi)); + return True; + } + + return False; +} + + + +ENTRYPOINT void +init_kaleidocycle (ModeInfo *mi) +{ + kaleidocycle_configuration *bp; + int wire = MI_IS_WIREFRAME(mi); + int i; + + if (!bps) { + bps = (kaleidocycle_configuration *) + calloc (MI_NUM_SCREENS(mi), sizeof (kaleidocycle_configuration)); + if (!bps) { + fprintf(stderr, "%s: out of memory\n", progname); + exit(1); + } + } + + bp = &bps[MI_SCREEN(mi)]; + + bp->glx_context = init_GL(mi); + + reshape_kaleidocycle (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); + + glLineWidth (4); + + if (!wire) + { + GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0}; + GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0}; + GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0}; + GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0}; + + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + glEnable(GL_CULL_FACE); + + glLightfv(GL_LIGHT0, GL_POSITION, pos); + glLightfv(GL_LIGHT0, GL_AMBIENT, amb); + glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); + glLightfv(GL_LIGHT0, GL_SPECULAR, spc); + + glEnable (GL_BLEND); + glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } + + { + Bool spinx = False, spiny = False, spinz = False; + double spin_speed = 0.25; + double wander_speed = 0.005; + double spin_accel = 0.2; + double twist_speed = 0.25; + double twist_accel = 1.0; + + char *s = do_spin; + while (*s) + { + if (*s == 'x' || *s == 'X') spinx = True; + else if (*s == 'y' || *s == 'Y') spiny = True; + else if (*s == 'z' || *s == 'Z') spinz = True; + else if (*s == '0') ; + else + { + fprintf (stderr, + "%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n", + progname, do_spin); + exit (1); + } + s++; + } + + bp->rot = make_rotator (spinx ? spin_speed : 0, + spiny ? spin_speed : 0, + spinz ? spin_speed : 0, + spin_accel, + do_wander ? wander_speed : 0, + False); + bp->rot2 = make_rotator (twist_speed, 0, 0, twist_accel, 0, True); + + bp->trackball = gltrackball_init (); + } + + if (MI_COUNT(mi) < 8) MI_COUNT(mi) = 8; + if (MI_COUNT(mi) & 1) MI_COUNT(mi)++; + + bp->min_count = 8; + bp->max_count = 12 + MI_COUNT(mi) * 1.3; + if (bp->max_count & 1) bp->max_count++; + bp->startup_p = True; + + bp->count = 0; + bp->mode = IN; + bp->prev_mode = IN; + +/* + bp->count = MI_COUNT(mi); + bp->mode = STATIC; +*/ + + bp->ncolors = 512; + if (! bp->colors) + bp->colors = (XColor *) calloc(bp->ncolors, sizeof(XColor)); + make_uniform_colormap (0, 0, 0, + bp->colors, &bp->ncolors, + False, 0, False); + + for (i = 0; i < bp->ncolors; i++) + { + /* make colors twice as bright */ + bp->colors[i].red = (bp->colors[i].red >> 2) + 0x7FFF; + bp->colors[i].green = (bp->colors[i].green >> 2) + 0x7FFF; + bp->colors[i].blue = (bp->colors[i].blue >> 2) + 0x7FFF; + } + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); +} + + + +/* t = toroidal rotation, a = radial position + colors = 4 colors, 4 channels each. + */ +static void +draw_tetra (ModeInfo *mi, double t, double a, Bool reflect_p, + GLfloat *colors) +{ + int wire = MI_IS_WIREFRAME(mi); + + XYZ v1, v2, v3, P, Q; + XYZ verts[4]; + int i; + + double scale; + double sint = sin(t); + double cost = cos(t); + double tana = tan(a); + double sint2 = sint * sint; + double tana2 = tana * tana; + + v1.x = cost; + v1.y = 0; + v1.z = sint; + + scale = 1 / sqrt (1 + sint2 * tana2); + v2.x = scale * -sint; + v2.y = scale * -sint * tana; + v2.z = scale * cost; + + v3.x = scale * -sint2 * tana; + v3.y = scale; + v3.z = scale * cost * sint * tana; + + P.x = v3.y / tana - v3.x; + P.y = 0; + P.z = -v3.z / 2; + + Q.x = v3.y / tana; + Q.y = v3.y; + Q.z = v3.z / 2; + + verts[0] = P; + verts[1] = P; + verts[2] = Q; + verts[3] = Q; + + scale = sqrt(2) / 2; + verts[0].x = P.x - scale * v1.x; + verts[0].y = P.y - scale * v1.y; + verts[0].z = P.z - scale * v1.z; + + verts[1].x = P.x + scale * v1.x; + verts[1].y = P.y + scale * v1.y; + verts[1].z = P.z + scale * v1.z; + + verts[2].x = Q.x - scale * v2.x; + verts[2].y = Q.y - scale * v2.y; + verts[2].z = Q.z - scale * v2.z; + + verts[3].x = Q.x + scale * v2.x; + verts[3].y = Q.y + scale * v2.y; + verts[3].z = Q.z + scale * v2.z; + + for (i = 0; i < 4; i++) + { + Bool reflect2_p = ((i + (reflect_p != 0)) & 1); + XYZ a = verts[(i+1) % 4]; + XYZ b = verts[(i+2) % 4]; + XYZ c = verts[(i+3) % 4]; + XYZ n = ((i & 1) + ? calc_normal (b, a, c) + : calc_normal (a, b, c)); + if (wire) + glColor4fv (colors + (i * 4)); + else + glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colors + (i * 4)); + + glFrontFace (reflect2_p ? GL_CW : GL_CCW); + glBegin (wire ? GL_LINE_LOOP : GL_TRIANGLES); + glNormal3f (n.x, n.y, n.z); + glVertex3f (a.x, a.y, a.z); + glVertex3f (b.x, b.y, b.z); + glVertex3f (c.x, c.y, c.z); + glEnd(); + } +} + + +/* Reflect through the plane normal to the given vector. + */ +static void +reflect (double x, double y, double z) +{ + GLfloat m[4][4]; + + m[0][0] = 1 - (2 * x * x); + m[1][0] = -2 * x * y; + m[2][0] = -2 * x * z; + m[3][0] = 0; + + m[0][1] = -2 * x * y; + m[1][1] = 1 - (2 * y * y); + m[2][1] = -2 * y * z; + m[3][1] = 0; + + m[0][2] = -2 * x * z; + m[1][2] = -2 * y * z; + m[2][2] = 1 - (2 * z * z); + m[3][2] = 0; + + m[0][3] = 0; + m[1][3] = 0; + m[2][3] = 0; + m[3][3] = 1; + + glMultMatrixf (&m[0][0]); +} + + +ENTRYPOINT void +draw_kaleidocycle (ModeInfo *mi) +{ + kaleidocycle_configuration *bp = &bps[MI_SCREEN(mi)]; + Display *dpy = MI_DISPLAY(mi); + Window window = MI_WINDOW(mi); + GLfloat colors[4*4]; + GLfloat count; + double t, a; + int i; + + GLfloat bspec[4] = {1.0, 1.0, 1.0, 1.0}; + GLfloat bshiny = 128.0; + + if (!bp->glx_context) + return; + + glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context)); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + mi->polygon_count = 0; + + glShadeModel(GL_SMOOTH); + glEnable(GL_DEPTH_TEST); + glEnable(GL_NORMALIZE); + glEnable(GL_CULL_FACE); + + glPushMatrix (); + + { + double x, y, z; + get_position (bp->rot, &x, &y, &z, !bp->button_down_p); + glTranslatef((x - 0.5) * 5, + (y - 0.5) * 5, + (z - 0.5) * 10); + + /* Do it twice because we don't track the device's orientation. */ + glRotatef( current_device_rotation(), 0, 0, 1); + gltrackball_rotate (bp->trackball); + glRotatef(-current_device_rotation(), 0, 0, 1); + + get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p); + glRotatef (x * 360, 1, 0, 0); + glRotatef (y * 360, 0, 1, 0); + glRotatef (z * 360, 0, 0, 1); + + get_rotation (bp->rot2, &x, &y, &z, !bp->button_down_p); + bp->th = x * 360 * 10 * speed; + + /* Make sure the twist is always in motion. Without this, the rotator + sometimes stops, and for too long, and it's boring looking. + */ + bp->th += speed * bp->dth++; + while (bp->dth > 360) bp->dth -= 360; + while (bp->th > 360) bp->th -= 360; + } + + glMaterialfv (GL_FRONT, GL_SPECULAR, bspec); + glMateriali (GL_FRONT, GL_SHININESS, bshiny); + + + /* Evenly spread the colors of the faces, and cycle them together. + */ + for (i = 0; i < 4; i++) + { + int o = bp->ncolors / 4; + int c = (bp->ccolor + (o*i)) % bp->ncolors; + colors[i*4+0] = bp->colors[c].red / 65536.0; + colors[i*4+1] = bp->colors[c].green / 65536.0; + colors[i*4+2] = bp->colors[c].blue / 65536.0; + colors[i*4+3] = 1; + } + bp->ccolor++; + if (bp->ccolor >= bp->ncolors) bp->ccolor = 0; + + + count = (int) floor (bp->count); + while (count < 8) count++; + if (((int) floor (count)) & 1) count++; + + a = 2 * M_PI / (bp->count < 8 ? 8 : bp->count); + t = bp->th / (180 / M_PI); + + glScalef (3, 3, 3); + glScalef (a, a, a); + glRotatef (90, 0, 0, 1); +/* glRotatef (45, 0, 1, 0); */ + + for (i = 0; i <= (int) floor (bp->count); i++) + { + Bool flip_p = (i & 1); + glPushMatrix(); + glRotatef ((i/2) * 4 * 180 / bp->count, 0, 0, 1); + if (flip_p) reflect (-sin(a), cos(a), 0); + + if (bp->mode != STATIC && i >= (int) floor (bp->count)) + { + /* Fractional bp->count means the last piece is in transition */ + GLfloat scale = bp->count - (int) floor (bp->count); + GLfloat tick = 0.07 * speed; + GLfloat ocount = bp->count; + GLfloat alpha; + + /* Fill in faster if we're starting up */ + if (bp->count < MI_COUNT(mi)) + tick *= 2; + + glScalef (scale, scale, scale); + + switch (bp->mode) { + case IN: break; + case OUT: tick = -tick; break; + case STATIC: tick = 0; break; + } + + bp->count += tick; + + if (bp->mode == IN + ? floor (ocount) != floor (bp->count) + : ceil (ocount) != ceil (bp->count)) + { + if (bp->mode == IN) + bp->count = floor (ocount) + 1; + else + bp->count = ceil (ocount) - 1; + + if (((int) floor (bp->count)) & 1 || + (bp->mode == IN && + (bp->count < MI_COUNT(mi) && + bp->startup_p))) + { + /* keep going if it's odd, or less than 8. */ + bp->count = round(bp->count); + } + else + { + bp->mode = STATIC; + bp->startup_p = False; + } + } + + alpha = (scale * scale * scale * scale); + if (alpha < 0.4) alpha = 0.4; + colors[3] = colors[7] = colors[11] = colors[15] = alpha; + } + + draw_tetra (mi, t, a, flip_p, colors); + mi->polygon_count += 4; + + glPopMatrix(); + } + + if (bp->mode == STATIC && !(random() % 200)) { + if (bp->count <= bp->min_count) + bp->mode = IN; + else if (bp->count >= bp->max_count) + bp->mode = OUT; + else + bp->mode = bp->prev_mode; + + bp->prev_mode = bp->mode; + } + + + mi->recursion_depth = ceil (bp->count); + + glPopMatrix (); + + if (mi->fps_p) do_fps (mi); + glFinish(); + + glXSwapBuffers(dpy, window); +} + +XSCREENSAVER_MODULE ("Kaleidocycle", kaleidocycle) + +#endif /* USE_GL */