sync code with last improvements from OpenBSD
This commit is contained in:
commit
88965415ff
GPG key ID:
F42C07F07E2E35B7
26235 changed files with 29195616 additions and 0 deletions
673
app/xlockmore/modes/starfish.c
Normal file
673
app/xlockmore/modes/starfish.c
Normal file
|
|
@ -0,0 +1,673 @@
|
|||
/* -*- Mode: C; tab-width: 4 -*- */
|
||||
/* starfish --- */
|
||||
|
||||
#if !defined( lint ) && !defined( SABER )
|
||||
static const char sccsid[] = "@(#)starfish.c 5.03 2003/05/01 xlockmore";
|
||||
|
||||
#endif
|
||||
|
||||
/* xscreensaver, Copyright (c) 1997 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.
|
||||
*
|
||||
* Revision History:
|
||||
* 01-May-2003: Changed to work in a 64x64 window.
|
||||
* 01-Nov-2000: Allocation checks
|
||||
* 24-Feb-1998: xlockmore version by Jouk Jansen <joukj@hrem.stm.tudelft.nl>
|
||||
* 1997: original xscreensaver version by Jamie Zawinski <jwz@jwz.org>
|
||||
*/
|
||||
|
||||
#ifdef STANDALONE
|
||||
#define MODE_starfish
|
||||
#define PROGCLASS "Starfish"
|
||||
#define HACK_INIT init_starfish
|
||||
#define HACK_DRAW draw_starfish
|
||||
#define starfish_opts xlockmore_opts
|
||||
#define DEFAULTS "*delay: 2000 \n" \
|
||||
"*cycles: 1000 \n" \
|
||||
"*ncolors: 200 \n" \
|
||||
"*fullrandom: True \n" \
|
||||
"*verbose: False \n"
|
||||
#include "xlockmore.h" /* in xscreensaver distribution */
|
||||
#else /* STANDALONE */
|
||||
#include "xlock.h" /* in xlockmore distribution */
|
||||
#include "color.h"
|
||||
#endif /* STANDALONE */
|
||||
|
||||
#ifdef MODE_starfish
|
||||
|
||||
#include "spline.h"
|
||||
|
||||
#define DEF_ROTV "-1"
|
||||
#define DEF_THICKNESS "-20"
|
||||
#define DEF_CYCLE "True"
|
||||
#define DEF_BLOB "False"
|
||||
#define DEF_CYCLESPEED "3"
|
||||
|
||||
static int cyclespeed;
|
||||
static float rotv, thickness;
|
||||
|
||||
static Bool blob, cycle_p;
|
||||
|
||||
static XrmOptionDescRec opts[] =
|
||||
{
|
||||
{(char *) "-cyclespeed", (char *) "starfish.cyclespeed", XrmoptionSepArg, (caddr_t) NULL},
|
||||
{(char *) "-rotation", (char *) "starfish.rotation", XrmoptionSepArg, (caddr_t) NULL},
|
||||
{(char *) "-thickness", (char *) "starfish.thickness", XrmoptionSepArg, (caddr_t) NULL},
|
||||
{(char *) "-blob", (char *) ".starfish.blob", XrmoptionNoArg, (caddr_t) "on"},
|
||||
{(char *) "+blob", (char *) ".starfish.blob", XrmoptionNoArg, (caddr_t) "off"},
|
||||
{(char *) "-cycle", (char *) ".starfish.cycle", XrmoptionNoArg, (caddr_t) "on"},
|
||||
{(char *) "+cycle", (char *) ".starfish.cycle", XrmoptionNoArg, (caddr_t) "off"}
|
||||
};
|
||||
|
||||
static argtype vars[] =
|
||||
{
|
||||
{(void *) & cyclespeed, (char *) "cyclespeed", (char *) "CycleSpeed", (char *) DEF_CYCLESPEED, t_Int},
|
||||
{(void *) & rotv, (char *) "rotation", (char *) "Rotation", (char *) DEF_ROTV, t_Float},
|
||||
{(void *) & thickness, (char *) "thickness", (char *) "Thickness", (char *) DEF_THICKNESS, t_Float},
|
||||
{(void *) & blob, (char *) "blob", (char *) "Blob", (char *) DEF_BLOB, t_Bool},
|
||||
{(void *) & cycle_p, (char *) "cycle", (char *) "Cycle", (char *) DEF_CYCLE, t_Bool}
|
||||
};
|
||||
|
||||
static OptionStruct desc[] =
|
||||
{
|
||||
{(char *) "-cyclespeed num", (char *) "Cycling speed"},
|
||||
{(char *) "-rotation num", (char *) "Rotation velocity"},
|
||||
{(char *) "-thickness num", (char *) "Thickness"},
|
||||
{(char *) "-/+blob", (char *) "turn on/off blob"},
|
||||
{(char *) "-/+cycle", (char *) "turn on/off cycle"}
|
||||
};
|
||||
|
||||
ModeSpecOpt starfish_opts =
|
||||
{sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
|
||||
|
||||
#ifdef USE_MODULES
|
||||
ModStruct starfish_description =
|
||||
{"starfish", "init_starfish", "draw_starfish", "release_starfish",
|
||||
"init_starfish", "init_starfish", (char *) NULL, &starfish_opts,
|
||||
2000, 1, 1000, 1, 64, 1.0, "",
|
||||
"Shows starfish", 0, NULL};
|
||||
|
||||
#endif
|
||||
|
||||
#define SCALE 1000 /* fixed-point math, for sub-pixel motion */
|
||||
|
||||
#define RAND(n) ((long) ((LRAND() & 0x7fffffff) % ((long) (n))))
|
||||
#define RANDSIGN() ((LRAND() & 1) ? 1 : -1)
|
||||
|
||||
enum starfish_mode {
|
||||
pulse,
|
||||
zoom
|
||||
};
|
||||
|
||||
|
||||
typedef struct {
|
||||
enum starfish_mode mode;
|
||||
Bool blob_p;
|
||||
int skip;
|
||||
long x, y; /* position of midpoint */
|
||||
double th; /* angle of rotation */
|
||||
double rotv; /* rotational velocity */
|
||||
double rota; /* rotational acceleration */
|
||||
double elasticity; /* how fast it deforms: radial velocity */
|
||||
double rot_max;
|
||||
long min_r, max_r; /* radius range */
|
||||
int npoints; /* control points */
|
||||
long *r; /* radii */
|
||||
spline *splines;
|
||||
XPoint *prev;
|
||||
int n_prev;
|
||||
GC gc;
|
||||
Colormap cmap;
|
||||
XColor *colors;
|
||||
int ncolors;
|
||||
Bool cycle_p, mono_p, no_colors;
|
||||
unsigned long fg_index;
|
||||
int size, winwidth, winheight, stage, counter;
|
||||
float thickness;
|
||||
unsigned long blackpixel, whitepixel, fg, bg;
|
||||
int direction;
|
||||
ModeInfo *mi;
|
||||
} starfishstruct;
|
||||
|
||||
static starfishstruct *starfishes = (starfishstruct *) NULL;
|
||||
|
||||
static void
|
||||
free_starfish(Display *display, starfishstruct * sp)
|
||||
{
|
||||
ModeInfo *mi = sp->mi;
|
||||
|
||||
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
|
||||
MI_WHITE_PIXEL(mi) = sp->whitepixel;
|
||||
MI_BLACK_PIXEL(mi) = sp->blackpixel;
|
||||
#ifndef STANDALONE
|
||||
MI_FG_PIXEL(mi) = sp->fg;
|
||||
MI_BG_PIXEL(mi) = sp->bg;
|
||||
#endif
|
||||
if (sp->colors != NULL) {
|
||||
if (sp->ncolors && !sp->no_colors)
|
||||
free_colors(display, sp->cmap, sp->colors, sp->ncolors);
|
||||
free(sp->colors);
|
||||
sp->colors = (XColor *) NULL;
|
||||
}
|
||||
if (sp->cmap != None) {
|
||||
XFreeColormap(display, sp->cmap);
|
||||
sp->cmap = None;
|
||||
}
|
||||
}
|
||||
if (sp->gc != None) {
|
||||
XFreeGC(display, sp->gc);
|
||||
sp->gc = None;
|
||||
}
|
||||
if (sp->splines != NULL) {
|
||||
free_spline(sp->splines);
|
||||
sp->splines = (spline *) NULL;
|
||||
}
|
||||
if (sp->r != NULL) {
|
||||
free(sp->r);
|
||||
sp->r = (long *) NULL;
|
||||
}
|
||||
if (sp->prev != NULL) {
|
||||
free(sp->prev);
|
||||
sp->prev = (XPoint *) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
make_starfish(ModeInfo * mi)
|
||||
{
|
||||
starfishstruct *sp = &starfishes[MI_SCREEN(mi)];
|
||||
int i;
|
||||
|
||||
sp->elasticity = SCALE * sp->thickness;
|
||||
|
||||
if (sp->elasticity == 0.0)
|
||||
/* bell curve from 0-15, avg 7.5 */
|
||||
sp->elasticity = RAND(5 * SCALE) + RAND(5 * SCALE) + RAND(5 * SCALE);
|
||||
|
||||
if (sp->rotv == -1)
|
||||
/* bell curve from 0-12 degrees, avg 6 */
|
||||
sp->rotv = (double) 4.0 *((double) LRAND() / (double) MAXRAND +
|
||||
(double) LRAND() / (double) MAXRAND +
|
||||
(double) LRAND() / (double) MAXRAND);
|
||||
|
||||
sp->rotv /= 360; /* convert degrees to ratio */
|
||||
|
||||
if (sp->blob_p) {
|
||||
sp->elasticity *= 3.0;
|
||||
sp->rotv *= 3;
|
||||
}
|
||||
sp->rot_max = sp->rotv * 2;
|
||||
sp->rota = 0.0004 + 0.0002 * (double) LRAND() / (double) MAXRAND;
|
||||
|
||||
|
||||
if (NRAND(20) == 5)
|
||||
sp->size = (int) (sp->size *
|
||||
(0.35 * ((double) LRAND() / (double) MAXRAND +
|
||||
(double) LRAND() / (double) MAXRAND) + 0.3));
|
||||
|
||||
{
|
||||
static char skips[] =
|
||||
{2, 2, 2, 2, 3, 3, 3, 6, 6, 12};
|
||||
|
||||
sp->skip = skips[LRAND() % sizeof (skips)];
|
||||
}
|
||||
|
||||
if (!(LRAND() % (sp->skip == 2 ? 3 : 12)))
|
||||
sp->mode = zoom;
|
||||
else
|
||||
sp->mode = pulse;
|
||||
|
||||
sp->winwidth *= SCALE;
|
||||
sp->winheight *= SCALE;
|
||||
sp->size *= SCALE;
|
||||
|
||||
sp->max_r = sp->size;
|
||||
sp->min_r = SCALE;
|
||||
/* sp->min_r = 5 * SCALE; */
|
||||
|
||||
/* mid = ((sp->min_r + sp->max_r) / 2); */
|
||||
|
||||
sp->x = sp->winwidth / 2;
|
||||
sp->y = sp->winheight / 2;
|
||||
|
||||
sp->th = 2.0 * M_PI * ((double) LRAND() / (double) MAXRAND) * RANDSIGN();
|
||||
|
||||
{
|
||||
static char sizes[] =
|
||||
{3, 3, 3, 3, 3,
|
||||
4, 4, 4, 4, 5, 5, 5, 5, 5, 5,
|
||||
8, 8, 8, 10, 35};
|
||||
int nsizes = sizeof (sizes);
|
||||
|
||||
if (sp->skip > 3)
|
||||
nsizes -= 4;
|
||||
sp->npoints = sp->skip * sizes[LRAND() % nsizes];
|
||||
}
|
||||
|
||||
if (sp->splines)
|
||||
free_spline(sp->splines);
|
||||
sp->splines = make_spline(sp->npoints);
|
||||
|
||||
if (sp->r != NULL)
|
||||
free(sp->r);
|
||||
if ((sp->r = (long *) malloc(sizeof (*sp->r) * sp->npoints)) == NULL) {
|
||||
free_starfish(MI_DISPLAY(mi), sp);
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < sp->npoints; i++)
|
||||
sp->r[i] = ((i % sp->skip) == 0) ? 0 : sp->size;
|
||||
}
|
||||
|
||||
static void
|
||||
throb_starfish(starfishstruct * sp)
|
||||
{
|
||||
int i;
|
||||
double frac = ((M_PI + M_PI) / sp->npoints);
|
||||
|
||||
for (i = 0; i < sp->npoints; i++) {
|
||||
double r = sp->r[i];
|
||||
double ra = (r > 0.0 ? r : -r);
|
||||
double th = (sp->th > 0 ? sp->th : -sp->th);
|
||||
double x, y;
|
||||
double elasticity = sp->elasticity;
|
||||
|
||||
/* place control points evenly around perimiter, shifted by theta */
|
||||
x = sp->x + (ra * cos(i * frac + th));
|
||||
y = sp->y + (ra * sin(i * frac + th));
|
||||
|
||||
sp->splines->control_x[i] = x / SCALE;
|
||||
sp->splines->control_y[i] = y / SCALE;
|
||||
|
||||
if (sp->mode == zoom && ((i % sp->skip) == 0))
|
||||
continue;
|
||||
|
||||
/* Slow down near the end points: move fastest in the middle. */
|
||||
{
|
||||
double ratio = ra / (double) (sp->max_r - sp->min_r);
|
||||
|
||||
if (ratio > 0.5)
|
||||
ratio = 1 - ratio; /* flip */
|
||||
ratio *= 2.0; /* normalize */
|
||||
ratio = (ratio * 0.9) + 0.1; /* fudge */
|
||||
elasticity = elasticity * ratio;
|
||||
}
|
||||
|
||||
|
||||
/* Increase/decrease radius by elasticity */
|
||||
ra += (r >= 0.0 ? elasticity : -elasticity);
|
||||
if ((i % sp->skip) == 0)
|
||||
ra += (elasticity / 2.0);
|
||||
|
||||
r = ra * (r >= 0.0 ? 1.0 : -1.0);
|
||||
|
||||
/* If we've reached the end (too long or too short) reverse direction. */
|
||||
if ((ra > sp->max_r && r >= 0.0) ||
|
||||
(ra < sp->min_r && r < 0.0))
|
||||
r = -r;
|
||||
|
||||
sp->r[i] = (long) r;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
spin_starfish(starfishstruct * sp)
|
||||
{
|
||||
double th = sp->th;
|
||||
|
||||
if (th < 0)
|
||||
th = -(th + sp->rotv);
|
||||
else
|
||||
th += sp->rotv;
|
||||
|
||||
if (th > (M_PI + M_PI))
|
||||
th -= (M_PI + M_PI);
|
||||
else if (th < 0)
|
||||
th += (M_PI + M_PI);
|
||||
|
||||
sp->th = (sp->th > 0 ? th : -th);
|
||||
|
||||
sp->rotv += sp->rota;
|
||||
|
||||
if (sp->rotv > sp->rot_max ||
|
||||
sp->rotv < -sp->rot_max) {
|
||||
sp->rota = -sp->rota;
|
||||
}
|
||||
/* If it stops, start it going in the other direction. */
|
||||
else if (sp->rotv < 0) {
|
||||
if (LRAND() & 1) {
|
||||
/* keep going in the same direction */
|
||||
sp->rotv = 0;
|
||||
if (sp->rota < 0)
|
||||
sp->rota = -sp->rota;
|
||||
} else {
|
||||
/* reverse gears */
|
||||
sp->rotv = -sp->rotv;
|
||||
sp->rota = -sp->rota;
|
||||
sp->th = -sp->th;
|
||||
}
|
||||
}
|
||||
/* Alter direction of rotational acceleration randomly. */
|
||||
if (!(LRAND() % 120))
|
||||
sp->rota = -sp->rota;
|
||||
|
||||
/* Change acceleration very occasionally. */
|
||||
if (!(LRAND() % 200)) {
|
||||
if (LRAND() & 1)
|
||||
sp->rota *= 1.2;
|
||||
else
|
||||
sp->rota *= 0.8;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static Bool
|
||||
draw1_starfish(Display * display, Drawable drawable, GC gc, starfishstruct * sp)
|
||||
{
|
||||
compute_closed_spline(sp->splines);
|
||||
if (sp->prev) {
|
||||
XPoint *points;
|
||||
int i = sp->splines->n_points;
|
||||
int j = sp->n_prev;
|
||||
|
||||
if ((points = (XPoint *) malloc(sizeof (XPoint) *
|
||||
(sp->n_prev + sp->splines->n_points + 2))) == NULL) {
|
||||
free_starfish(display, sp);
|
||||
return False;
|
||||
}
|
||||
(void) memcpy((char *) points, (char *) sp->splines->points,
|
||||
(i * sizeof (*points)));
|
||||
(void) memcpy((char *) (points + i), (char *) sp->prev,
|
||||
(j * sizeof (*points)));
|
||||
|
||||
if (sp->blob_p)
|
||||
XClearWindow(display, drawable);
|
||||
XFillPolygon(display, drawable, gc, points, i + j,
|
||||
Complex, CoordModeOrigin);
|
||||
free(points);
|
||||
|
||||
free(sp->prev);
|
||||
sp->prev = (XPoint *) NULL;
|
||||
}
|
||||
if ((sp->prev = (XPoint *) malloc(sp->splines->n_points *
|
||||
sizeof (XPoint))) == NULL) {
|
||||
free_starfish(display, sp);
|
||||
return False;
|
||||
}
|
||||
(void) memcpy((char *) sp->prev, (char *) sp->splines->points,
|
||||
sp->splines->n_points * sizeof (XPoint));
|
||||
sp->n_prev = sp->splines->n_points;
|
||||
|
||||
#ifdef DEBUG
|
||||
if (sp->blob_p) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < sp->npoints; i++)
|
||||
XDrawLine(display, drawable, gc, sp->x / SCALE, sp->y / SCALE,
|
||||
sp->splines->control_x[i], sp->splines->control_y[i]);
|
||||
}
|
||||
#endif
|
||||
return True;
|
||||
}
|
||||
|
||||
#ifndef STANDALONE
|
||||
extern char *background;
|
||||
extern char *foreground;
|
||||
#endif
|
||||
|
||||
void
|
||||
init_starfish(ModeInfo * mi)
|
||||
{
|
||||
Display *display = MI_DISPLAY(mi);
|
||||
Window window = MI_WINDOW(mi);
|
||||
XGCValues gcv;
|
||||
starfishstruct *sp;
|
||||
|
||||
/* initialize */
|
||||
if (starfishes == NULL) {
|
||||
|
||||
if ((starfishes = (starfishstruct *) calloc(MI_NUM_SCREENS(mi),
|
||||
sizeof (starfishstruct))) == NULL)
|
||||
return;
|
||||
}
|
||||
sp = &starfishes[MI_SCREEN(mi)];
|
||||
sp->mi = mi;
|
||||
|
||||
if (MI_IS_FULLRANDOM(mi)) {
|
||||
if (NRAND(10) == 9)
|
||||
sp->blob_p = True;
|
||||
else
|
||||
sp->blob_p = False;
|
||||
if (NRAND(8) == 7)
|
||||
sp->cycle_p = False;
|
||||
else
|
||||
sp->cycle_p = True;
|
||||
} else {
|
||||
sp->blob_p = blob;
|
||||
sp->cycle_p = cycle_p;
|
||||
}
|
||||
sp->rotv = (double) rotv;
|
||||
sp->direction = (LRAND() & 1) ? 1 : -1;
|
||||
if (thickness < 0)
|
||||
sp->thickness = -thickness * (float) LRAND() / (float) MAXRAND;
|
||||
else
|
||||
sp->thickness = thickness;
|
||||
if (sp->blob_p)
|
||||
sp->fg_index = MI_BLACK_PIXEL(mi);
|
||||
else
|
||||
sp->fg_index = MI_WHITE_PIXEL(mi);
|
||||
|
||||
if (sp->gc == None) {
|
||||
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
|
||||
XColor color;
|
||||
|
||||
#ifndef STANDALONE
|
||||
sp->fg = MI_FG_PIXEL(mi);
|
||||
sp->bg = MI_BG_PIXEL(mi);
|
||||
#endif
|
||||
sp->blackpixel = MI_BLACK_PIXEL(mi);
|
||||
sp->whitepixel = MI_WHITE_PIXEL(mi);
|
||||
if ((sp->cmap = XCreateColormap(display, window,
|
||||
MI_VISUAL(mi), AllocNone)) == None) {
|
||||
free_starfish(display, sp);
|
||||
return;
|
||||
}
|
||||
XSetWindowColormap(display, window, sp->cmap);
|
||||
(void) XParseColor(display, sp->cmap, "black", &color);
|
||||
(void) XAllocColor(display, sp->cmap, &color);
|
||||
MI_BLACK_PIXEL(mi) = color.pixel;
|
||||
(void) XParseColor(display, sp->cmap, "white", &color);
|
||||
(void) XAllocColor(display, sp->cmap, &color);
|
||||
MI_WHITE_PIXEL(mi) = color.pixel;
|
||||
#ifndef STANDALONE
|
||||
(void) XParseColor(display, sp->cmap, background, &color);
|
||||
(void) XAllocColor(display, sp->cmap, &color);
|
||||
MI_BG_PIXEL(mi) = color.pixel;
|
||||
(void) XParseColor(display, sp->cmap, foreground, &color);
|
||||
(void) XAllocColor(display, sp->cmap, &color);
|
||||
MI_FG_PIXEL(mi) = color.pixel;
|
||||
#endif
|
||||
sp->colors = (XColor *) NULL;
|
||||
sp->ncolors = 0;
|
||||
}
|
||||
gcv.foreground = sp->fg_index;
|
||||
gcv.fill_rule = EvenOddRule;
|
||||
if ((sp->gc = XCreateGC(display, window,
|
||||
GCForeground | GCFillRule, &gcv)) == None) {
|
||||
free_starfish(display, sp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
|
||||
/* Set up colour map */
|
||||
if (sp->colors != NULL) {
|
||||
if (sp->ncolors && !sp->no_colors)
|
||||
free_colors(display, sp->cmap, sp->colors, sp->ncolors);
|
||||
free(sp->colors);
|
||||
sp->colors = (XColor *) NULL;
|
||||
}
|
||||
sp->ncolors = MI_NCOLORS(mi);
|
||||
if (sp->ncolors < 2)
|
||||
sp->ncolors = 2;
|
||||
if (sp->ncolors <= 2)
|
||||
sp->mono_p = True;
|
||||
else
|
||||
sp->mono_p = False;
|
||||
|
||||
if (sp->mono_p)
|
||||
sp->colors = (XColor *) NULL;
|
||||
else
|
||||
if ((sp->colors = (XColor *) malloc(sizeof (*sp->colors) *
|
||||
(sp->ncolors + 1))) == NULL) {
|
||||
free_starfish(display, sp);
|
||||
return;
|
||||
}
|
||||
|
||||
if (sp->mono_p || sp->blob_p)
|
||||
sp->cycle_p = False;
|
||||
if (!sp->mono_p) {
|
||||
if (LRAND() % 3)
|
||||
make_smooth_colormap(mi, sp->cmap, sp->colors, &sp->ncolors,
|
||||
True, &sp->cycle_p);
|
||||
else
|
||||
make_uniform_colormap(mi, sp->cmap, sp->colors, &sp->ncolors,
|
||||
True, &sp->cycle_p);
|
||||
}
|
||||
XInstallColormap(display, sp->cmap);
|
||||
if (sp->ncolors < 2) {
|
||||
sp->ncolors = 2;
|
||||
sp->no_colors = True;
|
||||
} else
|
||||
sp->no_colors = False;
|
||||
if (sp->ncolors <= 2)
|
||||
sp->mono_p = True;
|
||||
|
||||
if (sp->mono_p)
|
||||
sp->cycle_p = False;
|
||||
|
||||
sp->fg_index = 0;
|
||||
|
||||
/* if (!sp->mono_p && !sp->blob_p)
|
||||
{
|
||||
gcv.foreground = sp->colors[sp->fg_index].pixel;
|
||||
XSetWindowBackground (display, window, gcv.foreground);
|
||||
} */
|
||||
|
||||
} else
|
||||
sp->fg_index = NRAND(MI_NPIXELS(mi));
|
||||
|
||||
sp->size = (MI_WIDTH(mi) < MI_HEIGHT(mi) ? MI_WIDTH(mi) : MI_HEIGHT(mi));
|
||||
if (sp->blob_p)
|
||||
sp->size /= 2;
|
||||
else
|
||||
sp->size = (int) (sp->size * 1.3);
|
||||
sp->winwidth = MI_WIDTH(mi);
|
||||
sp->winheight = MI_HEIGHT(mi);
|
||||
MI_CLEARWINDOW(mi);
|
||||
if (sp->prev != NULL) {
|
||||
free(sp->prev);
|
||||
sp->prev = (XPoint *) NULL;
|
||||
}
|
||||
sp->stage = 0;
|
||||
sp->counter = 0;
|
||||
make_starfish(mi);
|
||||
}
|
||||
|
||||
static Bool
|
||||
run_starfish(ModeInfo * mi)
|
||||
{
|
||||
Display *display = MI_DISPLAY(mi);
|
||||
Window window = MI_WINDOW(mi);
|
||||
starfishstruct *sp = &starfishes[MI_SCREEN(mi)];
|
||||
|
||||
throb_starfish(sp);
|
||||
spin_starfish(sp);
|
||||
if (!draw1_starfish(display, window, sp->gc, sp))
|
||||
return False;
|
||||
|
||||
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
|
||||
if (sp->mono_p) {
|
||||
if (!sp->blob_p) {
|
||||
sp->fg_index = (sp->fg_index == MI_BLACK_PIXEL(mi) ?
|
||||
MI_BLACK_PIXEL(mi) : MI_BLACK_PIXEL(mi));
|
||||
}
|
||||
XSetForeground(display, sp->gc, sp->fg_index);
|
||||
} else {
|
||||
sp->fg_index = (sp->fg_index + 1) % sp->ncolors;
|
||||
XSetForeground(display, sp->gc, sp->colors[sp->fg_index].pixel);
|
||||
}
|
||||
} else {
|
||||
if (MI_NPIXELS(mi) > 2)
|
||||
XSetForeground(display, sp->gc, MI_PIXEL(mi, sp->fg_index));
|
||||
else if (sp->fg_index)
|
||||
XSetForeground(display, sp->gc, MI_BLACK_PIXEL(mi));
|
||||
else
|
||||
XSetForeground(display, sp->gc, MI_WHITE_PIXEL(mi));
|
||||
if (++sp->fg_index >= (unsigned int) MI_NPIXELS(mi))
|
||||
sp->fg_index = 0;
|
||||
}
|
||||
return True;
|
||||
}
|
||||
|
||||
void
|
||||
draw_starfish(ModeInfo * mi)
|
||||
{
|
||||
Display *display = MI_DISPLAY(mi);
|
||||
starfishstruct *sp;
|
||||
|
||||
if (starfishes == NULL)
|
||||
return;
|
||||
sp = &starfishes[MI_SCREEN(mi)];
|
||||
if (sp->r == NULL)
|
||||
return;
|
||||
|
||||
if (sp->no_colors) {
|
||||
free_starfish(display, sp);
|
||||
init_starfish(mi);
|
||||
return;
|
||||
}
|
||||
MI_IS_DRAWN(mi) = True;
|
||||
|
||||
if (!sp->stage) {
|
||||
if (!run_starfish(mi))
|
||||
return;
|
||||
} else if (sp->cycle_p) {
|
||||
rotate_colors(display, sp->cmap, sp->colors, sp->ncolors, sp->direction);
|
||||
|
||||
if (!NRAND(512))
|
||||
sp->direction = -sp->direction;
|
||||
}
|
||||
sp->stage++;
|
||||
|
||||
if (sp->stage > (2 * sp->blob_p + 1) * cyclespeed) {
|
||||
sp->stage = 0;
|
||||
sp->counter++;
|
||||
}
|
||||
if (sp->counter > MI_CYCLES(mi)) {
|
||||
/* Every now and then, restart the mode */
|
||||
init_starfish(mi);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
release_starfish(ModeInfo * mi)
|
||||
{
|
||||
if (starfishes != NULL) {
|
||||
int screen;
|
||||
|
||||
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
|
||||
free_starfish(MI_DISPLAY(mi), &starfishes[screen]);
|
||||
free(starfishes);
|
||||
starfishes = (starfishstruct *) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* MODE_starfish */
|
||||
Loading…
Add table
Add a link
Reference in a new issue