* implied warranty.
*/
-
-#include <X11/Intrinsic.h>
-
#ifdef STANDALONE
-# define PROGCLASS "Engine"
-# define HACK_INIT init_engine
-# define HACK_DRAW draw_engine
-# define HACK_HANDLE_EVENT engine_handle_event
-# define HACK_RESHAPE reshape_engine
-# define EVENT_MASK PointerMotionMask
-# define engine_opts xlockmore_opts
-/* insert defaults here */
-
-#define DEF_ENGINE "(none)"
-#define DEF_TITLES "False"
-#define DEF_SPIN "True"
-#define DEF_WANDER "True"
-
-#define DEFAULTS "*delay: 10000 \n" \
+#define DEFAULTS "*delay: 30000 \n" \
"*showFPS: False \n" \
- "*move: True \n" \
- "*spin: True \n" \
- "*engine: " DEF_ENGINE "\n" \
- "*titles: " DEF_TITLES "\n" \
- "*titleFont: -*-times-bold-r-normal-*-180-*\n" \
+ "*suppressRotationAnimation: True\n" \
+ "*titleFont: -*-helvetica-medium-r-normal-*-*-180-*-*-*-*-*-*\n" \
+# define refresh_engine 0
# include "xlockmore.h" /* from the xscreensaver distribution */
#else /* !STANDALONE */
# include "xlock.h" /* from the xlockmore distribution */
#endif /* !STANDALONE */
+#include "texfont.h"
#include "rotator.h"
#include "gltrackball.h"
#ifdef USE_GL
-#include <GL/glu.h>
-
-
-
+#define DEF_ENGINE "(none)"
+#define DEF_TITLES "False"
+#define DEF_SPIN "True"
+#define DEF_MOVE "True"
#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))
-static int engineType;
static char *which_engine;
static int move;
-static int movepaused = 0;
static int spin;
static Bool do_titles;
static XrmOptionDescRec opts[] = {
{"-engine", ".engine.engine", XrmoptionSepArg, DEF_ENGINE },
- {"-move", ".engine.move", XrmoptionNoArg, (caddr_t) "True" },
- {"+move", ".engine.move", XrmoptionNoArg, (caddr_t) "False" },
- {"-spin", ".engine.spin", XrmoptionNoArg, (caddr_t) "True" },
- {"+spin", ".engine.spin", XrmoptionNoArg, (caddr_t) "False" },
- { "-titles", ".engine.titles", XrmoptionNoArg, (caddr_t) "True" },
- { "+titles", ".engine.titles", XrmoptionNoArg, (caddr_t) "False" },
+ {"-move", ".engine.move", XrmoptionNoArg, "True" },
+ {"+move", ".engine.move", XrmoptionNoArg, "False" },
+ {"-spin", ".engine.spin", XrmoptionNoArg, "True" },
+ {"+spin", ".engine.spin", XrmoptionNoArg, "False" },
+ { "-titles", ".engine.titles", XrmoptionNoArg, "True" },
+ { "+titles", ".engine.titles", XrmoptionNoArg, "False" },
};
static argtype vars[] = {
- {(caddr_t *) &which_engine, "engine", "Engine", DEF_ENGINE, t_String},
- {(caddr_t *) &move, "move", "Move", DEF_WANDER, t_Bool},
- {(caddr_t *) &spin, "spin", "Spin", DEF_SPIN, t_Bool},
- {(caddr_t *) &do_titles, "titles", "Titles", DEF_TITLES, t_Bool},
+ {&which_engine, "engine", "Engine", DEF_ENGINE, t_String},
+ {&move, "move", "Move", DEF_MOVE, t_Bool},
+ {&spin, "spin", "Spin", DEF_SPIN, t_Bool},
+ {&do_titles, "titles", "Titles", DEF_TITLES, t_Bool},
};
-ModeSpecOpt engine_opts = {countof(opts), opts, countof(vars), vars, NULL};
+ENTRYPOINT ModeSpecOpt engine_opts = {countof(opts), opts, countof(vars), vars, NULL};
#ifdef USE_MODULES
ModStruct engine_description =
#endif
+/* these defines are used to provide symbolic means
+ * by which to refer to various portions or multiples
+ * of a cyle in degrees
+ */
+#define HALFREV 180
+#define ONEREV 360
+#define TWOREV 720
+
+#define MOVE_MULT 0.05
+
+#define RAND_RANGE(min, max) ((min) + (max - min) * f_rand())
+
+
typedef struct {
GLXContext *glx_context;
Window window;
rotator *rot;
trackball_state *trackball;
Bool button_down_p;
- XFontStruct *xfont;
- GLuint font_dlist;
+ texture_font_data *font_data;
char *engine_name;
-} Engine;
+ int engineType;
+ int movepaused;
-static Engine *engine = NULL;
+ float crankOffset;
+ float crankWidth;
-#include <math.h>
-#include <sys/time.h>
-#include <stdio.h>
-#include <stdlib.h>
+ int win_w, win_h;
-#ifndef M_PI
-#define M_PI 3.14159265
-#endif
+ float sin_table[TWOREV];
+ float cos_table[TWOREV];
+ float tan_table[TWOREV];
-/* these defines are used to provide symbolic means
- * by which to refer to various portions or multiples
- * of a cyle in degrees
- */
-#define HALFREV 180
-#define ONEREV 360
-#define TWOREV 720
+ GLfloat boom_red[4];
+ GLfloat boom_lpos[4];
+ GLfloat boom_d, boom_wd;
+ int boom_time;
-#define MOVE_MULT 0.05
+ GLfloat viewer[3], lookat[3];
-#define RAND_RANGE(min, max) ((min) + (max - min) * f_rand())
+ int display_a;
+ GLfloat ln[730], yp[730], ang[730];
+ int ln_init;
+ int lastPlug;
+
+ GLuint shaft_list, piston_list;
+ int shaft_polys, piston_polys;
-float crankOffset;
-float crankWidth = 1.5;
+} Engine;
-int win_w, win_h;
+static Engine *engine = NULL;
-static GLfloat viewer[] = {0.0, 0.0, 30.0};
-static GLfloat lookat[] = {0.0, 0.0, 0.0};
-static GLfloat lightpos[] = {7.0, 7.0, 12, 1.0};
-GLfloat light_sp[] = {0.8, 0.8, 0.8, 0.5};
-static GLfloat red[] = {1.0, 0, 0, 1.0};
-static GLfloat green[] = {0.0, 1, 0, 1.0};
-static GLfloat blue[] = {0, 0, 1, 1.0};
-static GLfloat white[] = {1.0, 1, 1, 1.0};
-static GLfloat yellow_t[] = {1, 1, 0, 0.4};
+static const GLfloat lightpos[] = {7.0, 7.0, 12, 1.0};
+static const GLfloat light_sp[] = {0.8, 0.8, 0.8, 0.5};
+static const GLfloat red[] = {1.0, 0, 0, 1.0};
+static const GLfloat green[] = {0.0, 1, 0, 1.0};
+static const GLfloat blue[] = {0, 0, 1, 1.0};
+static const GLfloat white[] = {1.0, 1, 1, 1.0};
+static const GLfloat yellow_t[] = {1, 1, 0, 0.4};
-GLvoid normal(GLfloat [], GLfloat [], GLfloat [],
+static GLvoid normal(GLfloat [], GLfloat [], GLfloat [],
GLfloat *, GLfloat *, GLfloat *);
-float sin_table[TWOREV];
-float cos_table[TWOREV];
-float tan_table[TWOREV];
-
/*
* this table represents both the firing order and included angle of engine.
* To simplify things, we always number from 0 starting at the flywheel and
const char *engineName; /* currently unused */
} engine_type;
-engine_type engines[] = {
+static const engine_type engines[] = {
{ 3, 0, { 0, 240, 480, 0, 0, 0,
0, 0, 0, 0, 0, 0 }, 12,
"Honda Insight" },
/* this define is just a little shorter way of referring to members of the
* table above
*/
-#define ENG engines[engineType]
+#define ENG engines[e->engineType]
/* given a number of cylinders and an included angle, finds matching engine */
-int find_engine(const char *name)
+static int
+find_engine(char *name)
{
- int i;
+ unsigned int i;
+ char *s;
if (!name || !*name || !strcasecmp (name, "(none)"))
return (random() % countof(engines));
+ for (s = name; *s; s++)
+ if (*s == '-' || *s == '_') *s = ' ';
+
for (i = 0; i < countof(engines); i++) {
if (!strcasecmp(name, engines[i].engineName))
return i;
in one frame can be a bit harsh..
*/
-void make_tables(void)
+static void make_tables(Engine *e)
{
int i;
float f;
f = ONEREV / (M_PI * 2);
- for (i = 0 ; i <= TWOREV ; i++) {
- sin_table[i] = sin(i/f);
+ for (i = 0 ; i < TWOREV ; i++) {
+ e->sin_table[i] = sin(i/f);
}
- for (i = 0 ; i <= TWOREV ; i++) {
- cos_table[i] = cos(i/f);
+ for (i = 0 ; i < TWOREV ; i++) {
+ e->cos_table[i] = cos(i/f);
}
- for (i = 0 ; i <= TWOREV ; i++) {
- tan_table[i] = tan(i/f);
+ for (i = 0 ; i < TWOREV ; i++) {
+ e->tan_table[i] = tan(i/f);
}
}
/* for a tube, endcaps is 0 (none), 1 (left), 2 (right) or 3(both) */
/* angle is how far around the axis to go (up to 360) */
-void cylinder (GLfloat x, GLfloat y, GLfloat z,
+static int cylinder (Engine *e, GLfloat x, GLfloat y, GLfloat z,
float length, float outer, float inner, int endcaps, int sang, int eang)
{
+ int polys = 0;
int a; /* current angle around cylinder */
int b = 0; /* previous */
int angle, norm, step, sangle;
float z1, y1, z2, y2, ex=0;
- float y3, z3;
- float Z1, Y1, Z2, Y2, xl, Y3, Z3;
+ float Z1, Y1, Z2, Y2, xl;
GLfloat y2c[TWOREV], z2c[TWOREV];
- GLfloat ony, onz; /* previous normals */
int nsegs, tube = 0;
glPushMatrix();
- nsegs = outer*(MAX(win_w, win_h)/200);
+ nsegs = outer*(MAX(e->win_w, e->win_h)/200);
nsegs = MAX(nsegs, 6);
nsegs = MAX(nsegs, 40);
if (nsegs % 2)
nsegs += 1;
sangle = sang;
angle = eang;
- ony = onz = 0;
- z1 = cos_table[sangle]*outer+z; y1 = sin_table[sangle] * outer+y;
- Z1 = cos_table[sangle] * inner+z; Y1 = sin_table[sangle]*inner+y ;
+ z1 = e->cos_table[sangle]*outer+z; y1 = e->sin_table[sangle] * outer+y;
+ Z1 = e->cos_table[sangle] * inner+z; Y1 = e->sin_table[sangle]*inner+y ;
Z2 = z;
Y2 = y;
xl = x + length;
glBegin(GL_QUADS);
for (a = sangle ; a <= angle || b <= angle ; a+= step) {
- y2=outer*(float)sin_table[a]+y;
- z2=outer*(float)cos_table[a]+z;
- y3=outer*(float)sin_table[a+step]+y;
- z3=outer*(float)cos_table[a+step]+z;
- if (endcaps)
- y2c[a] = y2; z2c[a] = z2; /* cache for later */
+ y2=outer*(float)e->sin_table[a]+y;
+ z2=outer*(float)e->cos_table[a]+z;
+ if (endcaps) {
+ y2c[a] = y2;
+ z2c[a] = z2; /* cache for later */
+ }
if (tube) {
- Y2=inner*(float)sin_table[a]+y;
- Z2=inner*(float)cos_table[a]+z;
- Y3=inner*(float)sin_table[a+step]+y;
- Z3=inner*(float)cos_table[a+step]+z;
+ Y2=inner*(float)e->sin_table[a]+y;
+ Z2=inner*(float)e->cos_table[a]+z;
}
glNormal3f(0, y1, z1);
glVertex3f(x,y1,z1);
glNormal3f(0, y2, z2);
glVertex3f(xl,y2,z2);
glVertex3f(x,y2,z2);
+ polys++;
if (a == sangle && angle - sangle < ONEREV) {
if (tube)
glVertex3f(x, Y1, Z1);
glVertex3f(xl, Z1, Z1);
else
glVertex3f(xl, y, z);
+ polys++;
}
if (tube) {
if (endcaps != 1) {
glVertex3f(x, y2, z2);
glVertex3f(x, Y2, Z2);
glVertex3f(x, Y1, Z1);
+ polys++;
}
glNormal3f(0, -Y1, -Z1); /* inner surface */
glNormal3f(0, -Y2, -Z2);
glVertex3f(xl, Y2, Z2);
glVertex3f(x, Y2, Z2);
+ polys++;
if (endcaps != 2) {
glNormal3f(1, 0, 0); /* right end */
glVertex3f(xl, y2, z2);
glVertex3f(xl, Y2, Z2);
glVertex3f(xl, Y1, Z1);
+ polys++;
}
}
glVertex3f(x, y1, z1);
glVertex3f(xl, y1, z1);
glVertex3f(xl, y, z);
+ polys++;
glEnd();
}
if (endcaps) {
}
for(ex = start ; ex <= end ; ex += length) {
- z1 = outer*cos_table[sangle]+z;
- y1 = y+sin_table[sangle]*outer;
+ z1 = outer*e->cos_table[sangle]+z;
+ y1 = y+e->sin_table[sangle]*outer;
step = ONEREV/nsegs;
glBegin(GL_TRIANGLES);
b = 0;
glVertex3f(x+ex,y, z);
glVertex3f(x+ex,y1,z1);
glVertex3f(x+ex,y2c[a],z2c[a]);
+ polys++;
y1 = y2c[a]; z1 = z2c[a];
b = a;
}
}
}
glPopMatrix();
+ return polys;
}
/* this is just a convenience function to make a solid rod */
-void rod (GLfloat x, GLfloat y, GLfloat z, float length, float diameter)
+static int rod (Engine *e, GLfloat x, GLfloat y, GLfloat z, float length, float diameter)
{
- cylinder(x, y, z, length, diameter, diameter, 3, 0, ONEREV);
+ return cylinder(e, x, y, z, length, diameter, diameter, 3, 0, ONEREV);
}
-GLvoid normal(GLfloat v1[], GLfloat v2[], GLfloat v3[],
+static GLvoid normal(GLfloat v1[], GLfloat v2[], GLfloat v3[],
GLfloat *nx, GLfloat *ny, GLfloat *nz)
{
GLfloat x, y, z, X, Y, Z;
-void Rect(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h,
+static int Rect(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h,
GLfloat t)
{
+ int polys = 0;
GLfloat yh;
GLfloat xw;
GLfloat zt;
glVertex3f(x, yh, z);
glVertex3f(xw, yh, z);
glVertex3f(xw, y, z);
+ polys++;
/* back */
glNormal3f(0, 0, -1);
glVertex3f(x, y, zt);
glVertex3f(x, yh, zt);
glVertex3f(xw, yh, zt);
glVertex3f(xw, y, zt);
+ polys++;
/* top */
glNormal3f(0, 1, 0);
glVertex3f(x, yh, z);
glVertex3f(x, yh, zt);
glVertex3f(xw, yh, zt);
glVertex3f(xw, yh, z);
+ polys++;
/* bottom */
glNormal3f(0, -1, 0);
glVertex3f(x, y, z);
glVertex3f(x, y, zt);
glVertex3f(xw, y, zt);
glVertex3f(xw, y, z);
+ polys++;
/* left */
glNormal3f(-1, 0, 0);
glVertex3f(x, y, z);
glVertex3f(x, y, zt);
glVertex3f(x, yh, zt);
glVertex3f(x, yh, z);
+ polys++;
/* right */
glNormal3f(1, 0, 0);
glVertex3f(xw, y, z);
glVertex3f(xw, y, zt);
glVertex3f(xw, yh, zt);
glVertex3f(xw, yh, z);
+ polys++;
glEnd();
+ return polys;
}
-void makepiston(void)
+static int makepiston(Engine *e)
{
+ int polys = 0;
GLfloat colour[] = {0.6, 0.6, 0.6, 1.0};
- int i;
- i = glGenLists(1);
- glNewList(i, GL_COMPILE);
+ /* if (e->piston_list) glDeleteLists(1, e->piston_list); */
+ if (! e->piston_list) e->piston_list = glGenLists(1);
+ glNewList(e->piston_list, GL_COMPILE);
glRotatef(90, 0, 0, 1);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colour);
glMaterialfv(GL_FRONT, GL_SPECULAR, colour);
glMateriali(GL_FRONT, GL_SHININESS, 20);
- cylinder(0, 0, 0, 2, 1, 0.7, 2, 0, ONEREV); /* body */
+ polys += cylinder(e, 0, 0, 0, 2, 1, 0.7, 2, 0, ONEREV); /* body */
colour[0] = colour[1] = colour[2] = 0.2;
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colour);
- cylinder(1.6, 0, 0, 0.1, 1.05, 1.05, 0, 0, ONEREV); /* ring */
- cylinder(1.8, 0, 0, 0.1, 1.05, 1.05, 0, 0, ONEREV); /* ring */
+ polys += cylinder(e, 1.6, 0, 0, 0.1, 1.05, 1.05, 0, 0, ONEREV); /* ring */
+ polys += cylinder(e, 1.8, 0, 0, 0.1, 1.05, 1.05, 0, 0, ONEREV); /* ring */
glEndList();
+ return polys;
}
-void CrankBit(GLfloat x)
+static int CrankBit(Engine *e, GLfloat x)
{
- Rect(x, -1.4, 0.5, 0.2, 1.8, 1);
- cylinder(x, -0.5, 0, 0.2, 2, 2, 1, 60, 120);
+ int polys = 0;
+ polys += Rect(x, -1.4, 0.5, 0.2, 1.8, 1);
+ polys += cylinder(e, x, -0.5, 0, 0.2, 2, 2, 1, 60, 120);
+ return polys;
}
-void boom(GLfloat x, GLfloat y, int s)
+static int boom(Engine *e, GLfloat x, GLfloat y, int s)
{
- static GLfloat red[] = {0, 0, 0, 0.9};
- static GLfloat lpos[] = {0, 0, 0, 1};
- static GLfloat d = 0, wd;
+ int polys = 0;
int flameOut = 720/ENG.speed/ENG.cylinders;
- static int time = 0;
- if (time == 0 && s) {
- red[0] = red[1] = 0;
- d = 0.05;
- time++;
+ if (e->boom_time == 0 && s) {
+ e->boom_red[0] = e->boom_red[1] = 0;
+ e->boom_d = 0.05;
+ e->boom_time++;
glEnable(GL_LIGHT1);
- } else if (time == 0 && !s) {
- return;
- } else if (time >= 8 && time < flameOut && !s) {
- time++;
- red[0] -= 0.2; red[1] -= 0.1;
- d-= 0.04;
- } else if (time >= flameOut) {
- time = 0;
+ } else if (e->boom_time == 0 && !s) {
+ return polys;
+ } else if (e->boom_time >= 8 && e->boom_time < flameOut && !s) {
+ e->boom_time++;
+ e->boom_red[0] -= 0.2; e->boom_red[1] -= 0.1;
+ e->boom_d-= 0.04;
+ } else if (e->boom_time >= flameOut) {
+ e->boom_time = 0;
glDisable(GL_LIGHT1);
- return;
+ return polys;
} else {
- red[0] += 0.2; red[1] += 0.1;
- d+= 0.04;
- time++;
+ e->boom_red[0] += 0.2; e->boom_red[1] += 0.1;
+ e->boom_d += 0.04;
+ e->boom_time++;
}
- lpos[0] = x-d; lpos[1] = y;
- glLightfv(GL_LIGHT1, GL_POSITION, lpos);
- glLightfv(GL_LIGHT1, GL_DIFFUSE, red);
- glLightfv(GL_LIGHT1, GL_SPECULAR, red);
- glLighti(GL_LIGHT1, GL_LINEAR_ATTENUATION, 1.3);
+ e->boom_lpos[0] = x-e->boom_d; e->boom_lpos[1] = y;
+ glLightfv(GL_LIGHT1, GL_POSITION, e->boom_lpos);
+ glLightfv(GL_LIGHT1, GL_DIFFUSE, e->boom_red);
+ glLightfv(GL_LIGHT1, GL_SPECULAR, e->boom_red);
+ glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 1.3);
glLighti(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 0);
- glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
- wd = d*3;
- if (wd > 0.7) wd = 0.7;
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, e->boom_red);
+ e->boom_wd = e->boom_d*3;
+ if (e->boom_wd > 0.7) e->boom_wd = 0.7;
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- rod(x, y, 0, d, wd);
+ polys += rod(e, x, y, 0, e->boom_d, e->boom_wd);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
+ return polys;
}
-void display(Engine *e)
+static int display(ModeInfo *mi)
{
- static int a = 0;
+ Engine *e = &engine[MI_SCREEN(mi)];
+ int polys = 0;
GLfloat zb, yb;
- static GLfloat ln[730], yp[730], ang[730];
- static int ln_init = 0;
- static int lastPlug = 0;
+ float rightSide;
int half;
int sides;
int j, b;
- static float rightSide;
glEnable(GL_LIGHTING);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
- gluLookAt(viewer[0], viewer[1], viewer[2], lookat[0], lookat[1], lookat[2],
- 0.0, 1.0, 0.0);
+ gluLookAt(e->viewer[0], e->viewer[1], e->viewer[2],
+ e->lookat[0], e->lookat[1], e->lookat[2],
+ 0.0, 1.0, 0.0);
glPushMatrix();
+
+# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
+ {
+ GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
+ int o = (int) current_device_rotation();
+ if (o != 0 && o != 180 && o != -180)
+ glScalef (1/h, 1/h, 1/h);
+ }
+# endif
+
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_sp);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_sp);
get_position (e->rot, &x, &y, &z, !e->button_down_p);
glTranslatef(x*16-9, y*14-7, z*16-10);
}
+
if (spin) {
double x, y, z;
+
gltrackball_rotate (e->trackball);
+
get_rotation(e->rot, &x, &y, &z, !e->button_down_p);
glRotatef(x*ONEREV, 1.0, 0.0, 0.0);
glRotatef(y*ONEREV, 0.0, 1.0, 0.0);
/* crankshaft */
glPushMatrix();
- glRotatef(a, 1, 0, 0);
- glCallList(1);
+ glRotatef(e->display_a, 1, 0, 0);
+ glCallList(e->shaft_list);
+ polys += e->shaft_polys;
glPopMatrix();
/* init the ln[] matrix for speed */
- if (ln_init == 0) {
- for (ln_init = 0 ; ln_init < 730 ; ln_init++) {
- zb = sin_table[ln_init];
- yb = cos_table[ln_init];
+ if (e->ln_init == 0) {
+ for (e->ln_init = 0 ; e->ln_init < countof(e->sin_table) ; e->ln_init++) {
+ zb = e->sin_table[e->ln_init];
+ yb = e->cos_table[e->ln_init];
/* y ordinate of piston */
- yp[ln_init] = yb + sqrt(25 - (zb*zb));
+ e->yp[e->ln_init] = yb + sqrt(25 - (zb*zb));
/* length of rod */
- ln[ln_init] = sqrt(zb*zb + (yb-yp[ln_init])*(yb-yp[ln_init]));
+ e->ln[e->ln_init] = sqrt(zb*zb + (yb-e->yp[e->ln_init])*(yb-e->yp[e->ln_init]));
/* angle of connecting rod */
- ang[ln_init] = asin(zb/5)*57;
- ang[ln_init] *= -1;
+ e->ang[e->ln_init] = asin(zb/5)*57;
+ e->ang[e->ln_init] *= -1;
}
}
/* glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white); */
for (j = 0; j < ENG.cylinders; j += sides)
{
- b = (a + ENG.pistonAngle[j+half]) % ONEREV;
+ b = (e->display_a + ENG.pistonAngle[j+half]) % ONEREV;
glPushMatrix();
- glTranslatef(crankWidth/2 + crankOffset*(j+half), yp[b]-0.3, 0);
- glCallList(2);
+ glTranslatef(e->crankWidth/2 + e->crankOffset*(j+half), e->yp[b]-0.3, 0);
+ glCallList(e->piston_list);
+ polys += e->piston_polys;
glPopMatrix();
}
/* spark plugs */
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
for (j = 0; j < ENG.cylinders; j += sides)
{
- cylinder(8.5, -crankWidth/2-crankOffset*(j+half), 0,
+ polys += cylinder(e, 8.5, -e->crankWidth/2-e->crankOffset*(j+half), 0,
0.5, 0.4, 0.3, 1, 0, ONEREV);
}
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white);
for (j = 0; j < ENG.cylinders; j += sides)
{
- rod(8, -crankWidth/2-crankOffset*(j+half), 0, 0.5, 0.2);
- rod(9, -crankWidth/2-crankOffset*(j+half), 0, 1, 0.15);
+ polys += rod(e, 8, -e->crankWidth/2-e->crankOffset*(j+half), 0, 0.5, 0.2);
+ polys += rod(e, 9, -e->crankWidth/2-e->crankOffset*(j+half), 0, 1, 0.15);
}
/* rod */
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
for (j = 0; j < ENG.cylinders; j += sides)
{
- b = (a+HALFREV+ENG.pistonAngle[j+half]) % TWOREV;
+ b = (e->display_a+HALFREV+ENG.pistonAngle[j+half]) % TWOREV;
glPushMatrix();
- glRotatef(ang[b], 0, 1, 0);
- rod(-cos_table[b],
- -crankWidth/2-crankOffset*(j+half),
- -sin_table[b],
- ln[b], 0.2);
+ glRotatef(e->ang[b], 0, 1, 0);
+ polys += rod(e,
+ -e->cos_table[b],
+ -e->crankWidth/2-e->crankOffset*(j+half),
+ -e->sin_table[b],
+ e->ln[b], 0.2);
glPopMatrix();
}
glPopMatrix();
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
rightSide = (sides > 1) ? 0 : 1.6;
/* left plate */
- Rect(-crankWidth/2, -0.5, 1, 0.2, 9, 2);
+ polys += Rect(-e->crankWidth/2, -0.5, 1, 0.2, 9, 2);
/* right plate */
- Rect(0.3+crankOffset*ENG.cylinders-rightSide, -0.5, 1, 0.2, 9, 2);
+ polys += Rect(0.3+e->crankOffset*ENG.cylinders-rightSide, -0.5, 1, 0.2, 9, 2);
/* head plate */
- Rect(-crankWidth/2+0.2, 8.3, 1,
- crankWidth/2+0.1+crankOffset*ENG.cylinders-rightSide, 0.2, 2);
+ polys += Rect(-e->crankWidth/2+0.2, 8.3, 1,
+ e->crankWidth/2+0.1+e->crankOffset*ENG.cylinders-rightSide, 0.2, 2);
/* front rail */
- Rect(-crankWidth/2+0.2, 3, 1,
- crankWidth/2+0.1+crankOffset*ENG.cylinders-rightSide, 0.2, 0.2);
+ polys += Rect(-e->crankWidth/2+0.2, 3, 1,
+ e->crankWidth/2+0.1+e->crankOffset*ENG.cylinders-rightSide, 0.2, 0.2);
/* back rail */
- Rect(-crankWidth/2+0.2, 3, -1+0.2,
- crankWidth/2+0.1+crankOffset*ENG.cylinders-rightSide, 0.2, 0.2);
+ polys += Rect(-e->crankWidth/2+0.2, 3, -1+0.2,
+ e->crankWidth/2+0.1+e->crankOffset*ENG.cylinders-rightSide, 0.2, 0.2);
/* plates between cylinders */
for (j=0; j < ENG.cylinders - (sides == 1); j += sides)
- Rect(0.4+crankWidth+crankOffset*(j-half), 3, 1, 1, 5.3, 2);
+ polys += Rect(0.4+e->crankWidth+e->crankOffset*(j-half), 3, 1, 1, 5.3, 2);
glDepthMask(GL_TRUE);
}
glPopMatrix();
/* see which of our plugs should fire now, if any */
for (j = 0; j < ENG.cylinders; j++)
{
- if (0 == ((a + ENG.pistonAngle[j]) % TWOREV))
+ if (0 == ((e->display_a + ENG.pistonAngle[j]) % TWOREV))
{
glPushMatrix();
if (j & 1)
glRotatef(ENG.includedAngle,1,0,0);
glRotatef(90, 0, 0, 1);
- boom(8, -crankWidth/2-crankOffset*j, 1);
- lastPlug = j;
+ polys += boom(e, 8, -e->crankWidth/2-e->crankOffset*j, 1);
+ e->lastPlug = j;
glPopMatrix();
}
}
- if (lastPlug != j)
+ if (e->lastPlug != j)
{
/* this code causes the last plug explosion to dim gradually */
- if (lastPlug & 1)
+ if (e->lastPlug & 1)
glRotatef(ENG.includedAngle, 1, 0, 0);
glRotatef(90, 0, 0, 1);
- boom(8, -crankWidth/2-crankOffset*lastPlug, 0);
+ polys += boom(e, 8, -e->crankWidth/2-e->crankOffset*e->lastPlug, 0);
}
glDisable(GL_BLEND);
- a += ENG.speed;
- if (a >= TWOREV)
- a = 0;
+ e->display_a += ENG.speed;
+ if (e->display_a >= TWOREV)
+ e->display_a = 0;
glPopMatrix();
glFlush();
+ return polys;
}
-void makeshaft (void)
+static int makeshaft (Engine *e)
{
- int i;
+ int polys = 0;
int j;
- const static float crankThick = 0.2;
- const static float crankDiam = 0.3;
+ float crankThick = 0.2;
+ float crankDiam = 0.3;
- i = glGenLists(1);
- glNewList(i, GL_COMPILE);
+ /* if (e->shaft_list) glDeleteLists(1, e->shaft_list); */
+ if (! e->shaft_list) e->shaft_list = glGenLists(1);
+ glNewList(e->shaft_list, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
/* draw the flywheel */
- cylinder(-2.5, 0, 0, 1, 3, 2.5, 0, 0, ONEREV);
- Rect(-2, -0.3, 2.8, 0.5, 0.6, 5.6);
- Rect(-2, -2.8, 0.3, 0.5, 5.6, 0.6);
+ polys += cylinder(e, -2.5, 0, 0, 1, 3, 2.5, 0, 0, ONEREV);
+ polys += Rect(-2, -0.3, 2.8, 0.5, 0.6, 5.6);
+ polys += Rect(-2, -2.8, 0.3, 0.5, 5.6, 0.6);
/* now make each of the shaft bits between the cranks,
* starting from the flywheel end which is at X-coord 0.
* the first cranskhaft bit is always 2 units long
*/
- rod(-2, 0, 0, 2, crankDiam);
+ polys += rod(e, -2, 0, 0, 2, crankDiam);
/* Each crank is crankWidth units wide and the total width of a
* cylinder assembly is 3.3 units. For inline engines, there is just
* cylinders on one side of the engine, so the crankOffset length is
* halved.
*/
- crankOffset = 3.3;
+ e->crankOffset = 3.3;
if (ENG.includedAngle != 0)
- crankOffset /= 2;
+ e->crankOffset /= 2;
for (j = 0; j < ENG.cylinders - 1; j++)
- rod(crankWidth - crankThick + crankOffset*j, 0, 0,
- crankOffset - crankWidth + 2 * crankThick, crankDiam);
+ polys += rod(e,
+ e->crankWidth - crankThick + e->crankOffset*j, 0, 0,
+ e->crankOffset - e->crankWidth + 2 * crankThick, crankDiam);
/* the last bit connects to the engine wall on the non-flywheel end */
- rod(crankWidth - crankThick + crankOffset*j, 0, 0, 0.9, crankDiam);
+ polys += rod(e, e->crankWidth - crankThick + e->crankOffset*j, 0, 0, 0.9, crankDiam);
for (j = 0; j < ENG.cylinders; j++)
glRotatef(HALFREV+ENG.pistonAngle[j],1,0,0);
/* draw wrist pin */
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
- rod(crankOffset*j, -1.0, 0.0, crankWidth, crankDiam);
+ polys += rod(e, e->crankOffset*j, -1.0, 0.0, e->crankWidth, crankDiam);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
/* draw right part of crank */
- CrankBit(crankOffset*j);
+ polys += CrankBit(e, e->crankOffset*j);
/* draw left part of crank */
- CrankBit(crankWidth-crankThick+crankOffset*j);
+ polys += CrankBit(e, e->crankWidth-crankThick+e->crankOffset*j);
glPopMatrix();
}
glEndList();
-}
-
-static void
-load_font (ModeInfo *mi, char *res, XFontStruct **fontP, GLuint *dlistP)
-{
- const char *font = get_string_resource (res, "Font");
- XFontStruct *f;
- Font id;
- int first, last;
-
- if (!font) font = "-*-times-bold-r-normal-*-180-*";
-
- f = XLoadQueryFont(mi->dpy, font);
- if (!f) f = XLoadQueryFont(mi->dpy, "fixed");
-
- id = f->fid;
- first = f->min_char_or_byte2;
- last = f->max_char_or_byte2;
-
- clear_gl_error ();
- *dlistP = glGenLists ((GLuint) last+1);
- check_gl_error ("glGenLists");
- glXUseXFont(id, first, last-first+1, *dlistP + first);
- check_gl_error ("glXUseXFont");
-
- *fontP = f;
+ return polys;
}
-static void
-print_title_string (ModeInfo *mi, const char *string, GLfloat x, GLfloat y)
-{
- Engine *e = &engine[MI_SCREEN(mi)];
- XFontStruct *font = e->xfont;
- GLfloat line_height = font->ascent + font->descent;
-
- y -= line_height;
-
- glPushAttrib (GL_TRANSFORM_BIT | /* for matrix contents */
- GL_ENABLE_BIT); /* for various glDisable calls */
- glDisable (GL_LIGHTING);
- glDisable (GL_DEPTH_TEST);
- {
- glMatrixMode(GL_PROJECTION);
- glPushMatrix();
- {
- glLoadIdentity();
-
- glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- {
- int i;
- int x2 = x;
- glLoadIdentity();
-
- gluOrtho2D (0, mi->xgwa.width, 0, mi->xgwa.height);
-
- glRasterPos2f (x, y);
- for (i = 0; i < strlen(string); i++)
- {
- char c = string[i];
- if (c == '\n')
- {
- glRasterPos2f (x, (y -= line_height));
- x2 = x;
- }
- else
- {
- glCallList (e->font_dlist + (int)(c));
- x2 += (font->per_char
- ? font->per_char[c - font->min_char_or_byte2].width
- : font->min_bounds.width);
- }
- }
- }
- glPopMatrix();
- }
- glMatrixMode(GL_PROJECTION);
- glPopMatrix();
- }
- glPopAttrib();
-
- glMatrixMode(GL_MODELVIEW);
-}
-
-
-
-void reshape_engine(ModeInfo *mi, int width, int height)
+ENTRYPOINT void reshape_engine(ModeInfo *mi, int width, int height)
{
+ Engine *e = &engine[MI_SCREEN(mi)];
glViewport(0,0,(GLint)width, (GLint) height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
- glFrustum(-1.0,1.0,-1.0,1.0,1.5,70.0);
+/* glFrustum(-1.0,1.0,-1.0,1.0,1.5,70.0);*/
+ gluPerspective(40.0,((GLdouble)width)/height,1.5,70.0);
glMatrixMode(GL_MODELVIEW);
- win_h = height; win_w = width;
+ e->win_h = height;
+ e->win_w = width;
}
-void init_engine(ModeInfo *mi)
+ENTRYPOINT void init_engine(ModeInfo *mi)
{
int screen = MI_SCREEN(mi);
Engine *e;
e->dy = (float)(random() % 1000)/30000;
e->dz = (float)(random() % 1000)/30000;
} else {
- viewer[0] = 0; viewer[1] = 2; viewer[2] = 18;
- lookat[0] = 0; lookat[1] = 0; lookat[2] = 0;
+ e->viewer[0] = 0; e->viewer[1] = 2; e->viewer[2] = 18;
+ e->lookat[0] = 0; e->lookat[1] = 0; e->lookat[2] = 0;
}
if (spin) {
}
{
- double spin_speed = 1.0;
- double wander_speed = 0.03;
+ double spin_speed = 0.5;
+ double wander_speed = 0.01;
+
+ e->crankWidth = 1.5;
+ e->boom_red[3] = 0.9;
+ e->boom_lpos[3] = 1;
+
+ e->viewer[2] = 30;
e->rot = make_rotator (spin ? spin_speed : 0,
spin ? spin_speed : 0,
move ? wander_speed : 0,
True);
- e->trackball = gltrackball_init ();
+ e->trackball = gltrackball_init (True);
}
- if ((e->glx_context = init_GL(mi)) != NULL) {
+ if (!e->glx_context && /* re-initting breaks print_texture_label */
+ (e->glx_context = init_GL(mi)) != NULL) {
reshape_engine(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
- glClearColor(0.0,0.0,0.0,0.0);
glShadeModel(GL_SMOOTH);
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
- make_tables();
- engineType = find_engine(which_engine);
+ make_tables(e);
+ e->engineType = find_engine(which_engine);
- e->engine_name = malloc(200);
+ if (!e->engine_name)
+ e->engine_name = malloc(200);
sprintf (e->engine_name,
"%s\n%s%d%s",
- engines[engineType].engineName,
- (engines[engineType].includedAngle == 0 ? "" :
- engines[engineType].includedAngle == 180 ? "Flat " : "V"),
- engines[engineType].cylinders,
- (engines[engineType].includedAngle == 0 ? " Cylinder" : "")
+ engines[e->engineType].engineName,
+ (engines[e->engineType].includedAngle == 0 ? "" :
+ engines[e->engineType].includedAngle == 180 ? "Flat " : "V"),
+ engines[e->engineType].cylinders,
+ (engines[e->engineType].includedAngle == 0 ? " Cylinder" : "")
);
- makeshaft();
- makepiston();
- load_font (mi, "titleFont", &e->xfont, &e->font_dlist);
+ e->shaft_polys = makeshaft(e);
+ e->piston_polys = makepiston(e);
+
+ if (!e->font_data)
+ e->font_data = load_texture_font (mi->dpy, "titleFont");
}
-Bool engine_handle_event (ModeInfo *mi, XEvent *event)
+ENTRYPOINT Bool
+engine_handle_event (ModeInfo *mi, XEvent *event)
{
Engine *e = &engine[MI_SCREEN(mi)];
if (event->xany.type == ButtonPress &&
- event->xbutton.button & Button1)
+ event->xbutton.button == Button1)
{
- e->button_down_p = True;
- gltrackball_start (e->trackball,
- event->xbutton.x, event->xbutton.y,
- MI_WIDTH (mi), MI_HEIGHT (mi));
- movepaused = 1;
return True;
}
else if (event->xany.type == ButtonRelease &&
- event->xbutton.button & Button1) {
- e->button_down_p = False;
- movepaused = 0;
- return True;
+ event->xbutton.button == Button1) {
+ e->movepaused = 0;
}
- else if (event->xany.type == MotionNotify &&
- e->button_down_p) {
- gltrackball_track (e->trackball,
- event->xmotion.x, event->xmotion.y,
- MI_WIDTH (mi), MI_HEIGHT (mi));
+
+ if (gltrackball_event_handler (event, e->trackball,
+ MI_WIDTH (mi), MI_HEIGHT (mi),
+ &e->button_down_p))
+ return True;
+ else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
+ {
+ which_engine = NULL; /* randomize */
+ init_engine(mi);
return True;
- }
+ }
+
return False;
}
-void draw_engine(ModeInfo *mi)
+ENTRYPOINT void draw_engine(ModeInfo *mi)
{
Engine *e = &engine[MI_SCREEN(mi)];
Window w = MI_WINDOW(mi);
glXMakeCurrent(disp, w, *(e->glx_context));
- display(e);
+ mi->polygon_count = display(mi);
+ glColor3f (1, 1, 0);
if (do_titles)
- print_title_string (mi, e->engine_name,
- 10, mi->xgwa.height - 10);
+ print_texture_label (mi->dpy, e->font_data,
+ mi->xgwa.width, mi->xgwa.height,
+ 1, e->engine_name);
if(mi->fps_p) do_fps(mi);
glFinish();
glXSwapBuffers(disp, w);
}
-void release_engine(ModeInfo *mi)
+ENTRYPOINT void
+release_engine(ModeInfo *mi)
{
if (engine != NULL) {
(void) free((void *) engine);
engine = NULL;
}
- FreeAllGL(MI);
+ FreeAllGL(mi);
}
+XSCREENSAVER_MODULE ("Engine", engine)
+
#endif