nsaver.c

一个嵌入式操作系统(microwindows)的源代码

	}
}

void saver6_drawbolt(nstate *state, s6state *s, int bolt, int delete)
{
	int n;

	for(n = 0; n < SAVER6_MAXFORKS; n++)
		if(s->bolts[bolt].forks[n].valid)
			saver6_drawfork(state, s, bolt, n, delete);
}

void saver6_drawlightning(nstate *state, s6state *s, int delete)
{
	int i;

	for(i = 0; i < SAVER6_MAXBOLTS; i++) {
		if(s->bolts[i].duration) {
			if(delete) s->bolts[i].duration--;
			saver6_drawbolt(state, s, i, delete);
		}
	}
}

void saver6_exposure(nstate *state)
{
	s6state *s = state->priv;

	GrClearWindow(state->main_window, 0);

	saver6_drawlightning(state, s, 0);
}

void saver6_setvertices(s6state *s, int bolt, int fork, int vert, GR_COORD x,
								GR_COORD y)
{
	int i;

	for(i = 0; i < SAVER6_THICKNESS; i++) {
		s->bolts[bolt].forks[fork].vertices[i][vert].x = x + i;
		s->bolts[bolt].forks[fork].vertices[i][vert].y = y;
	}
}

void saver6_perturb(nstate *state, GR_COORD *x, GR_COORD *y, int maxperturb)
{
	*x += (int)FRANDRANGE(0, (maxperturb - 1.0)) -
				(double)(maxperturb / 2.0);
	if(*x < 0) *x = 0;
	if(*x > (state->si.cols - 1)) *x = state->si.cols - 1;

	*y += (int)FRANDRANGE(0, (maxperturb - 1.0)) -
				(double)(maxperturb / 2.0);
	if(*y < 0) *y = 0;
	if(*y > (state->si.cols - 1)) *y = state->si.cols - 1;
}

void saver6_makefork(nstate *state, s6state *s, int bolt, int fork, GR_COORD x,
								GR_COORD y)
{
	int i, vertices;
	double length, incr, pos, angle, scale;
	GR_COORD ex, ey, nx, ny, xlen, ylen;

	saver6_setvertices(s, bolt, fork, 0, x , y);

	scale = (double)(state->si.rows - y) / (double)state->si.rows;

	vertices = (int)(scale * (double)RANDRANGE(SAVER6_MINFULLVERTICES,
						SAVER6_MAXVERTICES));

	if(vertices < SAVER6_MINVERTICES) vertices = SAVER6_MINVERTICES;

	s->bolts[bolt].forks[fork].valid = vertices;

	ey = state->si.rows - SAVER6_MAXEND_Y +
		(int)FRANDRANGE(0, SAVER6_MAXEND_Y - 1.0);
	if((ey - y) <= 0) ey = SAVER6_MINDROP;
	if(ey >= (state->si.rows - 1)) ey = state->si.rows - 1;

	if(!fork) {
		ex = x + FRANDRANGE(0, ((state->si.cols - 1.0) / 2.0));
	} else {
		ex = x + (FRANDRANGE(0, (ey - y)) / 2.0) - ((ey - y) / 2.0);
	}

	if(ex >= state->si.cols) ex = state->si.cols - 1;
	if(ex < 0) ex = 0;

	xlen = MAX(x, ex) - MIN(x, ex);
	ylen = MAX(y, ey) - MIN(y, ey);

	length = sqrt(((double)(xlen * xlen) + (double)(ylen * ylen)));
	incr = length / (vertices - 1);
	angle = atan(((double)xlen / (double)ylen));

	for(i = vertices - 1; i ; i--) {
		pos = (incr * (i - 1)) + (FRANDRANGE(0, SAVER6_MAXZIGZAG) -
					((double)SAVER6_MAXZIGZAG / 2.0));
		if(pos < 0) pos = 0;
		if(pos > length) pos = length;
		nx = x - (pos * sin(angle));
		ny = y + pos * cos(angle);
		saver6_perturb(state, &nx, &ny, SAVER6_MAXZIGZAG);
		saver6_setvertices(s, bolt, fork, i, nx , ny);
	}
}

