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
946
app/xlockmore/modes/scooter.c
Normal file
946
app/xlockmore/modes/scooter.c
Normal file
|
|
@ -0,0 +1,946 @@
|
|||
/* -*- Mode: C; tab-width: 4 -*- */
|
||||
/* scooter -- a journey through space tunnel and stars */
|
||||
|
||||
#if !defined( lint ) && !defined( SABER )
|
||||
static const char sccsid[] = "@(#)scooter.c 5.01 2001/03/02 xlockmore";
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* scooter.c
|
||||
*
|
||||
* Copyright (c) 2001 Sven Thoennissen <posse@gmx.net>
|
||||
*
|
||||
* This program is based on the original "scooter", a blanker module from the
|
||||
* Nightshift screensaver which is part of EGS (Enhanced Graphics System) on
|
||||
* the Amiga computer. EGS has been developed by VIONA Development.
|
||||
*
|
||||
*
|
||||
* (now the obligatory stuff)
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software and its
|
||||
* documentation for any purpose and without fee is hereby granted,
|
||||
* provided that the above copyright notice appear in all copies and that
|
||||
* both that copyright notice and this permission notice appear in
|
||||
* supporting documentation.
|
||||
*
|
||||
* This file is provided AS IS with no warranties of any kind. The author
|
||||
* shall have no liability with respect to the infringement of copyrights,
|
||||
* trade secrets or any patents by this file or any part thereof. In no
|
||||
* event will the author be liable for any lost revenue or profits or
|
||||
* other special, indirect and consequential damages.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifdef STANDALONE
|
||||
#define MODE_scooter
|
||||
#define PROGCLASS "Scooter"
|
||||
#define HACK_INIT init_scooter
|
||||
#define HACK_DRAW draw_scooter
|
||||
#define scooter_opts xlockmore_opts
|
||||
#define DEFAULTS "*delay: 20000 \n" \
|
||||
"*count: 24 \n" \
|
||||
"*cycles: 5 \n" \
|
||||
"*size: 100 \n" \
|
||||
"*ncolors: 200 \n" \
|
||||
"*fullrandom: True \n" \
|
||||
"*verbose: False \n"
|
||||
#include "xlockmore.h" /* in xscreensaver distribution */
|
||||
#else /* STANDALONE */
|
||||
#include "xlock.h" /* in xlockmore distribution */
|
||||
#endif /* STANDALONE */
|
||||
|
||||
#ifdef MODE_scooter
|
||||
|
||||
ModeSpecOpt scooter_opts =
|
||||
{0, (XrmOptionDescRec *) NULL, 0, (argtype *) NULL, (OptionStruct *) NULL};
|
||||
|
||||
#ifdef USE_MODULES
|
||||
ModStruct scooter_description =
|
||||
{"scooter", "init_scooter", "draw_scooter", "release_scooter",
|
||||
"refresh_scooter", "change_scooter", (char *) NULL, &scooter_opts,
|
||||
20000, 24, 5, 100, 64, 1.0, "",
|
||||
"Shows a journey through space tunnel and stars", 0, NULL};
|
||||
/*
|
||||
* count = number of doors
|
||||
* cycles = speed (see MIN/MAX_SPEED below)
|
||||
* size = number of stars
|
||||
*
|
||||
*/
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
int x, y, z;
|
||||
} Vec3D;
|
||||
|
||||
typedef struct {
|
||||
int x, y, z;
|
||||
} Angle3D;
|
||||
|
||||
typedef struct {
|
||||
int r, g, b;
|
||||
} ColorRGB;
|
||||
|
||||
typedef struct {
|
||||
XPoint lefttop, rightbottom;
|
||||
} Rect;
|
||||
|
||||
typedef struct {
|
||||
Vec3D coords[4]; /* lefttop, righttop, rightbottom, leftbottom */
|
||||
int zelement;
|
||||
unsigned long color;
|
||||
char freecolor;
|
||||
char pad;
|
||||
} Door;
|
||||
|
||||
typedef struct {
|
||||
int xpos, ypos;
|
||||
int width, height;
|
||||
int zelement;
|
||||
short draw;
|
||||
} Star;
|
||||
|
||||
/* define this to see a pixel for each zelement */
|
||||
/*
|
||||
#define _DRAW_ZELEMENTS
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
Vec3D pos;
|
||||
Angle3D angle;
|
||||
} ZElement;
|
||||
|
||||
typedef struct {
|
||||
Star *stars;
|
||||
Door *doors;
|
||||
ZElement *zelements;
|
||||
int doorcount, ztotal, speed;
|
||||
int zelements_per_door, zelement_distance, spectator_zelement;
|
||||
int projnorm_z, rotationDuration, rotationStep, starcount;
|
||||
Angle3D currentRotation, rotationDelta;
|
||||
|
||||
/* doors color cycling stuff */
|
||||
ColorRGB begincolor, endcolor;
|
||||
int colorcount, colorsteps;
|
||||
|
||||
/* scale all stars and doors to window dimensions */
|
||||
float aspect_scale;
|
||||
|
||||
Bool halt_scooter;
|
||||
} scooterstruct;
|
||||
|
||||
static scooterstruct *scooters = (scooterstruct *) NULL;
|
||||
|
||||
#define MIN_DOORS 4
|
||||
|
||||
#define MIN_SPEED 1
|
||||
#define MAX_SPEED 10
|
||||
|
||||
#define SPACE_XY_FACTOR 10
|
||||
|
||||
#define DOOR_WIDTH (600*SPACE_XY_FACTOR)
|
||||
#define DOOR_HEIGHT (400*SPACE_XY_FACTOR)
|
||||
|
||||
/* stars distance from doors center */
|
||||
#define STAR_MIN_X (1000*SPACE_XY_FACTOR)
|
||||
#define STAR_MIN_Y (750*SPACE_XY_FACTOR)
|
||||
#define STAR_MAX_X (10000*SPACE_XY_FACTOR)
|
||||
#define STAR_MAX_Y (7500*SPACE_XY_FACTOR)
|
||||
|
||||
/* star size (random) */
|
||||
#define STAR_SIZE_MIN (2*SPACE_XY_FACTOR)
|
||||
#define STAR_SIZE_MAX (64*SPACE_XY_FACTOR)
|
||||
|
||||
/* greater values make scooter run harder curves, smaller values produce calm curves */
|
||||
#define DOOR_CURVEDNESS 14
|
||||
|
||||
/* 3d->2d projection (greater values create more fish-eye effect) */
|
||||
#define PROJECTION_DEGREE 2.4
|
||||
|
||||
/* this is my resolution at which scooter is in its original size, producing a 4:3 aspect ratio.
|
||||
* all variables in this module are adjusted for this screen size; if scooter is run
|
||||
* in windows with different size, it knows how to rescale itself.
|
||||
*/
|
||||
#define ASPECT_SCREENWIDTH 1152
|
||||
#define ASPECT_SCREENHEIGHT 864
|
||||
|
||||
/* we define our own sin/cos macros to be faaast ;-) (good old Amiga times) */
|
||||
#define SINUSTABLE_SIZE 0x8000
|
||||
#define SINUSTABLE_MASK 0x7fff
|
||||
#define SIN(a) sintable[a & SINUSTABLE_MASK]
|
||||
#define COS(a) sintable[(a+(SINUSTABLE_SIZE/4)) & SINUSTABLE_MASK]
|
||||
|
||||
/* signum function */
|
||||
#define SGN(a) (a < 0 ? -1 : 1)
|
||||
|
||||
static float *sintable = (float *) NULL;
|
||||
|
||||
static void
|
||||
randomcolor(ColorRGB *col)
|
||||
{
|
||||
unsigned long n;
|
||||
|
||||
/* col->r = NRAND(65536);
|
||||
col->g = NRAND(65536);
|
||||
col->b = NRAND(65536);
|
||||
*/
|
||||
/* col->r = LRAND() & 0xffff;
|
||||
col->g = LRAND() & 0xffff;
|
||||
col->b = LRAND() & 0xffff;
|
||||
*/
|
||||
/* this seems best */
|
||||
n = NRAND(0x1000000);
|
||||
col->r = (n>>16)<<8;
|
||||
col->g = ((n>>8) & 0xff)<<8;
|
||||
col->b = (n & 0xff)<<8;
|
||||
}
|
||||
|
||||
static void
|
||||
initdoorcolors(scooterstruct *sp)
|
||||
{
|
||||
/* prepare initial values for nextdoorcolor() */
|
||||
|
||||
randomcolor(&sp->endcolor);
|
||||
|
||||
sp->colorcount = 0;
|
||||
sp->colorsteps = 0;
|
||||
}
|
||||
|
||||
static void nextdoorcolor(ModeInfo *mi, Door *door)
|
||||
{
|
||||
scooterstruct *sp = &scooters[MI_SCREEN(mi)];
|
||||
Display *display = MI_DISPLAY(mi);
|
||||
XColor xcol;
|
||||
|
||||
/* uncomment this to color the doors from xlock's palette (created with saturation value) */
|
||||
#if 0
|
||||
if (MI_NPIXELS(mi) > 2) {
|
||||
if (++colorcount >= MI_NPIXELS(mi))
|
||||
colorcount = 0;
|
||||
door->color = MI_PIXEL(mi,colorcount);
|
||||
} else
|
||||
door->color = MI_WHITE_PIXEL(mi);
|
||||
return;
|
||||
#endif
|
||||
if (door->freecolor) {
|
||||
XFreeColors(display, MI_COLORMAP(mi), &(door->color), 1, 0);
|
||||
door->freecolor = 0;
|
||||
}
|
||||
if (MI_NPIXELS(mi) <= 2) {
|
||||
door->color = MI_WHITE_PIXEL(mi);
|
||||
return;
|
||||
}
|
||||
|
||||
if (sp->colorcount >= sp->colorsteps) {
|
||||
|
||||
/* init next color ramp */
|
||||
|
||||
sp->colorcount = 0;
|
||||
sp->colorsteps = 8 + NRAND(32);
|
||||
sp->begincolor = sp->endcolor;
|
||||
randomcolor(&sp->endcolor);
|
||||
}
|
||||
|
||||
/* compute next color values */
|
||||
|
||||
xcol.red = sp->begincolor.r + ((sp-> endcolor.r - sp->begincolor.r) *
|
||||
sp->colorcount / sp->colorsteps);
|
||||
xcol.green = sp->begincolor.g + ((sp-> endcolor.g - sp->begincolor.g) *
|
||||
sp->colorcount / sp->colorsteps);
|
||||
xcol.blue = sp->begincolor.b + ((sp-> endcolor.b - sp->begincolor.b) *
|
||||
sp->colorcount / sp->colorsteps);
|
||||
xcol.pixel = 0;
|
||||
xcol.flags = DoRed | DoGreen | DoBlue;
|
||||
|
||||
sp->colorcount++;
|
||||
|
||||
if (!XAllocColor(display, MI_COLORMAP(mi), &xcol)) {
|
||||
/* fail safe */
|
||||
door->color = MI_WHITE_PIXEL(mi);
|
||||
door->freecolor = 0;
|
||||
} else {
|
||||
door->color = xcol.pixel;
|
||||
door->freecolor = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
free_scooter(scooterstruct *sp)
|
||||
{
|
||||
if (sp->doors != NULL) {
|
||||
free(sp->doors);
|
||||
sp->doors = (Door *) NULL;
|
||||
}
|
||||
if (sp->stars != NULL) {
|
||||
free(sp->stars);
|
||||
sp->stars = (Star *) NULL;
|
||||
}
|
||||
if (sp->zelements != NULL) {
|
||||
free(sp->zelements);
|
||||
sp->zelements = (ZElement *) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void release_scooter(ModeInfo *mi)
|
||||
{
|
||||
if (scooters != NULL) {
|
||||
int screen;
|
||||
|
||||
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
|
||||
free_scooter(&scooters[screen]);
|
||||
free(scooters);
|
||||
scooters = (scooterstruct *) NULL;
|
||||
}
|
||||
if (sintable != NULL) {
|
||||
free(sintable);
|
||||
sintable = (float *) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void init_scooter(ModeInfo *mi)
|
||||
{
|
||||
int i;
|
||||
scooterstruct *sp;
|
||||
|
||||
if (scooters == NULL) {
|
||||
if ((scooters = (scooterstruct *) calloc(MI_NUM_SCREENS(mi),
|
||||
sizeof (scooterstruct))) == NULL)
|
||||
return;
|
||||
}
|
||||
sp = &scooters[MI_SCREEN(mi)];
|
||||
|
||||
sp->doorcount = MAX(MI_COUNT(mi),MIN_DOORS);
|
||||
sp->speed = MI_CYCLES(mi);
|
||||
sp->starcount = MI_SIZE(mi);
|
||||
if (sp->starcount < 1)
|
||||
sp->starcount = 1;
|
||||
if (sp->speed < MIN_SPEED)
|
||||
sp->speed = MIN_SPEED;
|
||||
if (sp->speed > MAX_SPEED)
|
||||
sp->speed = MAX_SPEED;
|
||||
sp->zelements_per_door = 60;
|
||||
sp->zelement_distance = 300;
|
||||
sp->ztotal = sp->doorcount * sp->zelements_per_door;
|
||||
/* sp->z_maxdepth = sp->ztotal * sp->zelement_distance; */
|
||||
if (sp->starcount > sp->ztotal)
|
||||
sp->starcount = sp->ztotal;
|
||||
|
||||
sp->halt_scooter = False;
|
||||
|
||||
initdoorcolors(sp);
|
||||
|
||||
free_scooter(sp);
|
||||
if ((sintable = (float *) malloc(sizeof(float) *
|
||||
SINUSTABLE_SIZE)) == NULL) {
|
||||
release_scooter(mi);
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < SINUSTABLE_SIZE; i++) {
|
||||
sintable[i] = SINF(M_PI*2/SINUSTABLE_SIZE*i);
|
||||
}
|
||||
|
||||
if ((sp->doors = (Door *) malloc(sizeof(Door) *
|
||||
sp->doorcount)) == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((sp->zelements = (ZElement *) malloc(sizeof(ZElement) *
|
||||
sp->ztotal)) == NULL) {
|
||||
free_scooter(sp);
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < sp->doorcount; i++) {
|
||||
sp->doors[i].zelement =
|
||||
(sp->zelements_per_door * (i + 1)) - 1;
|
||||
sp->doors[i].freecolor = 0;
|
||||
nextdoorcolor(mi, &sp->doors[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < sp->ztotal; i++) {
|
||||
sp->zelements[i].angle.x = 0;
|
||||
sp->zelements[i].angle.y = 0;
|
||||
sp->zelements[i].angle.z = 0;
|
||||
}
|
||||
|
||||
if ((sp->stars = (Star *) malloc(sizeof(Star) *
|
||||
sp->starcount)) == NULL) {
|
||||
free_scooter(sp);
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < sp->starcount; i++) {
|
||||
sp->stars[i].zelement = sp->ztotal * i / sp->starcount;
|
||||
sp->stars[i].draw = 0;
|
||||
}
|
||||
|
||||
sp->projnorm_z = 50 * 240;
|
||||
sp->spectator_zelement = sp->zelements_per_door;
|
||||
|
||||
sp->currentRotation.x = 0;
|
||||
sp->currentRotation.y = 0;
|
||||
sp->currentRotation.z = 0;
|
||||
|
||||
sp->rotationDelta.x = 0;
|
||||
sp->rotationDelta.y = 0;
|
||||
sp->rotationDelta.z = 0;
|
||||
|
||||
sp->rotationDuration = 1;
|
||||
sp->rotationStep = 0;
|
||||
}
|
||||
|
||||
static void cleardoors(ModeInfo *mi)
|
||||
{
|
||||
MI_CLEARWINDOW(mi);
|
||||
}
|
||||
|
||||
/* Should be taken care of already... but just in case */
|
||||
#if !defined( __GNUC__ ) && !defined(__cplusplus) && !defined(c_plusplus)
|
||||
#undef inline
|
||||
#define inline /* */
|
||||
#endif
|
||||
static inline float
|
||||
projection (scooterstruct *sp, int zval)
|
||||
{
|
||||
return (sp->projnorm_z / (PROJECTION_DEGREE * zval));
|
||||
/* this is another formula. it is not limited to z>0 but it pulls too strong towards the screen center */
|
||||
/* return (sp->projnorm_z * pow(1.22,-(zval/200*PROJ_CURVEDNESS)))*/
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
y
|
||||
|
||||
^
|
||||
| z
|
||||
| .
|
||||
| /
|
||||
| /
|
||||
| /
|
||||
|/
|
||||
-+------------> x
|
||||
/|
|
||||
|
||||
rotation angles:
|
||||
a = alpha (x-rotation), b = beta (y-rotation), c = gamma (z-rotation)
|
||||
|
||||
x-axis rotation:
|
||||
( z )' = ( cos(a) -sin(a) ) ( z )
|
||||
( y ) ( sin(a) cos(a) ) ( y )
|
||||
|
||||
y-axis rotation:
|
||||
( z )' = ( cos(b) -sin(b) ) ( z )
|
||||
( x ) ( sin(b) cos(b) ) ( x )
|
||||
|
||||
z-axis rotation:
|
||||
( x )' = ( cos(c) -sin(c) ) ( x )
|
||||
( y ) ( sin(c) cos(c) ) ( y )
|
||||
*/
|
||||
|
||||
static void
|
||||
rotate_3d(Vec3D *src, Vec3D *dest, Angle3D *angle)
|
||||
{
|
||||
Vec3D tmp;
|
||||
float cosa = COS(angle->x),
|
||||
cosb = COS(angle->y),
|
||||
cosc = COS(angle->z),
|
||||
sina = SIN(angle->x),
|
||||
sinb = SIN(angle->y),
|
||||
sinc = SIN(angle->z);
|
||||
|
||||
/* rotate around X, Y and Z axis (see formulae above) */
|
||||
|
||||
/* X axis */
|
||||
tmp.z = src->z;
|
||||
tmp.y = src->y;
|
||||
dest->z = (int) (tmp.z * cosa - tmp.y * sina);
|
||||
dest->y = (int) (tmp.z * sina + tmp.y * cosa);
|
||||
|
||||
/* Y axis */
|
||||
tmp.z = dest->z;
|
||||
tmp.x = src->x;
|
||||
dest->z = (int) (tmp.z * cosb - tmp.x * sinb);
|
||||
dest->x = (int) (tmp.z * sinb + tmp.x * cosb);
|
||||
|
||||
/* Z axis */
|
||||
tmp.x = dest->x;
|
||||
tmp.y = dest->y;
|
||||
dest->x = (int) (tmp.x * cosc - tmp.y * sinc);
|
||||
dest->y = (int) (tmp.x * sinc + tmp.y * cosc);
|
||||
}
|
||||
|
||||
static void calc_new_element(ModeInfo *mi)
|
||||
{
|
||||
scooterstruct *sp = &scooters[MI_SCREEN(mi)];
|
||||
float rot = SIN((SINUSTABLE_SIZE/2)*
|
||||
sp->rotationStep/sp->rotationDuration);
|
||||
|
||||
/* change current rotation 3D angle */
|
||||
|
||||
if (sp->rotationStep++ >= sp->rotationDuration) {
|
||||
|
||||
int fps = 1000000/MI_DELAY(mi); /* frames per second as timebase */
|
||||
|
||||
/* one rotation interval takes 10-30 seconds at speed 1.
|
||||
*/
|
||||
sp->rotationDuration = 10*fps + NRAND(20*fps);
|
||||
|
||||
/* -DOOR_CURVEDNESS <= delta <= +DOOR_CURVEDNESS */
|
||||
sp->rotationDelta.x =
|
||||
NRAND(DOOR_CURVEDNESS*2+1) - DOOR_CURVEDNESS;
|
||||
sp->rotationDelta.y =
|
||||
NRAND(DOOR_CURVEDNESS*2+1) - DOOR_CURVEDNESS;
|
||||
sp->rotationDelta.z =
|
||||
NRAND(DOOR_CURVEDNESS*2+1) - DOOR_CURVEDNESS;
|
||||
|
||||
sp->rotationStep = 0;
|
||||
}
|
||||
|
||||
sp->currentRotation.x += (int) (rot * sp->rotationDelta.x);
|
||||
sp->currentRotation.y += (int) (rot * sp->rotationDelta.y);
|
||||
sp->currentRotation.z += (int) (rot * sp->rotationDelta.z);
|
||||
|
||||
sp->currentRotation.x &= SINUSTABLE_MASK;
|
||||
sp->currentRotation.y &= SINUSTABLE_MASK;
|
||||
sp->currentRotation.z &= SINUSTABLE_MASK;
|
||||
}
|
||||
|
||||
static void shift_elements(ModeInfo *mi)
|
||||
{
|
||||
scooterstruct *sp = &scooters[MI_SCREEN(mi)];
|
||||
int i, iprev;
|
||||
Vec3D tmpvec;
|
||||
Angle3D tmpangle;
|
||||
|
||||
/* shift angles from zelements */
|
||||
|
||||
for (i = sp->speed; i < sp->ztotal; i++) {
|
||||
sp->zelements[i - sp->speed].angle = sp->zelements[i].angle;
|
||||
}
|
||||
for (i = sp->ztotal - sp->speed; i < sp->ztotal; i++) {
|
||||
calc_new_element(mi);
|
||||
sp->zelements[i].angle = sp->currentRotation;
|
||||
}
|
||||
|
||||
/* calculate new 3D-coords from ALL zelements */
|
||||
|
||||
sp->zelements[sp->spectator_zelement].pos.x = 0;
|
||||
sp->zelements[sp->spectator_zelement].pos.y = 0;
|
||||
sp->zelements[sp->spectator_zelement].pos.z =
|
||||
sp->zelement_distance * sp->spectator_zelement;
|
||||
|
||||
for (i = sp->spectator_zelement - 1; i >= 0; --i) {
|
||||
iprev = i + 1;
|
||||
|
||||
tmpvec.x = 0;
|
||||
tmpvec.y = 0;
|
||||
tmpvec.z = - sp->zelement_distance;
|
||||
tmpangle.x = sp->zelements[i].angle.x -
|
||||
sp->zelements[sp->spectator_zelement].angle.x;
|
||||
tmpangle.y = sp->zelements[i].angle.y -
|
||||
sp->zelements[sp->spectator_zelement].angle.y;
|
||||
tmpangle.z = sp->zelements[i].angle.z -
|
||||
sp->zelements[sp->spectator_zelement].angle.z;
|
||||
rotate_3d(&tmpvec, &(sp->zelements[i].pos), &tmpangle);
|
||||
sp->zelements[i].pos.x += sp->zelements[iprev].pos.x;
|
||||
sp->zelements[i].pos.y += sp->zelements[iprev].pos.y;
|
||||
sp->zelements[i].pos.z += sp->zelements[iprev].pos.z;
|
||||
}
|
||||
|
||||
for (i = sp->spectator_zelement + 1; i < sp->ztotal; i++) {
|
||||
iprev = i - 1;
|
||||
|
||||
tmpvec.x = 0;
|
||||
tmpvec.y = 0;
|
||||
tmpvec.z = sp->zelement_distance;
|
||||
tmpangle.x = sp->zelements[i].angle.x -
|
||||
sp->zelements[sp->spectator_zelement].angle.x;
|
||||
tmpangle.y = sp->zelements[i].angle.y -
|
||||
sp->zelements[sp->spectator_zelement].angle.y;
|
||||
tmpangle.z = sp->zelements[i].angle.z -
|
||||
sp->zelements[sp->spectator_zelement].angle.z;
|
||||
rotate_3d(&tmpvec, &(sp->zelements[i].pos), &tmpangle);
|
||||
sp->zelements[i].pos.x += sp->zelements[iprev].pos.x;
|
||||
sp->zelements[i].pos.y += sp->zelements[iprev].pos.y;
|
||||
sp->zelements[i].pos.z += sp->zelements[iprev].pos.z;
|
||||
}
|
||||
|
||||
|
||||
/* shift doors and wrap around */
|
||||
|
||||
for (i = 0; i < sp->doorcount; i++) {
|
||||
if ((sp->doors[i].zelement -= sp->speed) < 0) {
|
||||
sp->doors[i].zelement += sp->ztotal;
|
||||
nextdoorcolor(mi,&sp->doors[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/* shift stars */
|
||||
|
||||
for (i = 0; i < sp->starcount; i++) {
|
||||
if ((sp->stars[i].zelement -= sp->speed) < 0) {
|
||||
int rnd;
|
||||
|
||||
sp->stars[i].zelement += sp->ztotal;
|
||||
sp->stars[i].draw = 1;
|
||||
|
||||
/* make sure new stars are outside doors */
|
||||
|
||||
rnd = NRAND(2*(STAR_MAX_X - STAR_MIN_X)) -
|
||||
(STAR_MAX_X - STAR_MIN_X);
|
||||
sp->stars[i].xpos = rnd + (STAR_MIN_X * SGN(rnd));
|
||||
|
||||
rnd = NRAND(2*(STAR_MAX_Y - STAR_MIN_Y)) -
|
||||
(STAR_MAX_Y - STAR_MIN_Y);
|
||||
sp->stars[i].ypos = rnd + (STAR_MIN_Y * SGN(rnd));
|
||||
|
||||
rnd = NRAND(STAR_SIZE_MAX - STAR_SIZE_MIN) +
|
||||
STAR_SIZE_MIN;
|
||||
sp->stars[i].width = rnd;
|
||||
sp->stars[i].height = rnd * 3 / 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void door_3d(scooterstruct *sp, Door *door)
|
||||
{
|
||||
ZElement *ze = &sp->zelements[door->zelement];
|
||||
Vec3D src;
|
||||
Angle3D tmpangle;
|
||||
|
||||
tmpangle.x = ze->angle.x -
|
||||
sp->zelements[sp->spectator_zelement].angle.x;
|
||||
tmpangle.y = ze->angle.y -
|
||||
sp->zelements[sp->spectator_zelement].angle.y;
|
||||
tmpangle.z = ze->angle.z -
|
||||
sp->zelements[sp->spectator_zelement].angle.z;
|
||||
|
||||
/* calculate 3d coords of all 4 edges */
|
||||
|
||||
src.x = -DOOR_WIDTH/2;
|
||||
src.y = DOOR_HEIGHT/2;
|
||||
src.z = 0;
|
||||
rotate_3d(&src, &(door->coords[0]), &tmpangle);
|
||||
door->coords[0].x += ze->pos.x;
|
||||
door->coords[0].y += ze->pos.y;
|
||||
door->coords[0].z += ze->pos.z;
|
||||
|
||||
src.x = DOOR_WIDTH/2;
|
||||
rotate_3d(&src, &(door->coords[1]), &tmpangle);
|
||||
door->coords[1].x += ze->pos.x;
|
||||
door->coords[1].y += ze->pos.y;
|
||||
door->coords[1].z += ze->pos.z;
|
||||
|
||||
src.y = -DOOR_HEIGHT/2;
|
||||
rotate_3d(&src, &(door->coords[2]), &tmpangle);
|
||||
door->coords[2].x += ze->pos.x;
|
||||
door->coords[2].y += ze->pos.y;
|
||||
door->coords[2].z += ze->pos.z;
|
||||
|
||||
src.x = -DOOR_WIDTH/2;
|
||||
rotate_3d(&src, &(door->coords[3]), &tmpangle);
|
||||
door->coords[3].x += ze->pos.x;
|
||||
door->coords[3].y += ze->pos.y;
|
||||
door->coords[3].z += ze->pos.z;
|
||||
}
|
||||
|
||||
/*
|
||||
* clip the line p1-p2 at the given rectangle
|
||||
*
|
||||
*/
|
||||
static int clipline(XPoint *p1, XPoint *p2, Rect *rect)
|
||||
{
|
||||
XPoint new1, new2, tmp;
|
||||
float m;
|
||||
|
||||
new1 = *p1;
|
||||
new2 = *p2;
|
||||
|
||||
/* entire line may not need clipping */
|
||||
|
||||
if (((new1.x >= rect->lefttop.x) && (new1.x <= rect->rightbottom.x))
|
||||
|| ((new1.y >= rect->lefttop.y) && (new1.y <= rect->rightbottom.y))
|
||||
|| ((new2.x >= rect->lefttop.x) && (new2.x <= rect->rightbottom.x))
|
||||
|| ((new2.y >= rect->lefttop.y) && (new2.y <= rect->rightbottom.y)))
|
||||
return 1;
|
||||
|
||||
|
||||
/* first: clip y dimension */
|
||||
|
||||
/* p1 is above p2 */
|
||||
if (new1.y > new2.y) {
|
||||
tmp = new1;
|
||||
new1 = new2;
|
||||
new2 = tmp;
|
||||
}
|
||||
|
||||
/* line could be totally out of view */
|
||||
if ((new2.y < rect->lefttop.y) || (new1.y > rect->rightbottom.y))
|
||||
return 0;
|
||||
|
||||
m = (new2.x == new1.x) ? 0 :
|
||||
((float)(new2.y - new1.y) / (new2.x - new1.x));
|
||||
|
||||
if (new1.y < rect->lefttop.y) {
|
||||
if (m)
|
||||
new1.x += (int) ((rect->lefttop.y - new1.y)/m);
|
||||
new1.y = rect->lefttop.y;
|
||||
}
|
||||
if (new2.y > rect->rightbottom.y) {
|
||||
if (m)
|
||||
new2.x -= (int) ((new2.y - rect->rightbottom.y)/m);
|
||||
new2.y = rect->rightbottom.y;
|
||||
}
|
||||
|
||||
|
||||
/* clip x dimension */
|
||||
|
||||
/* p1 is left to p2 */
|
||||
if (new1.x > new2.x) {
|
||||
tmp = new1;
|
||||
new1 = new2;
|
||||
new2 = tmp;
|
||||
}
|
||||
|
||||
if ((new2.x < rect->lefttop.x) || (new1.x > rect->rightbottom.x))
|
||||
return 0;
|
||||
|
||||
m = (new2.x == new1.x) ? 0 :
|
||||
((float)(new2.y - new1.y) / (new2.x - new1.x));
|
||||
|
||||
if (new1.x < rect->lefttop.x) {
|
||||
new1.y += (int) ((rect->lefttop.y - new1.y)*m);
|
||||
new1.x = rect->lefttop.x;
|
||||
}
|
||||
if (new2.y > rect->rightbottom.y) {
|
||||
new2.y -= (int) ((new2.y - rect->rightbottom.y)*m);
|
||||
new2.x = rect->rightbottom.x;
|
||||
}
|
||||
|
||||
|
||||
/* push values */
|
||||
|
||||
*p1 = new1;
|
||||
*p2 = new2;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void drawdoors(ModeInfo *mi)
|
||||
{
|
||||
scooterstruct *sp = &scooters[MI_SCREEN(mi)];
|
||||
Display *display = MI_DISPLAY(mi);
|
||||
Window window = MI_WINDOW(mi);
|
||||
GC gc = MI_GC(mi);
|
||||
int width = MI_WIDTH(mi), height = MI_HEIGHT(mi),
|
||||
midx = width/2, midy = height/2;
|
||||
int i, j;
|
||||
Rect rect = { {0,0}, {0,0} };
|
||||
|
||||
rect.rightbottom.x = width - 1;
|
||||
rect.rightbottom.y = height - 1;
|
||||
XSetLineAttributes(display, gc, 2, LineSolid, CapNotLast, JoinRound);
|
||||
|
||||
#ifdef _DRAW_ZELEMENTS
|
||||
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
|
||||
for (i= sp->spectator_zelement; i<ztotal; i++) {
|
||||
register float proj;
|
||||
XPoint p;
|
||||
|
||||
proj = projection(sp, zelements[i].pos.z) * sp->aspect_scale;
|
||||
p.x = midx + (sp->zelements[i].pos.x * proj / SPACE_XY_FACTOR);
|
||||
p.y = midy - (sp->zelements[i].pos.y * proj / SPACE_XY_FACTOR);
|
||||
XDrawPoint(display, window, gc, p.x, p.y);
|
||||
}
|
||||
#endif
|
||||
|
||||
for (i = 0; i < sp->doorcount; i++) {
|
||||
|
||||
register float proj;
|
||||
XPoint lines[4], clip1, clip2;
|
||||
|
||||
door_3d(sp, &sp->doors[i]);
|
||||
|
||||
for (j=0; j<4; j++) {
|
||||
if (sp->doors[i].coords[j].z <= 0) break;
|
||||
|
||||
proj = projection(sp, sp->doors[i].coords[j].z) * sp->aspect_scale;
|
||||
lines[j].x = midx + (int) (sp->doors[i].coords[j].x *
|
||||
proj / SPACE_XY_FACTOR);
|
||||
lines[j].y = midy - (int) (sp->doors[i].coords[j].y *
|
||||
proj / SPACE_XY_FACTOR);
|
||||
}
|
||||
if (j<4) continue;
|
||||
|
||||
XSetForeground(display, gc, sp->doors[i].color);
|
||||
|
||||
for (j=0; j<4; j++) {
|
||||
clip1 = lines[j];
|
||||
clip2 = lines[(j+1)%4];
|
||||
if (clipline(&clip1, &clip2, &rect))
|
||||
XDrawLine(display, window, gc, clip1.x, clip1.y, clip2.x, clip2.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void drawstars(ModeInfo *mi)
|
||||
{
|
||||
scooterstruct *sp = &scooters[MI_SCREEN(mi)];
|
||||
Display *display = MI_DISPLAY(mi);
|
||||
Window window = MI_WINDOW(mi);
|
||||
GC gc = MI_GC(mi);
|
||||
int width = MI_WIDTH(mi), height = MI_HEIGHT(mi),
|
||||
midx = width/2, midy = height/2;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < sp->starcount; i++) {
|
||||
|
||||
float proj;
|
||||
ZElement *ze = &sp->zelements[sp->stars[i].zelement];
|
||||
Vec3D tmpvec, coords;
|
||||
Angle3D tmpangle;
|
||||
XPoint lefttop, rightbottom;
|
||||
|
||||
if (!sp->stars[i].draw) continue;
|
||||
|
||||
|
||||
/* rotate star around its z-element, then add its position */
|
||||
|
||||
tmpangle.x = ze->angle.x -
|
||||
sp->zelements[sp->spectator_zelement].angle.x;
|
||||
tmpangle.y = ze->angle.y -
|
||||
sp->zelements[sp->spectator_zelement].angle.y;
|
||||
tmpangle.z = ze->angle.z -
|
||||
sp->zelements[sp->spectator_zelement].angle.z;
|
||||
|
||||
tmpvec.x = sp->stars[i].xpos;
|
||||
tmpvec.y = sp->stars[i].ypos;
|
||||
tmpvec.z = 0;
|
||||
rotate_3d(&tmpvec, &coords, &tmpangle);
|
||||
coords.x += ze->pos.x;
|
||||
coords.y += ze->pos.y;
|
||||
coords.z += ze->pos.z;
|
||||
|
||||
if (coords.z <= 0) continue;
|
||||
|
||||
|
||||
/* projection and clipping (trivial for a rectangle) */
|
||||
|
||||
proj = projection(sp, coords.z) * sp->aspect_scale;
|
||||
|
||||
lefttop.x = midx + (int) ((coords.x - sp->stars[i].width/2) *
|
||||
proj / SPACE_XY_FACTOR);
|
||||
lefttop.y = midy - (int) ((coords.y + sp->stars[i].height/2) *
|
||||
proj / SPACE_XY_FACTOR);
|
||||
if (lefttop.x < 0)
|
||||
lefttop.x = 0;
|
||||
else if (lefttop.x >= width)
|
||||
continue;
|
||||
if (lefttop.y < 0)
|
||||
lefttop.y = 0;
|
||||
else if (lefttop.y >= height)
|
||||
continue;
|
||||
|
||||
rightbottom.x = midx + (int) ((coords.x + sp->stars[i].width/2) *
|
||||
proj / SPACE_XY_FACTOR);
|
||||
rightbottom.y = midy - (int) ((coords.y - sp->stars[i].height/2) *
|
||||
proj / SPACE_XY_FACTOR);
|
||||
if (rightbottom.x < 0)
|
||||
continue;
|
||||
else if (rightbottom.x >= width)
|
||||
rightbottom.x = width - 1;
|
||||
if (rightbottom.y < 0)
|
||||
continue;
|
||||
else if (rightbottom.y >= height)
|
||||
rightbottom.y = height - 1;
|
||||
|
||||
|
||||
/* in white color, small stars look darker than big stars */
|
||||
|
||||
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
|
||||
|
||||
if ((lefttop.x == rightbottom.x) &&
|
||||
(lefttop.y == rightbottom.y)) {
|
||||
/* star is exactly 1 pixel */
|
||||
XDrawPoint(display, window, gc, lefttop.x, lefttop.y);
|
||||
} else if ((rightbottom.x - lefttop.x) +
|
||||
(rightbottom.y - lefttop.y) == 1) {
|
||||
/* star is 2 pixels wide or high */
|
||||
XDrawPoint(display, window, gc,
|
||||
lefttop.x, lefttop.y);
|
||||
XDrawPoint(display, window, gc,
|
||||
rightbottom.x, rightbottom.y);
|
||||
} else if ((rightbottom.x - lefttop.x == 1) &&
|
||||
(rightbottom.y - lefttop.y == 1)) {
|
||||
|
||||
/* star is exactly 2x2 pixels.
|
||||
* a 2x2 rectangle should be drawn faster by plotting all 4 pixels
|
||||
* than by filling a rectangle (is this really so under X ?)
|
||||
*/
|
||||
|
||||
XDrawPoint(display, window, gc,
|
||||
lefttop.x, lefttop.y);
|
||||
XDrawPoint(display, window, gc,
|
||||
rightbottom.x, lefttop.y);
|
||||
XDrawPoint(display, window, gc,
|
||||
lefttop.x, rightbottom.y);
|
||||
XDrawPoint(display, window, gc,
|
||||
rightbottom.x, rightbottom.y);
|
||||
} else {
|
||||
XFillRectangle(display, window, gc,
|
||||
lefttop.x, lefttop.y,
|
||||
rightbottom.x - lefttop.x,
|
||||
rightbottom.y - lefttop.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void draw_scooter(ModeInfo *mi)
|
||||
{
|
||||
scooterstruct *sp;
|
||||
|
||||
if (scooters == NULL)
|
||||
return;
|
||||
sp = &scooters[MI_SCREEN(mi)];
|
||||
if (sp->doors == NULL)
|
||||
return;
|
||||
|
||||
cleardoors(mi);
|
||||
|
||||
shift_elements(mi);
|
||||
|
||||
/* With these scale factors, all doors are sized correctly for any window dimension.
|
||||
* If aspect ratio is not 4:3, the smaller part of the window is used, e.g.:
|
||||
* window = 1000x600
|
||||
* => door scale factor is like in a 800x600 window (not 1000x750)
|
||||
*/
|
||||
|
||||
if ((float)MI_WIDTH(mi)/MI_HEIGHT(mi) >=
|
||||
(float)ASPECT_SCREENWIDTH/ASPECT_SCREENHEIGHT) {
|
||||
/* window is wider than or equal 4:3 */
|
||||
sp->aspect_scale = (float)MI_HEIGHT(mi) / ASPECT_SCREENHEIGHT;
|
||||
} else {
|
||||
/* window is higher than 4:3 */
|
||||
sp->aspect_scale = (float)MI_WIDTH(mi) / ASPECT_SCREENWIDTH;
|
||||
}
|
||||
|
||||
drawstars(mi);
|
||||
|
||||
drawdoors(mi);
|
||||
}
|
||||
|
||||
void refresh_scooter(ModeInfo *mi)
|
||||
{
|
||||
MI_CLEARWINDOW(mi);
|
||||
}
|
||||
|
||||
void change_scooter(ModeInfo *mi)
|
||||
{
|
||||
scooterstruct *sp;
|
||||
|
||||
if (scooters == NULL)
|
||||
return;
|
||||
sp = &scooters[MI_SCREEN(mi)];
|
||||
|
||||
sp->halt_scooter = !sp->halt_scooter;
|
||||
}
|
||||
|
||||
#endif /* MODE_scooter */
|
||||
Loading…
Add table
Add a link
Reference in a new issue