diff options
Diffstat (limited to 'hacks/glx/moebiusgears.c')
| -rw-r--r-- | hacks/glx/moebiusgears.c | 437 |
1 files changed, 437 insertions, 0 deletions
diff --git a/hacks/glx/moebiusgears.c b/hacks/glx/moebiusgears.c new file mode 100644 index 0000000..0f058b8 --- /dev/null +++ b/hacks/glx/moebiusgears.c @@ -0,0 +1,437 @@ +/* moebiusgears, Copyright (c) 2007-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: 17 \n" \ + "*showFPS: False \n" \ + "*wireframe: False \n" \ + "*suppressRotationAnimation: True\n" \ + +# define free_mgears 0 +# define release_mgears 0 +#undef countof +#define countof(x) (sizeof((x))/sizeof((*x))) + +#include "xlockmore.h" +#include "involute.h" +#include "normals.h" +#include "rotator.h" +#include "gltrackball.h" +#include <ctype.h> + +#ifdef USE_GL /* whole file */ + + +#define DEF_SPIN "True" +#define DEF_WANDER "True" +#define DEF_ROLL "True" +#define DEF_SPEED "1.0" +#define DEF_TEETH "15" + +typedef struct { + + gear g; + GLfloat pos_th; /* position on ring of gear system */ + GLfloat pos_thz; /* rotation out of plane of gear system */ +} mogear; + +typedef struct { + GLXContext *glx_context; + rotator *rot; + trackball_state *trackball; + Bool button_down_p; + + int ngears; + mogear *gears; + GLfloat ring_r; /* radius of gear system */ + GLfloat roll_th; + +} mgears_configuration; + +static mgears_configuration *bps = NULL; + +static Bool do_spin; +static GLfloat speed; +static Bool do_wander; +static Bool do_roll; +static int teeth_arg; + +static XrmOptionDescRec opts[] = { + { "-spin", ".spin", XrmoptionNoArg, "True" }, + { "+spin", ".spin", XrmoptionNoArg, "False" }, + { "-speed", ".speed", XrmoptionSepArg, 0 }, + { "-wander", ".wander", XrmoptionNoArg, "True" }, + { "+wander", ".wander", XrmoptionNoArg, "False" }, + { "-roll", ".roll", XrmoptionNoArg, "True" }, + { "+roll", ".roll", XrmoptionNoArg, "False" }, + { "-teeth", ".teeth", XrmoptionSepArg, 0 }, +}; + +static argtype vars[] = { + {&do_spin, "spin", "Spin", DEF_SPIN, t_Bool}, + {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool}, + {&do_roll, "roll", "Roll", DEF_ROLL, t_Bool}, + {&speed, "speed", "Speed", DEF_SPEED, t_Float}, + {&teeth_arg, "teeth", "Teeth", DEF_TEETH, t_Int}, +}; + +ENTRYPOINT ModeSpecOpt mgears_opts = {countof(opts), opts, countof(vars), vars, NULL}; + + +/* Window management, etc + */ +ENTRYPOINT void +reshape_mgears (ModeInfo *mi, int width, int height) +{ + GLfloat h = (GLfloat) height / (GLfloat) width; + int y = 0; + + if (width > height * 5) { /* tiny window: show middle */ + height = width * 9/16; + y = -height/2; + h = height / (GLfloat) width; + } + + glViewport (0, y, (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); + +# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */ + { + int o = (int) current_device_rotation(); + if (o != 0 && o != 180 && o != -180) + glScalef (1/h, 1/h, 1/h); + } +# endif + + glClear(GL_COLOR_BUFFER_BIT); +} + + +static void +reset_mgears (ModeInfo *mi) +{ + mgears_configuration *bp = &bps[MI_SCREEN(mi)]; + int wire = MI_IS_WIREFRAME(mi); + int total_gears = MI_COUNT(mi); + double gears_per_turn; + double gear_r, tw, th, thick, slope; + int i, nubs, size; + + if (! (total_gears & 1)) + total_gears++; /* must be odd or gears intersect */ + + /* Number of teeth must be odd if number of gears is odd, or teeth don't + mesh when the loop closes. And since number of gears must be odd... + */ + if (! (teeth_arg & 1)) teeth_arg++; + if (teeth_arg < 7) teeth_arg = 7; + + if (total_gears < 13) /* gear mesh angle is too steep with less */ + total_gears = 13; + + thick = 0.2; + nubs = (random() & 3) ? 0 : (random() % teeth_arg) / 2; + + slope = 0; + + /* Sloping gears are incompatible with "-roll" ... */ + /* slope= -M_PI * 2 / total_gears; */ + + gears_per_turn = total_gears / 2.0; + + bp->ring_r = 3; + gear_r = M_PI * bp->ring_r / gears_per_turn; + tw = 0; + th = gear_r * 2.5 / teeth_arg; + + /* If the gears are small, use a lower density mesh. */ + size = (gear_r > 0.60 ? INVOLUTE_HUGE : + gear_r > 0.32 ? INVOLUTE_LARGE : + gear_r > 0.13 ? INVOLUTE_MEDIUM : + INVOLUTE_SMALL); + + /* If there are lots of teeth, use a lower density mesh. */ + if (teeth_arg > 77) + size = INVOLUTE_SMALL; + if (teeth_arg > 45 && size >= INVOLUTE_HUGE) + size = INVOLUTE_MEDIUM; + + if (bp->gears) + { + for (i = 0; i < bp->ngears; i++) + glDeleteLists (bp->gears[i].g.dlist, 1); + free (bp->gears); + bp->gears = 0; + } + + bp->ngears = total_gears; + + bp->gears = (mogear *) calloc (bp->ngears, sizeof(*bp->gears)); + for (i = 0; i < bp->ngears; i++) + { + mogear *mg = &bp->gears[i]; + gear *g = &mg->g; + + g->r = gear_r; + g->size = size; + g->nteeth = teeth_arg; + g->tooth_w = tw; + g->tooth_h = th; + g->tooth_slope = slope; + g->thickness = g->r * thick; + g->thickness2 = g->thickness * 0.1; + g->thickness3 = g->thickness; + g->inner_r = g->r * 0.80; + g->inner_r2 = g->r * 0.60; + g->inner_r3 = g->r * 0.55; + g->nubs = nubs; + mg->pos_th = (M_PI * 2 / gears_per_turn) * i; + mg->pos_thz = (M_PI / 2 / gears_per_turn) * i; + + g->th = ((i & 1) + ? (M_PI * 2 / g->nteeth) + : 0); + + /* Colorize + */ + g->color[0] = 0.7 + frand(0.3); + g->color[1] = 0.7 + frand(0.3); + g->color[2] = 0.7 + frand(0.3); + g->color[3] = 1.0; + + g->color2[0] = g->color[0] * 0.85; + g->color2[1] = g->color[1] * 0.85; + g->color2[2] = g->color[2] * 0.85; + g->color2[3] = g->color[3]; + + /* Now render the gear into its display list. + */ + g->dlist = glGenLists (1); + if (! g->dlist) + { + check_gl_error ("glGenLists"); + abort(); + } + + glNewList (g->dlist, GL_COMPILE); + g->polygons += draw_involute_gear (g, wire); + glEndList (); + } +} + + +ENTRYPOINT void +init_mgears (ModeInfo *mi) +{ + mgears_configuration *bp; + int wire = MI_IS_WIREFRAME(mi); + + MI_INIT (mi, bps); + + bp = &bps[MI_SCREEN(mi)]; + + bp->glx_context = init_GL(mi); + + reshape_mgears (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); + + 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); + } + + { + double spin_speed = 0.5; + double wander_speed = 0.01; + double spin_accel = 2.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 /* don't randomize */ + ); + bp->trackball = gltrackball_init (True); + } + + reset_mgears (mi); +} + + +ENTRYPOINT Bool +mgears_handle_event (ModeInfo *mi, XEvent *event) +{ + mgears_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 (c == '+' || c == '=' || + keysym == XK_Up || keysym == XK_Right || keysym == XK_Next) + { + MI_COUNT(mi) += 2; + reset_mgears (mi); + return True; + } + else if (c == '-' || c == '_' || + keysym == XK_Down || keysym == XK_Left || keysym == XK_Prior) + { + if (MI_COUNT(mi) <= 13) + return False; + MI_COUNT(mi) -= 2; + reset_mgears (mi); + 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: + MI_COUNT(mi) = 13 + (2 * (random() % 10)); + reset_mgears (mi); + return True; + } + + return False; +} + + +ENTRYPOINT void +draw_mgears (ModeInfo *mi) +{ + mgears_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)); + + 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); + + { + double x, y, z; + get_position (bp->rot, &x, &y, &z, !bp->button_down_p); + glTranslatef ((x - 0.5) * 4, + (y - 0.5) * 4, + (z - 0.5) * 7); + + gltrackball_rotate (bp->trackball); + + get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p); + + /* add a little rotation for -no-spin mode */ + x -= 0.14; + y -= 0.06; + + 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 (1.5, 1.5, 1.5); + +/*#define DEBUG*/ + +#ifdef DEBUG + glScalef (.5, .5, .5); + glTranslatef (0, -bp->gears[0].g.r * bp->ngears, 0); +#endif + + for (i = 0; i < bp->ngears; i++) + { + mogear *mg = &bp->gears[i]; + gear *g = &mg->g; + + glPushMatrix(); +#ifndef DEBUG + glRotatef (mg->pos_th * 180 / M_PI, 0, 0, 1); /* rotation on ring */ + glTranslatef (bp->ring_r, 0, 0); /* position on ring */ + glRotatef (mg->pos_thz * 180 / M_PI, 0, 1, 0); /* twist a bit */ + + if (do_roll) + { + glRotatef (bp->roll_th * 180 / M_PI, 0, 1, 0); + bp->roll_th += speed * 0.0005; + } +#else + glTranslatef (0, i * 2 * g->r, 0); +#endif + glRotatef (g->th * 180 / M_PI, 0, 0, 1); + + glCallList (g->dlist); + mi->polygon_count += g->polygons; + glPopMatrix (); + } + + glPopMatrix (); + +#ifndef DEBUG + /* spin gears */ + for (i = 0; i < bp->ngears; i++) + { + mogear *mg = &bp->gears[i]; + mg->g.th += speed * (M_PI / 100) * (i & 1 ? 1 : -1); + } +#endif + + if (mi->fps_p) do_fps (mi); + glFinish(); + + glXSwapBuffers(dpy, window); +} + +XSCREENSAVER_MODULE_2 ("MoebiusGears", moebiusgears, mgears) + +#endif /* USE_GL */ |