int saver6_makeforks(nstate *state, s6state *s, int bolt, int fork,
						int *vert, int *nextfork)
{
	int thisvert = 1, thisfork;
	double prob;

	if(*vert == (s->bolts[bolt].forks[fork].valid - 1)) return 0;
	if(*nextfork == SAVER6_MAXFORKS) return 0;

 	prob = (double)SAVER6_FORK_PROBABILITY * ((double)*vert /
				(double)s->bolts[bolt].forks[fork].valid) *
					(1.0 / ((double)fork + 1.0));
	if((double)FRANDRANGE(0, 1) < prob) {
		thisfork = *nextfork;
		saver6_makefork(state, s, bolt, thisfork,
			s->bolts[bolt].forks[fork].vertices[0][*vert].x,
			s->bolts[bolt].forks[fork].vertices[0][*vert].y);
		*nextfork += 1;
		while(saver6_makeforks(state, s, bolt, thisfork, &thisvert,
								nextfork));
	}

	*vert += 1;

	return 1;
}

void saver6_makebolt(nstate *state, s6state *s, int bolt)
{
	GR_COORD x;
	int vert = 1, nextfork = 1, n;

	for(n = 0; n < SAVER6_MAXFORKS; n++)
		s->bolts[bolt].forks[n].valid = 0;

	x = RANDRANGE(0, state->si.cols - 1);

	saver6_makefork(state, s, bolt, 0, x, 0);

	while(saver6_makeforks(state, s, bolt, 0, &vert, &nextfork));
}

void saver6_newbolt(nstate *state, s6state *s)
{
	int i;

	for(i = 0; i < SAVER6_MAXBOLTS; i++) {
		if(!s->bolts[i].duration) {
			saver6_makebolt(state, s, i);
			s->bolts[i].duration = RANDRANGE(SAVER6_MINDURATION,
							SAVER6_MAXDURATION);
			saver6_drawbolt(state, s, i, 0);
			break;
		}
	}

	s->new_bolt_time = RANDRANGE(1, SAVER6_MAXNEWBOLTTIME);
}

void saver6_perturb_bolt(nstate *state, s6state *s, int bolt, int fork)
{
	int m, o;
	GR_COORD x, ox, y, oy;

	for(m = 1; m < s->bolts[bolt].forks[fork].valid; m++) {
		ox = x = s->bolts[bolt].forks[fork].vertices[0][m].x;
		oy = y = s->bolts[bolt].forks[fork].vertices[0][m].y;
		saver6_perturb(state, &x, &y, SAVER6_MAXZIGZAG);
		saver6_setvertices(s, bolt, fork, m, x, y);
		for(o = fork + 1; o < SAVER6_MAXFORKS; o++) {
			if((s->bolts[bolt].forks[o].vertices[0][0].x == ox) &&
				(s->bolts[bolt].forks[o].vertices[0][0].y
								== oy)) {
				saver6_setvertices(s, bolt, o, 0, x, y);
			}
		}
	}
}

void saver6_perturb_lightning(nstate *state, s6state *s)
{
	int i, n;

	for(i = 0; i < SAVER6_MAXBOLTS; i++) {
		if(!s->bolts[i].duration) continue;
		for(n = 0; n < SAVER6_MAXFORKS; n++) {
			if(!s->bolts[i].forks[n].valid) continue;
			saver6_perturb_bolt(state, s, i, n);
		}
	}
}

void saver6_animate(nstate *state)
{
	s6state *s = state->priv;

	saver6_drawlightning(state, s, 1);
	saver6_perturb_lightning(state, s);
	saver6_drawlightning(state, s, 0);

	if(!s->new_bolt_time--) saver6_newbolt(state, s);
}

/* The algorithm used in saver7 was adapted from "grav" by Greg Bowering */

void saver7_drawstar(nstate *state, s7state *s)
{
	GrSetGCForeground(state->main_gc, SAVER7_STARCOLOUR);
	GrFillEllipse(state->main_window, state->main_gc, s->starx, s->stary,
				SAVER7_STARRADIUS, SAVER7_STARRADIUS);
}

