diff options
Diffstat (limited to 'hacks/glx/lockward.c')
| -rw-r--r-- | hacks/glx/lockward.c | 963 |
1 files changed, 0 insertions, 963 deletions
diff --git a/hacks/glx/lockward.c b/hacks/glx/lockward.c deleted file mode 100644 index 6c80afa..0000000 --- a/hacks/glx/lockward.c +++ /dev/null @@ -1,963 +0,0 @@ -/* - * lockward.c: First attempt at an Xscreensaver. - * - * Leo L. Schwab 2007.08.17 - **** - * Copyright (c) 2007 Leo L. Schwab - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sublicense, and/or sell copies of the Software, and to permit - * persons to whom the Software is furnished to do so, subject to the - * following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN - * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -#include <ctype.h> -#include <strings.h> - -#include "xlockmore.h" -#include "colors.h" - - -/*************************************************************************** - * #defines - */ -#ifdef USE_GL /* whole file */ - -#define DEFAULTS "*delay: 20000 \n"\ - "*showFPS: False \n" - -#define release_lockward 0 - - -#define NUMOF(x) (sizeof ((x)) / sizeof ((*x))) - -#define NBLADES 12 -#define NSPINNERS 4 -#define NRADII 8 -#define COLORIDX_SHF 4 -#define SUBDIV 6 - - -/*************************************************************************** - * Structure definitions. - */ -struct lockward_context; /* Forward declaration. */ - -#define int8_t char -#define int16_t short -#define int32_t int -#define uint8_t unsigned char -#define uint16_t unsigned short -#define uint32_t unsigned int - -typedef struct bladestate { - uint8_t outer, inner; /* Radii */ -} bladestate; - -typedef struct spinnerstate { - GLfloat rot; /* Terminal rotation after count expires */ - GLfloat rotinc; /* Per-frame increment to rot. */ - XColor *colors; - bladestate *bladeidx; - int ncolors; /* n.4 fixed-point */ - int ccolor; /* n.4 fixed-point */ - int colorinc; /* n.4 fixed-point */ - int rotcount; - uint8_t nblades; -} spinnerstate; - -typedef struct blinkstate { - int (*drawfunc) (struct lockward_context *ctx, - struct blinkstate *bs); - uint32_t *noise; /* For draw_blink_segment_scatter() */ - GLfloat color[4]; - uint32_t val; - int16_t dwell; /* <0: sharp >0: decay */ - int16_t dwellcnt; - uint8_t type; - int8_t counter; - int8_t direction; - int8_t radius; -} blinkstate; - -enum blinktype { - BTYPE_RADIAL_SINGLE = 0, - BTYPE_RADIAL_RANDOM, - BTYPE_RADIAL_SEQ, - BTYPE_RADIAL_DOUBLESEQ, - BTYPE_SEGMENT_SINGLE, - BTYPE_SEGMENT_RANDOM, - BTYPE_CONCENTRIC_SINGLE, - BTYPE_CONCENTRIC_RANDOM, - BTYPE_CONCENTRIC_SEQ, - BTYPE_SEGMENT_SCATTER, - MAX_BTYPE -}; - -typedef struct { GLfloat x,y,z; } XYZ; - -typedef struct lockward_context { - GLXContext *glx_context; - - spinnerstate spinners[NSPINNERS]; - blinkstate blink; - - /* This used to put vertexes into lists without putting begin/end - into the same list! I didn't even know that worked. Well, it - doesn't work with jwzgles, so I changed it to not do that. */ - /* GLuint blades_outer, blades_inner; */ - XYZ points_outer[NRADII][SUBDIV+1]; - XYZ points_inner[NRADII][SUBDIV+1]; - - GLuint rings; - Bool blendmode; - int nextblink; - int fps; - -} lockward_context; - - -/*************************************************************************** - * Prototypes. - */ -ENTRYPOINT void free_lockward (ModeInfo *mi); - - -/*************************************************************************** - * Global variables. - */ -static lockward_context *g_ctx = NULL; -static Bool g_blink_p = True; -static int g_blades = NBLADES; -static int g_rotateidle_min, - g_rotateidle_max; -static int g_blinkidle_min, - g_blinkidle_max; -static int g_blinkdwell_min, - g_blinkdwell_max; - -#define DEF_BLINK "True" -#define DEF_ROTATEIDLEMIN "1000" -#define DEF_ROTATEIDLEMAX "6000" -#define DEF_BLINKIDLEMIN "1000" -#define DEF_BLINKIDLEMAX "9000" -#define DEF_BLINKDWELLMIN "100" -#define DEF_BLINKDWELLMAX "600" - - -static XrmOptionDescRec opts[] = { - { "-blink", ".blink", XrmoptionNoArg, "on" }, - { "+blink", ".blink", XrmoptionNoArg, "off" }, - { "-rotateidle-min", ".rotateidlemin", XrmoptionSepArg, 0 }, - { "-rotateidle-max", ".rotateidlemax", XrmoptionSepArg, 0 }, - { "-blinkidle-min", ".blinkidlemin", XrmoptionSepArg, 0 }, - { "-blinkidle-max", ".blinkidlemax", XrmoptionSepArg, 0 }, - { "-blinkdwell-min", ".blinkdwellmin", XrmoptionSepArg, 0 }, - { "-blinkdwell-max", ".blinkdwellmax", XrmoptionSepArg, 0 }, -}; - -static argtype vars[] = { - { &g_blink_p, "blink", "Blink", DEF_BLINK, t_Bool }, - { &g_rotateidle_min, "rotateidlemin", "Rotateidlemin", DEF_ROTATEIDLEMIN, t_Int }, - { &g_rotateidle_max, "rotateidlemax", "Rotateidlemax", DEF_ROTATEIDLEMAX, t_Int }, - { &g_blinkidle_min, "blinkidlemin", "Blinkidlemin", DEF_BLINKIDLEMIN, t_Int }, - { &g_blinkidle_max, "blinkidlemax", "Blinkidlemax", DEF_BLINKIDLEMAX, t_Int }, - { &g_blinkdwell_min, "blinkdwellmin", "Blinkdwellmin", DEF_BLINKDWELLMIN, t_Int }, - { &g_blinkdwell_max, "blinkdwellmax", "Blinkdwellmax", DEF_BLINKDWELLMAX, t_Int }, -}; - -static OptionStruct desc[] = { - { "-/+blink", "Turn on/off blinking effects." }, - { "-rotateidle-min", "Minimum idle time for rotators, in milliseconds." }, - { "-rotateidle-max", "Maximum idle time for rotators, in milliseconds." }, - { "-blinkidle-min", "Minimum idle time between blink effects, in milliseconds." }, - { "-blinkidle-max", "Maximum idle time between blink effects, in milliseconds." }, - { "-blinkdwell-min", "Minimum dwell time for blink effects, in milliseconds." }, - { "-blinkdwell-max", "Maximum dwell time for blink effects, in milliseconds." }, -}; - -ENTRYPOINT ModeSpecOpt lockward_opts = { - NUMOF(opts), opts, NUMOF(vars), vars, desc -}; - - -/*************************************************************************** - * Window management. - */ -ENTRYPOINT void -reshape_lockward (ModeInfo *mi, int width, int height) -{ - lockward_context *ctx = &g_ctx[MI_SCREEN (mi)]; - 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; - } - - glXMakeCurrent (MI_DISPLAY (mi), MI_WINDOW (mi), *ctx->glx_context); - - glViewport (0, y, (GLint) width, (GLint) height); - - glMatrixMode (GL_PROJECTION); - glLoadIdentity (); - if (height > width) - glOrtho (-8.0, 8.0, -8.0 * h, 8.0 * h, -1, 1); - else - glOrtho (-8.0 / h, 8.0 / h, -8.0, 8.0, -1, 1); - - glMatrixMode (GL_MODELVIEW); -} - -ENTRYPOINT Bool -lockward_handle_event (ModeInfo *mi, XEvent *event) -{ - lockward_context *ctx = &g_ctx[MI_SCREEN (mi)]; - - if (event->xany.type == KeyPress) { - KeySym keysym; - char c = 0; - - XLookupString (&event->xkey, &c, 1, &keysym, 0); - if (c == ' ' || c == '\t') { - ctx->blendmode ^= 1; - return True; - } - } - - return False; -} - - -/*************************************************************************** - * "Blade" routines. - */ -static void -random_blade_rot (lockward_context *ctx, struct spinnerstate *ss) -{ - /* - * The circle is divided up in to g_blades divisions. The idea here - * is to rotate to an exact division point. - * - * The target rotation is computed via random numbers. - * - * The time it takes to get there is a maximum of six seconds per - * division, and a minimum of one second (no matter how far away it - * is), and is selected by random numbers. - * - * The time value is converted into frames, and a per-frame rotation - * is computed. - * - * During rendering, we approach the target rotation by subtracting - * from it the per-frame rotation times the number of outstanding - * ticks. Doing it this way means we'll hit the target rotation - * exactly, without low-order errors creeping in to the values (at - * least not nearly as quickly). - */ - GLfloat d; - int dist; - - dist = random() % g_blades + 1; - - ss->rotcount = random() % (6 * dist * ctx->fps - ctx->fps) - + ctx->fps; - - if (random() & 4) - dist = -dist; - d = dist * 360.0 / (GLfloat) g_blades; - ss->rot += d; - ss->rotinc = d / (GLfloat) ss->rotcount; -} - - -/* - * A "blade" is pie-wedge shaped flat thing that is rotated around where the - * apex is/would be. Initially envisioned as 1/12th of a circle, but that - * could be configurable. The inner and outer edges are rounded off using - * six subdivisions so that, when multiple blades are assembled, it looks - * more like a circle and less like a polygon. - * - * The blade is assembled as a tri-fan. It is oriented centered at 3 - * o'clock. The blade is composed of two display lists -- arcs, essentially - * -- the outer and the inner one. The outer one *must* be called before - * the inner one, or the blade clockwise-ness will be wrong, and become - * invisible. Arcs of various radii are compiled. - */ - -static void -gen_blade_arcs (lockward_context *ctx) -{ - GLfloat here, there, step; - int i, n; - - here = 0; - there = M_PI * 2.0 / g_blades; - step = there / SUBDIV; - here -= SUBDIV * step / 2.0; - - /* - * Build outer blade arcs. - * Start at left side of outer radius. Strike all its vertices. - */ - for (n = 0; n < NRADII; ++n) { - /* glNewList (ctx->blades_outer + n, GL_COMPILE); */ - XYZ *a = ctx->points_outer[n]; - int j = 0; - for (i = SUBDIV; i >= 0; --i) { - /* glVertex3f (cos (here + step * i) * (n + 1.0), - sin (here + step * i) * (n + 1.0), 0); */ - a[j].x = cos (here + step * i) * (n + 1.0); - a[j].y = sin (here + step * i) * (n + 1.0); - a[j].z = 0; - j++; - } - if (j != SUBDIV+1) abort(); - /* glEndList (); */ - } - - /* - * Build inner blade arcs. - * Move to inner radius, strike all vertices in opposite order. - */ - for (n = 0; n < NRADII; ++n) { - /* glNewList (ctx->blades_inner + n, GL_COMPILE); */ - XYZ *a = ctx->points_inner[n]; - int j = 0; - for (i = 0; i <= SUBDIV; ++i) { - /* glVertex3f (cos (here + step * i) * (n + 1.0), - sin (here + step * i) * (n + 1.0), 0); */ - a[j].x = cos (here + step * i) * (n + 1.0); - a[j].y = sin (here + step * i) * (n + 1.0); - a[j].z = 0; - j++; - } - if (j != SUBDIV+1) abort(); - /* glEndList (); */ - } -} - -static void -gen_rings (lockward_context *ctx) -{ - GLfloat step; - int i, n; - - step = M_PI * 2.0 / (g_blades * SUBDIV); - - for (n = 0; n < NRADII - 1; ++n) { - glNewList (ctx->rings + n, GL_COMPILE); - glBegin (GL_TRIANGLE_STRIP); - for (i = g_blades * SUBDIV; i >= 0; --i) { - glVertex3f (cos (step * i) * (n + 1.0), - sin (step * i) * (n + 1.0), 0); - glVertex3f (cos (step * i) * (n + 2.0), - sin (step * i) * (n + 2.0), 0); - } - glEnd(); - glEndList (); - } -} - - -/*************************************************************************** - * "Blink" routines. - */ -static int -calc_interval_frames (lockward_context *ctx, int min, int max) -{ - /* - * Compute random interval between min and max milliseconds. - * Returned value is in frames. - */ - register int i; - - i = min; - if (max > min) - i += random() % (max - min); - - return i * ctx->fps / 1000; -} - -static void -set_alpha_by_dwell (struct blinkstate *bs) -{ - if (bs->dwell > 0) - bs->color[3] = (GLfloat) bs->dwellcnt / (GLfloat) bs->dwell; - else - bs->color[3] = bs->dwellcnt > (-bs->dwell >> 2) ? 1.0 : 0.0; -} - - -static void -draw_blink_blade (lockward_context *ctx, int inner, int outer, - Bool begin_p) -{ - int i; - if (begin_p) glBegin (GL_TRIANGLE_FAN); - /* glCallList (ctx->blades_outer + outer); */ - for (i = 0; i < countof(*ctx->points_outer); i++) - glVertex3f(ctx->points_outer[outer][i].x, - ctx->points_outer[outer][i].y, - ctx->points_outer[outer][i].z); - - /* glCallList (ctx->blades_inner + inner); */ - for (i = 0; i < countof(*ctx->points_inner); i++) - glVertex3f(ctx->points_inner[inner][i].x, - ctx->points_inner[inner][i].y, - ctx->points_inner[inner][i].z); - if (begin_p) glEnd(); -} - -static int -draw_blink_radial_random (lockward_context *ctx, struct blinkstate *bs) -{ - int i; - - /* - * There is no sense of direction in a random sweep, so re-use the - * 'direction' field to hold the current blade we're messing with. - */ - if (bs->dwellcnt < 0) { - if (bs->counter <= 0) { - bs->drawfunc = NULL; - return 0; - } - - /* - * Find available blade. Potentially very slow, depending on - * how unlucky we are. - */ - do { - i = random() % g_blades; - } while (bs->val & (1 << i)); - bs->val |= (1 << i); /* Mark as used. */ - bs->direction = i; - if ((bs->dwellcnt = bs->dwell) < 0) - bs->dwellcnt = -bs->dwellcnt; - - if ( bs->type == BTYPE_SEGMENT_SINGLE - || bs->type == BTYPE_SEGMENT_RANDOM) - bs->radius = random() % (NRADII - 1); - - --bs->counter; - } - - set_alpha_by_dwell (bs); - glBlendFunc (GL_DST_COLOR, GL_SRC_ALPHA); - glColor4fv (bs->color); - glRotatef (bs->direction * 360.0 / (GLfloat) g_blades, 0, 0, 1); - if (bs->radius >= 0) - draw_blink_blade (ctx, bs->radius, bs->radius + 1, True); - else - draw_blink_blade (ctx, 0, NRADII - 1, True); - - --bs->dwellcnt; - - return SUBDIV + SUBDIV; -} - -static int -draw_blink_radial_sequential (lockward_context *ctx, struct blinkstate *bs) -{ - if (bs->dwellcnt < 0) { - if (bs->counter <= 0) { - bs->drawfunc = NULL; - return 0; - } - if ((bs->dwellcnt = bs->dwell) < 0) - bs->dwellcnt = -bs->dwellcnt; - --bs->counter; - } - - set_alpha_by_dwell (bs); - glBlendFunc (GL_DST_COLOR, GL_SRC_ALPHA); - glColor4fv (bs->color); - glRotatef ((bs->counter * bs->direction + (int) bs->val) - * 360.0 / (GLfloat) g_blades, - 0, 0, 1); - draw_blink_blade (ctx, 0, NRADII - 1, True); - - --bs->dwellcnt; - - return SUBDIV + SUBDIV; -} - -static int -draw_blink_radial_doubleseq (lockward_context *ctx, struct blinkstate *bs) -{ - int polys; - - if (bs->dwellcnt < 0) { - if (bs->counter <= 0) { - bs->drawfunc = NULL; - return 0; - } - if ((bs->dwellcnt = bs->dwell) < 0) - bs->dwellcnt = -bs->dwellcnt; - --bs->counter; - } - - set_alpha_by_dwell (bs); - glBlendFunc (GL_DST_COLOR, GL_SRC_ALPHA); - glColor4fv (bs->color); - - glPushMatrix (); - glRotatef (((int) bs->val + bs->counter) * 360.0 / (GLfloat) g_blades, - 0, 0, 1); - draw_blink_blade (ctx, 0, NRADII - 1, True); - glPopMatrix (); - polys = SUBDIV + SUBDIV; - - if (bs->counter && bs->counter < g_blades / 2) { - glRotatef (((int) bs->val - bs->counter) - * 360.0 / (GLfloat) g_blades, - 0, 0, 1); - draw_blink_blade (ctx, 0, NRADII - 1, True); - polys += SUBDIV + SUBDIV; - } - - --bs->dwellcnt; - - return polys; -} - -static int -draw_blink_concentric_random (lockward_context *ctx, struct blinkstate *bs) -{ - int i; - - if (bs->dwellcnt < 0) { - if (bs->counter <= 0) { - bs->drawfunc = NULL; - return 0; - } - - do { - i = random() % (NRADII - 1); - } while (bs->val & (1 << i)); - bs->val |= (1 << i); - bs->direction = i; - if ((bs->dwellcnt = bs->dwell) < 0) - bs->dwellcnt = -bs->dwellcnt; - - --bs->counter; - } - - set_alpha_by_dwell (bs); - glBlendFunc (GL_DST_COLOR, GL_SRC_ALPHA); - glColor4fv (bs->color); - glCallList (ctx->rings + bs->direction); - - --bs->dwellcnt; - - return g_blades * SUBDIV * 2; -} - -static int -draw_blink_concentric_sequential (lockward_context *ctx, struct blinkstate *bs) -{ - if (bs->dwellcnt < 0) { - if (bs->counter <= 0) { - bs->drawfunc = NULL; - return 0; - } - if ((bs->dwellcnt = bs->dwell) < 0) - bs->dwellcnt = -bs->dwellcnt; - --bs->counter; - } - - set_alpha_by_dwell (bs); - glBlendFunc (GL_DST_COLOR, GL_SRC_ALPHA); - glColor4fv (bs->color); - if (bs->direction > 0) - glCallList (ctx->rings + (NRADII - 2) - bs->counter); - else - glCallList (ctx->rings + bs->counter); - - --bs->dwellcnt; - - return g_blades * SUBDIV * 2; -} - -static int -draw_blink_segment_scatter (lockward_context *ctx, struct blinkstate *bs) -{ - int i, polys = 0; - - if (bs->dwellcnt < 0) { - if (bs->counter <= 0) { - bs->drawfunc = NULL; - return 0; - } - - /* - * Init random noise array. On average, 1/4 of the bits will - * be set, which should look nice. (1/2 looks too busy.) - */ - for (i = g_blades; --i >= 0; ) - bs->noise[i] = random() & random() - & ((1 << (NRADII - 1)) - 1); - - if ((bs->dwellcnt = bs->dwell) < 0) - bs->dwellcnt = -bs->dwellcnt; - --bs->counter; - } - - set_alpha_by_dwell (bs); - glBlendFunc (GL_DST_COLOR, GL_SRC_ALPHA); - glColor4fv (bs->color); - - for (i = g_blades; --i >= 0; ) { - register uint32_t bits; - int inner, outer; - - /* - * Find consecutive runs of 1 bits. Keep going until we run - * out of them. - */ - for (bits = bs->noise[i]; bits; ) { - inner = ffs (bits) - 1; - bits = ~bits & ~((1 << inner) - 1); - outer = ffs (bits) - 1; - bits = ~bits & ~((1 << outer) - 1); - - glPushMatrix (); - glRotatef (i * 360.0 / (GLfloat) g_blades, 0, 0, 1); - draw_blink_blade (ctx, inner, outer, True); - glPopMatrix (); - - polys += SUBDIV + SUBDIV; - } - } - - --bs->dwellcnt; - - return polys; -} - -static void -random_blink (lockward_context *ctx, struct blinkstate *bs) -{ - bs->color[0] = - bs->color[1] = - bs->color[2] = - bs->color[3] = 1.0; - bs->dwellcnt = -1; - bs->radius = -1; - bs->dwell = calc_interval_frames - (ctx, g_blinkdwell_min, g_blinkdwell_max); - if (random() & 2) - bs->dwell = -bs->dwell; - - bs->type = random() % MAX_BTYPE; - - switch (bs->type) { - case BTYPE_RADIAL_SINGLE: - case BTYPE_SEGMENT_SINGLE: - bs->drawfunc = draw_blink_radial_random; - bs->val = 0; - bs->counter = 1; - break; - case BTYPE_RADIAL_RANDOM: - case BTYPE_SEGMENT_RANDOM: - bs->drawfunc = draw_blink_radial_random; - bs->val = 0; - bs->counter = g_blades; - break; - case BTYPE_RADIAL_SEQ: - bs->drawfunc = draw_blink_radial_sequential; - bs->val = random() % g_blades; /* Initial offset */ - bs->direction = random() & 8 ? 1 : -1; - bs->counter = g_blades; - break; - case BTYPE_RADIAL_DOUBLESEQ: - bs->drawfunc = draw_blink_radial_doubleseq; - bs->val = random() % g_blades; /* Initial offset */ - bs->counter = g_blades / 2 + 1; - break; - case BTYPE_CONCENTRIC_SINGLE: - bs->drawfunc = draw_blink_concentric_random; - bs->val = 0; - bs->counter = 1; - break; - case BTYPE_CONCENTRIC_RANDOM: - bs->drawfunc = draw_blink_concentric_random; - bs->val = 0; - bs->counter = NRADII - 1; - break; - case BTYPE_CONCENTRIC_SEQ: - bs->drawfunc = draw_blink_concentric_sequential; - bs->direction = random() & 8 ? 1 : -1; - bs->counter = NRADII - 1; - break; - case BTYPE_SEGMENT_SCATTER: - bs->drawfunc = draw_blink_segment_scatter; - bs->counter = random() % (g_blades / 2) + (g_blades / 2) + 1; - break; - } -} - - -/*************************************************************************** - * Main rendering routine. - */ -ENTRYPOINT void -draw_lockward (ModeInfo *mi) -{ - lockward_context *ctx = &g_ctx[MI_SCREEN (mi)]; - spinnerstate *ss; - Display *dpy = MI_DISPLAY(mi); - Window window = MI_WINDOW(mi); - int i, n; - - GLfloat scolor[4] = {0.0, 0.0, 0.0, 0.5}; - - if (!ctx->glx_context) - return; - - glXMakeCurrent (MI_DISPLAY (mi), MI_WINDOW (mi), *ctx->glx_context); - - - glClear (GL_COLOR_BUFFER_BIT); - - if (ctx->blendmode) - glBlendFunc (GL_ONE, GL_ONE); - else - glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - - glPushMatrix (); - glLoadIdentity (); - - mi->polygon_count = 0; - - for (n = NSPINNERS; --n >= 0; ) { - ss = &ctx->spinners[n]; - - /* Set color. */ - i = ss->ccolor >> COLORIDX_SHF; - scolor[0] = ss->colors[i].red / 65535.0; - scolor[1] = ss->colors[i].green / 65535.0; - scolor[2] = ss->colors[i].blue / 65535.0; - glColor4fv (scolor); - - glPushMatrix (); - glRotatef (ss->rot - ss->rotcount * ss->rotinc, 0, 0, 1); - for (i = ss->nblades; --i >= 0; ) { - glPushMatrix (); - glRotatef (360.0 * i / ss->nblades, 0, 0, 1); - - glBegin (GL_TRIANGLE_FAN); - /* glCallList (ctx->blades_outer + ss->bladeidx[i].outer); */ - /* glCallList (ctx->blades_inner + ss->bladeidx[i].inner); */ - draw_blink_blade (ctx, - ss->bladeidx[i].inner, - ss->bladeidx[i].outer, - False); - glEnd (); - - glPopMatrix (); - mi->polygon_count += SUBDIV + SUBDIV; - } - glPopMatrix (); - - /* Advance rotation. */ - if (ss->rotcount) { - if (ss->rotcount > 0) - --ss->rotcount; - } else { - if (ss->rotinc == 0.0) - random_blade_rot (ctx, ss); - else { - /* Compute # of ticks to sit idle. */ - ss->rotinc = 0.0; - ss->rotcount = - calc_interval_frames (ctx, - g_rotateidle_min, - g_rotateidle_max); - } - } - - /* Advance colors. */ - if ((ss->ccolor += ss->colorinc) >= ss->ncolors) - ss->ccolor -= ss->ncolors; - else if (ss->ccolor < 0) - ss->ccolor += ss->ncolors; - } - - if (g_blink_p) { - if (ctx->blink.drawfunc) { - mi->polygon_count += - ctx->blink.drawfunc (ctx, &ctx->blink); - } else { - if (ctx->nextblink > 0) - --ctx->nextblink; - else { - /* Compute # of frames for blink idle time. */ - ctx->nextblink = - calc_interval_frames (ctx, - g_blinkidle_min, - g_blinkidle_max); - random_blink (ctx, &ctx->blink); - } - } - } - glPopMatrix (); - - if (MI_IS_FPS (mi)) do_fps (mi); - glFinish(); - - glXSwapBuffers (dpy, window); -} - - -/*************************************************************************** - * Initialization/teardown. - */ -ENTRYPOINT void -init_lockward (ModeInfo *mi) -{ - lockward_context *ctx; - int i, n; - - MI_INIT (mi, g_ctx); - ctx = &g_ctx[MI_SCREEN (mi)]; - - ctx->glx_context = init_GL (mi); - - reshape_lockward (mi, MI_WIDTH (mi), MI_HEIGHT (mi)); - - glEnable (GL_CULL_FACE); - glEnable (GL_BLEND); - glDisable (GL_DEPTH_TEST); - - glShadeModel (GL_FLAT); - glFrontFace (GL_CW); - - /* ctx->blades_outer = glGenLists (NRADII); */ - /* ctx->blades_inner = glGenLists (NRADII); */ - ctx->rings = glGenLists (NRADII - 1); - ctx->blendmode = 0; -/* WTF? ctx->fps = 1000000 / MI_DELAY (mi); */ - ctx->fps = 60; - ctx->nextblink = calc_interval_frames - (ctx, g_blinkidle_min, g_blinkidle_max); - ctx->blink.drawfunc = NULL; - ctx->blink.noise = malloc (sizeof (uint32_t) * g_blades); - if (!ctx->blink.noise) { - fprintf (stderr, "Can't allocate noise array.\n"); - exit (1); - } - - gen_blade_arcs (ctx); - gen_rings (ctx); - - for (i = NSPINNERS; --i >= 0; ) { - spinnerstate *ss = &ctx->spinners[i]; - - ss->rot = 0.0; - ss->rotcount = -1; - - /* Establish rotation */ - random_blade_rot (ctx, ss); - - /* - * Establish color cycling path and rate. Rate avoids zero. - */ - ss->ncolors = 128; - ss->colorinc = (random() & ((2 << COLORIDX_SHF) - 1)) - - (1 << COLORIDX_SHF); - if (ss->colorinc >= 0) - ++ss->colorinc; - - ss->colors = (XColor *) calloc (ss->ncolors, sizeof (XColor)); - if (!ss->colors) { - fprintf (stderr, - "Can't allocate XColors for spinner %d.\n", - i); - exit (1); - } - make_smooth_colormap (0, 0, 0, - ss->colors, &ss->ncolors, - False, 0, False); - ss->ncolors <<= COLORIDX_SHF; - - /* - * Create blades. - */ - ss->nblades = g_blades; - ss->bladeidx = malloc (sizeof (bladestate) * g_blades); - if (!ss->bladeidx) { - fprintf (stderr, "Can't allocate blades.\n"); - exit (1); - } - for (n = g_blades; --n >= 0; ) { - /* - * Establish blade radii. Can't be equal. Ensure - * outer > inner. - */ - do { - ss->bladeidx[n].outer = random() & 7; - ss->bladeidx[n].inner = random() & 7; - } while (ss->bladeidx[n].outer == - ss->bladeidx[n].inner); - - if (ss->bladeidx[n].outer < ss->bladeidx[n].inner) { - uint8_t tmp; - - tmp = ss->bladeidx[n].outer; - ss->bladeidx[n].outer = ss->bladeidx[n].inner; - ss->bladeidx[n].inner = tmp; - } - } - } -} - -ENTRYPOINT void -free_lockward (ModeInfo *mi) -{ - lockward_context *ctx = &g_ctx[MI_SCREEN (mi)]; - int i; - - if (!ctx->glx_context) return; - glXMakeCurrent (MI_DISPLAY (mi), MI_WINDOW (mi), *ctx->glx_context); - - if (ctx->blink.noise) - free (ctx->blink.noise); - if (glIsList (ctx->rings)) - glDeleteLists (ctx->rings, NRADII - 1); - /* if (glIsList (ctx->blades_outer)) - glDeleteLists (ctx->blades_outer, NRADII); - if (glIsList (ctx->blades_inner)) - glDeleteLists (ctx->blades_inner, NRADII); */ - - for (i = NSPINNERS; --i >= 0; ) { - spinnerstate *ss = &ctx->spinners[i]; - - if (ss->colors) - free (ss->colors); - if (ss->bladeidx) - free (ss->bladeidx); - } -} - - -XSCREENSAVER_MODULE ("Lockward", lockward) - -#endif /* USE_GL */ - -/* vim:se ts=8 sts=8 sw=8: */ |