diff options
Diffstat (limited to 'hacks/glx/tronbit.c')
| -rw-r--r-- | hacks/glx/tronbit.c | 536 |
1 files changed, 536 insertions, 0 deletions
diff --git a/hacks/glx/tronbit.c b/hacks/glx/tronbit.c new file mode 100644 index 0000000..b79309c --- /dev/null +++ b/hacks/glx/tronbit.c @@ -0,0 +1,536 @@ +/* tronbit, Copyright (c) 2011-2014 Jamie Zawinski <jwz@jwz.org> + * + * 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. + */ + +#define DEFAULTS "*delay: 30000 \n" \ + "*count: 30 \n" \ + "*showFPS: False \n" \ + "*wireframe: False \n" + +# define free_bit 0 +# define release_bit 0 +#undef countof +#define countof(x) (sizeof((x))/sizeof((*x))) + +#include "xlockmore.h" +#include "colors.h" +#include "sphere.h" +#include "rotator.h" +#include "gltrackball.h" +#include <ctype.h> + +#ifdef USE_GL /* whole file */ + +#include "gllist.h" + +extern const struct gllist *tronbit_idle1, *tronbit_idle2, + *tronbit_no, *tronbit_yes; +static const struct gllist * const *all_objs[] = { + &tronbit_idle1, &tronbit_idle2, &tronbit_no, &tronbit_yes }; + + +#define DEF_SPIN "True" +#define DEF_WANDER "True" +#define DEF_SPEED "1.0" + +#define HISTORY_LENGTH 512 +typedef enum { BIT_IDLE1, BIT_IDLE2, BIT_NO, BIT_YES } bit_state; +#define MODELS 4 + + +typedef struct { + GLXContext *glx_context; + rotator *rot; + trackball_state *trackball; + Bool button_down_p; + + double frequency; + double confidence; + + double last_time; + unsigned char history [HISTORY_LENGTH]; + unsigned char histogram [HISTORY_LENGTH]; + int history_fp, histogram_fp; + + GLuint dlists[MODELS], polys[MODELS]; + char kbd; + +} bit_configuration; + +static bit_configuration *bps = NULL; + +static const GLfloat colors[][4] = { + { 0.66, 0.85, 1.00, 1.00 }, + { 0.66, 0.85, 1.00, 1.00 }, + { 1.00, 0.12, 0.12, 1.00 }, + { 0.98, 0.85, 0.30, 1.00 } +}; + + +static Bool 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[] = { + {&do_spin, "spin", "Spin", DEF_SPIN, t_Bool}, + {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool}, + {&speed, "speed", "Speed", DEF_SPEED, t_Float}, +}; + +ENTRYPOINT ModeSpecOpt bit_opts = {countof(opts), opts, countof(vars), vars, NULL}; + + +/* Returns the current time in seconds as a double. + */ +static double +double_time (void) +{ + struct timeval now; +# ifdef GETTIMEOFDAY_TWO_ARGS + struct timezone tzp; + gettimeofday(&now, &tzp); +# else + gettimeofday(&now); +# endif + + return (now.tv_sec + ((double) now.tv_usec * 0.000001)); +} + + +static int +make_bit (ModeInfo *mi, bit_state which) +{ + static const GLfloat spec[4] = {1.0, 1.0, 1.0, 1.0}; + static const GLfloat shiny = 128.0; + const GLfloat *color = colors[which]; + int wire = MI_IS_WIREFRAME(mi); + int polys = 0; + GLfloat s; + const struct gllist *gll; + + glMaterialfv (GL_FRONT, GL_SPECULAR, spec); + glMateriali (GL_FRONT, GL_SHININESS, shiny); + glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color); + glColor4f (color[0], color[1], color[2], color[3]); + + glPushMatrix(); + switch (which) + { + case BIT_IDLE1: + glRotatef (-44, 0, 1, 0); /* line up the models with each other */ + glRotatef (-11, 1, 0, 0); + glRotatef ( 8, 0, 0, 1); + s = 1.0; + break; + case BIT_IDLE2: + glRotatef ( 16.0, 0, 0, 1); + glRotatef (-28.0, 1, 0, 0); + s = 1.0; + break; + case BIT_NO: + glRotatef ( 16.0, 0, 0, 1); + glRotatef (-28.0, 1, 0, 0); + s = 1.6; + break; + case BIT_YES: + glRotatef (-44.0, 0, 1, 0); + glRotatef (-32.0, 1, 0, 0); + s = 1.53; + break; + default: + abort(); + break; + } + glScalef (s, s, s); + gll = *all_objs[which]; + renderList (gll, wire); + polys += gll->points / 3; + glPopMatrix(); + + return polys; +} + + +static void +tick_bit (ModeInfo *mi, double now) +{ + bit_configuration *bp = &bps[MI_SCREEN(mi)]; + double freq = bp->frequency; + int n = bp->history[bp->history_fp]; + int histogram_speed = 3 * speed; + int i; + + if (histogram_speed < 1) histogram_speed = 1; + + if (n == BIT_YES || n == BIT_NO) + freq *= 2; + + if (bp->button_down_p) return; + + for (i = 0; i < histogram_speed; i++) + { + int nn = (n == BIT_YES ? 240 : n == BIT_NO ? 17 : 128); + int on = bp->histogram[(bp->histogram_fp-1) % countof(bp->histogram)]; + + /* smooth out the square wave a little bit */ + + if (!(nn > 100 && nn < 200) != + !(on > 100 && on < 200)) + nn += (((random() % 48) - 32) * + ((on > 100 && on < 200) ? 1 : -1)); + + nn += (random() % 16) - 8; + + bp->histogram_fp++; + if (bp->histogram_fp >= countof(bp->history)) + bp->histogram_fp = 0; + bp->histogram [bp->histogram_fp] = nn; + } + + + if (bp->last_time + freq > now && !bp->kbd) return; + + bp->last_time = now; + + bp->history_fp++; + if (bp->history_fp >= countof(bp->history)) + bp->history_fp = 0; + + if (bp->kbd) + { + n = (bp->kbd == '1' ? BIT_YES : + bp->kbd == '0' ? BIT_NO : + (random() & 1) ? BIT_YES : BIT_NO); + bp->kbd = 0; + } + else if (n == BIT_YES || + n == BIT_NO || + frand(1.0) >= bp->confidence) + n = (n == BIT_IDLE1 ? BIT_IDLE2 : BIT_IDLE1); + else + n = (random() & 1) ? BIT_YES : BIT_NO; + + bp->history [bp->history_fp] = n; +} + + +static int +animate_bits (ModeInfo *mi, bit_state omodel, bit_state nmodel, GLfloat ratio) +{ + bit_configuration *bp = &bps[MI_SCREEN(mi)]; + int polys = 0; + GLfloat scale = sin (ratio * M_PI / 2); + GLfloat osize, nsize, small; + int wire = MI_IS_WIREFRAME(mi); + + glShadeModel(GL_SMOOTH); + + glEnable(GL_DEPTH_TEST); + glEnable(GL_NORMALIZE); + glEnable(GL_CULL_FACE); + + if (!wire) + { + glEnable(GL_LIGHTING); + glEnable(GL_DEPTH_TEST); + glEnable(GL_CULL_FACE); + } + + if ((omodel == BIT_IDLE1 || omodel == BIT_IDLE2) && + (nmodel == BIT_IDLE1 || nmodel == BIT_IDLE2)) + small = 0.9; + else + small = 0.5; + + nsize = small + (1 - small) * scale; + osize = small + (1 - small) * (1 - scale); + + glPushMatrix(); + glScalef (osize, osize, osize); + glCallList (bp->dlists [omodel]); + polys += bp->polys [omodel]; + glPopMatrix(); + + glPushMatrix(); + glScalef (nsize, nsize, nsize); + glCallList (bp->dlists [nmodel]); + polys += bp->polys [nmodel]; + glPopMatrix(); + + return polys; +} + + +static int +draw_histogram (ModeInfo *mi, GLfloat ratio) +{ + bit_configuration *bp = &bps[MI_SCREEN(mi)]; + int samples = countof (bp->histogram); + GLfloat scalex = (GLfloat) mi->xgwa.width / samples; + GLfloat scaley = mi->xgwa.height / 255.0 / 4; /* about 1/4th of screen */ + int polys = 0; + int overlays = 5; + int k; + + glDisable (GL_TEXTURE_2D); + glDisable (GL_LIGHTING); + glDisable (GL_BLEND); + glDisable (GL_DEPTH_TEST); + glDisable (GL_CULL_FACE); + + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + { + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + + glLoadIdentity(); + /* glRotatef(current_device_rotation(), 0, 0, 1); */ + glOrtho (0, mi->xgwa.width, 0, mi->xgwa.height, -1, 1); + + for (k = 0; k < overlays; k++) + { + int i, j; + GLfloat a = (GLfloat) k / overlays; + + glColor3f (0.3 * a, 0.7 * a, 1.0 * a); + + glBegin (GL_LINE_STRIP); + + j = bp->histogram_fp + 1; + for (i = 0; i < samples; i++) + { + GLfloat x, y, z; + if (j >= samples) j = 0; + x = i; + y = bp->histogram[j]; + z = 0; + + y += (int) ((random() % 16) - 8); + y += 16; /* margin at bottom of screen */ + + x *= scalex; + y *= scaley; + + glVertex3f (x, y, z); + ++j; + polys++; + } + glEnd(); + } + + glPopMatrix(); + } + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + + glMatrixMode(GL_MODELVIEW); + + return polys; +} + + +/* Window management, etc + */ +ENTRYPOINT void +reshape_bit (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 +bit_handle_event (ModeInfo *mi, XEvent *event) +{ + bit_configuration *bp = &bps[MI_SCREEN(mi)]; + + if (gltrackball_event_handler (event, bp->trackball, + MI_WIDTH (mi), MI_HEIGHT (mi), + &bp->button_down_p)) + return True; + else if (event->xany.type == KeyPress) + { + KeySym keysym; + char c = 0; + XLookupString (&event->xkey, &c, 1, &keysym, 0); + + if (keysym == XK_Up || keysym == XK_Left || keysym == XK_Prior) + c = '1'; + else if (keysym == XK_Down || keysym == XK_Right || keysym == XK_Next) + c = '0'; + + if (c == ' ' || c == '\t' || c == '\n' || c == '1' || c == '0') + { + bp->kbd = c; + return True; + } + } + + return False; +} + + +ENTRYPOINT void +init_bit (ModeInfo *mi) +{ + bit_configuration *bp; + int i; + + MI_INIT (mi, bps); + + bp = &bps[MI_SCREEN(mi)]; + + bp->glx_context = init_GL(mi); + + reshape_bit (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); + + { + double spin_speed = 3.0; + double wander_speed = 0.03 * speed; + double spin_accel = 4.0; + + bp->rot = make_rotator (do_spin ? spin_speed : 0, + do_spin ? spin_speed : 0, + do_spin ? spin_speed : 0, + spin_accel, + do_wander ? wander_speed : 0, + False); + bp->trackball = gltrackball_init (False); + } + + for (i = 0; i < countof(bp->dlists); i++) + { + bp->dlists[i] = glGenLists (1); + glNewList (bp->dlists[i], GL_COMPILE); + bp->polys [i] = make_bit (mi, i); + glEndList (); + } + + bp->frequency = 0.30 / speed; /* parity around 3x/second */ + bp->confidence = 0.06; /* provide answer 1/15 or so */ + + for (i = 0; i < countof(bp->histogram); i++) + bp->histogram[i] = 128 + (random() % 16) - 8; +} + + +ENTRYPOINT void +draw_bit (ModeInfo *mi) +{ + bit_configuration *bp = &bps[MI_SCREEN(mi)]; + Display *dpy = MI_DISPLAY(mi); + Window window = MI_WINDOW(mi); + int wire = MI_IS_WIREFRAME(mi); + + if (!bp->glx_context) + return; + + glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context)); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + 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); + glLightfv(GL_LIGHT0, GL_POSITION, pos); + glLightfv(GL_LIGHT0, GL_AMBIENT, amb); + glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); + glLightfv(GL_LIGHT0, GL_SPECULAR, spc); + } + + glPushMatrix (); + glScalef(1.1, 1.1, 1.1); + +# 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 + + { + double x, y, z; + get_position (bp->rot, &x, &y, &z, !bp->button_down_p); + glTranslatef((x - 0.5) * 11, + (y - 0.5) * 5, + (z - 0.5) * 3); + 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; + + glScalef (6, 6, 6); + + { + int nmodel = bp->history [bp->history_fp]; + int omodel = bp->history [bp->history_fp > 0 + ? bp->history_fp-1 + : countof(bp->history)-1]; + double now = double_time(); + double ratio = 1 - ((bp->last_time + bp->frequency) - now) / bp->frequency; + if (ratio > 1) ratio = 1; + mi->polygon_count += draw_histogram (mi, ratio); + + if (MI_WIDTH(mi) > MI_HEIGHT(mi) * 5) { /* wide window: scale up */ + glScalef (8, 8, 8); + } + + mi->polygon_count += animate_bits (mi, omodel, nmodel, ratio); + tick_bit (mi, now); + } + glPopMatrix (); + + if (mi->fps_p) do_fps (mi); + glFinish(); + + glXSwapBuffers(dpy, window); +} + +XSCREENSAVER_MODULE_2 ("TronBit", tronbit, bit) + +#endif /* USE_GL */ |