/*
* 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
#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))
/***************************************************************************
* 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: */