void saver7_drawplanet(nstate *state, s7state *s, int planet, int erase)
{
	if(erase) GrSetGCForeground(state->main_gc, GR_COLOR_BLACK);
	else GrSetGCForeground(state->main_gc, s->planets[planet].colour);

	if((s->planets[planet].ax < 0) || (s->planets[planet].ay < 0) ||
			(s->planets[planet].ax >= state->si.cols) ||
			(s->planets[planet].ay >= state->si.rows)) {
		return;
	}

	GrFillEllipse(state->main_window, state->main_gc, s->planets[planet].ax,
				s->planets[planet].ay,
				SAVER7_PLANETRADIUS, SAVER7_PLANETRADIUS);
}

void saver7_calc_planet_position(nstate *state, s7state *s, int planet)
{
	if(s->planets[planet].r > -SAVER7_ALMOSTDIST) {
		s->planets[planet].ax = (int)((double) state->si.cols *
			(0.5 + (s->planets[planet].x / (s->planets[planet].r +
							SAVER7_DIST))));
		s->planets[planet].ay = (int)((double) state->si.rows *
			(0.5 + (s->planets[planet].y / (s->planets[planet].r +
							SAVER7_DIST))));
	} else {
		s->planets[planet].ax = -1;
		s->planets[planet].ay = -1;
	}
}

void saver7_init(nstate *state)
{
	int i;
	s7state *s = my_malloc(sizeof(s7state));
	state->priv = s;

	s->starx = state->si.cols / 2;
	s->stary = state->si.rows / 2;

	for(i = 0; i < SAVER7_PLANETS; i++) {
		s->planets[i].r = FRANDRANGE(SAVER7_MIN_STARTDIM,
						SAVER7_MAX_STARTDIM);
		s->planets[i].x = FRANDRANGE(SAVER7_MIN_STARTDIM,
						SAVER7_MAX_STARTDIM);
		s->planets[i].y = FRANDRANGE(SAVER7_MIN_STARTDIM,
						SAVER7_MAX_STARTDIM);
		s->planets[i].rv = FRANDRANGE(SAVER7_MIN_STARTVEL,
						SAVER7_MAX_STARTVEL);
		s->planets[i].xv = FRANDRANGE(SAVER7_MIN_STARTVEL,
						SAVER7_MAX_STARTVEL);
		s->planets[i].yv = FRANDRANGE(SAVER7_MIN_STARTVEL,
						SAVER7_MAX_STARTVEL);
		s->planets[i].colour = RANDRANGE(0, state->si.ncolors - 1);
		saver7_calc_planet_position(state, s, i);
		saver7_drawplanet(state, s, i, 0);
	}

	saver7_drawstar(state, s);

	state->animate_interval = SAVER7_DELAY;
}

void saver7_exposure(nstate *state)
{
	int i;
	s7state *s = state->priv;

	GrClearWindow(state->main_window, 0);

	for(i = 0; i < SAVER7_PLANETS; i++)
		saver7_drawplanet(state, s, i, 0);

	saver7_drawstar(state, s);
}

void saver7_moveplanet(nstate *state, s7state *s, int planet)
{
	double dist;
	double accel;

	dist = (s->planets[planet].x * s->planets[planet].x) +
		(s->planets[planet].y * s->planets[planet].y) +
		(s->planets[planet].r * s->planets[planet].r);
	if(dist < SAVER7_COLLIDE) dist = SAVER7_COLLIDE;
	dist = sqrt(dist);
	dist = dist * dist * dist;

#ifdef SAVER7_USE_DAMPING
	accel = s->planets[planet].r * SAVER7_G / dist;
	if(accel > SAVER7_MAX_ACCEL) accel = SAVER7_MAX_ACCEL;
	else if(accel < -SAVER7_MAX_ACCEL) accel = -SAVER7_MAX_ACCEL;
	s->planets[planet].rv = (s->planets[planet].rv + accel) *
						SAVER7_DAMPING_FACTOR;
	s->planets[planet].r += s->planets[planet].rv;
	accel = s->planets[planet].x * SAVER7_G / dist;
	if(accel > SAVER7_MAX_ACCEL) accel = SAVER7_MAX_ACCEL;
	else if(accel < -SAVER7_MAX_ACCEL) accel = -SAVER7_MAX_ACCEL;
	s->planets[planet].xv = (s->planets[planet].xv + accel) *
						SAVER7_DAMPING_FACTOR;
	s->planets[planet].x += s->planets[planet].xv;
	accel = s->planets[planet].y * SAVER7_G / dist;
	if(accel > SAVER7_MAX_ACCEL) accel = SAVER7_MAX_ACCEL;
	else if(accel < -SAVER7_MAX_ACCEL) accel = -SAVER7_MAX_ACCEL;
	s->planets[planet].yv = (s->planets[planet].yv + accel) *
						SAVER7_DAMPING_FACTOR;
	s->planets[planet].y += s->planets[planet].yv;
#else
	accel = s->planets[planet].r * SAVER7_G / dist;
	s->planets[planet].rv += accel;
	s->planets[planet].r += s->planets[planet].rv;
	accel = s->planets[planet].x * SAVER7_G / dist;
	s->planets[planet].xv += accel;
	s->planets[planet].x += s->planets[planet].xv;
	accel = s->planets[planet].y * SAVER7_G / dist;
	s->planets[planet].yv += accel;
	s->planets[planet].y += s->planets[planet].yv;
#endif
}

void saver7_animate(nstate *state)
{
	int i;
	s7state *s = state->priv;

	for(i = 0; i < SAVER7_PLANETS; i++) {
		saver7_moveplanet(state, s, i);
		saver7_drawplanet(state, s, i, 1);
		saver7_calc_planet_position(state, s, i);
		saver7_drawplanet(state, s, i, 0);
	}
	saver7_drawstar(state, s);
}

/* The algorithm used in saver8 is based on that found at: 
   http://www.go2net.com/internet/deep/1997/04/16/body.html */

void saver8_init(nstate *state)
{
	int red = 0, green = 0, blue = 0, step, i = 0;

	s8state *s = my_malloc(sizeof(s8state));
	state->priv = s;

	s->current_line = 0;

	step = 512 / SAVER8_NUMCOLOURS;

	for(green = 255; green > 0; green -= step, blue += step, i++)
		GrFindColor(GR_RGB(0, green, blue), &s->colours[i]);
	for(blue = 255; blue > 0; blue -= step, red += step, i++)
		GrFindColor(GR_RGB(red, 0, blue), &s->colours[i]);
	
	s->rows = my_malloc(sizeof(GR_PIXELVAL) * state->si.cols *
			SAVER8_LINES_PER_FRAME);
	
	state->animate_interval = SAVER8_DELAY1;
}

void saver8_drawpattern(nstate *state)
{
	int x, y, col, newfactor, lines = SAVER8_LINES_PER_FRAME;
	s8state *s = state->priv;
	GR_PIXELVAL *p = s->rows;

	if(!s->current_line) {
		state->animate_interval = SAVER8_DELAY1;
		do {
			newfactor = RANDRANGE(SAVER8_MINFACTOR,
					SAVER8_MAXFACTOR);
		} while(newfactor == s->factor);
		s->factor = newfactor;
	}

	y = s->current_line;
	while(s->current_line < state->si.rows) {
		if(!--lines) break;
		for(x = 0; x < state->si.cols; x++) {
			col = ((((x * x) + (s->current_line * s->current_line))
					/ s->factor) % SAVER8_NUMCOLOURS);
			*p++ = s->colours[col];
		}
		s->current_line++;
	}

	GrArea(state->main_window, state->main_gc, 0, y, state->si.cols,
			s->current_line - y, s->rows, MWPF_PIXELVAL);

	if(lines) {
		state->animate_interval = SAVER8_DELAY2;
		s->current_line = 0;
	}
}

void saver8_exposure(nstate *state)
{
	s8state *s = state->priv;

	GrClearWindow(state->main_window, 0);
	s->current_line = 0;
	saver8_drawpattern(state);
}

void saver8_animate(nstate *state)
{
	saver8_drawpattern(state);
}

/* saver9 is based on the melt mode of decay from xscreensaver. */

void saver9_init(nstate *state)
{
	s9state *s = my_malloc(sizeof(s9state));
	state->priv = s;