-/* -*- Mode: C; tab-width: 4 -*-
- * gears.c --- 3D gear wheels
- */
+/* -*- Mode: C; tab-width: 4 -*- */
+/* gears --- 3D gear wheels */
+
#if !defined( lint ) && !defined( SABER )
-static const char sccsid[] = "@(#)gears.c 4.02 97/04/01 xlockmore";
+static const char sccsid[] = "@(#)gears.c 4.07 97/11/24 xlockmore";
+
#endif
-/* Permission to use, copy, modify, and distribute this software and its
+
+/*-
+ * 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
* other special, indirect and consequential damages.
*
* Revision History:
+ * 09-Feb-01: "Planetary" gear system added by jwz@jwz.org.
+ * 10-May-97: Compatible with xscreensaver
* 22-Mar-97: Added support for -mono mode, and monochrome X servers.
- * Ed Mackey, emackey@early.com
+ * Ed Mackey, emackey@netaxs.com
* 13-Mar-97: Memory leak fix by Tom Schmidt <tschmidt@micron.com>
* 1996: "written" by Danny Sung <dannys@ucla.edu>
* Based on 3-D gear wheels by Brian Paul which is in the public domain.
- *
- * Brian Paul
*/
/*-
# define PROGCLASS "Gears"
# define HACK_INIT init_gears
# define HACK_DRAW draw_gears
+# define HACK_RESHAPE reshape_gears
# define gears_opts xlockmore_opts
# define DEFAULTS "*count: 1 \n" \
"*cycles: 2 \n" \
- "*delay: 100 \n" \
+ "*delay: 20000 \n" \
+ "*planetary: False \n" \
+ "*showFPS: False \n" \
"*wireframe: False \n"
# include "xlockmore.h" /* from the xscreensaver distribution */
#else /* !STANDALONE */
#ifdef USE_GL
-ModeSpecOpt gears_opts = {
- 0, NULL, 0, NULL, NULL };
+#undef countof
+#define countof(x) (sizeof((x))/sizeof((*x)))
+
+#define DEF_PLANETARY "False"
+
+static int planetary;
+
+static XrmOptionDescRec opts[] = {
+ {"-planetary", ".gears.planetary", XrmoptionNoArg, (caddr_t) "true" },
+ {"+planetary", ".gears.planetary", XrmoptionNoArg, (caddr_t) "false" },
+};
+
+static argtype vars[] = {
+ {(caddr_t *) &planetary, "planetary", "Planetary", DEF_PLANETARY, t_Bool},
+};
+
+ModeSpecOpt gears_opts = {countof(opts), opts, countof(vars), vars, NULL};
+
+#ifdef USE_MODULES
+ModStruct gears_description =
+{"gears", "init_gears", "draw_gears", "release_gears",
+ "draw_gears", "init_gears", NULL, &gears_opts,
+ 1000, 1, 2, 1, 4, 1.0, "",
+ "Shows GL's gears", 0, NULL};
-typedef struct {
- GLfloat view_rotx, view_roty, view_rotz;
- GLuint gear1, gear2, gear3;
- GLfloat angle;
- int mono;
- GLXContext glx_context;
-#if 0
- Window win;
#endif
+
+typedef struct {
+
+ GLfloat rotx, roty, rotz; /* current object rotation */
+ GLfloat dx, dy, dz; /* current rotational velocity */
+ GLfloat ddx, ddy, ddz; /* current rotational acceleration */
+ GLfloat d_max; /* max velocity */
+
+ GLuint gear1, gear2, gear3;
+ GLuint gear_inner, gear_outer;
+ GLuint armature;
+ GLfloat angle;
+ GLXContext *glx_context;
+ Window window;
} gearsstruct;
static gearsstruct *gears = NULL;
-/*
+/*-
* Draw a gear wheel. You'll probably want to call this function when
* building a display list since we do a lot of trig here.
*
*/
static void
gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
- GLint teeth, GLfloat tooth_depth, Bool wire)
+ GLint teeth, GLfloat tooth_depth, Bool wire, Bool invert)
{
GLint i;
GLfloat r0, r1, r2;
GLfloat angle, da;
GLfloat u, v, len;
- r0 = inner_radius;
- r1 = outer_radius - tooth_depth / 2.0;
- r2 = outer_radius + tooth_depth / 2.0;
+ if (!invert)
+ {
+ r0 = inner_radius;
+ r1 = outer_radius - tooth_depth / 2.0;
+ r2 = outer_radius + tooth_depth / 2.0;
+ glFrontFace(GL_CCW);
+ }
+ else
+ {
+ r0 = outer_radius;
+ r2 = inner_radius + tooth_depth / 2.0;
+ r1 = outer_radius - tooth_depth / 2.0;
+ glFrontFace(GL_CW);
+ }
da = 2.0 * M_PI / teeth / 4.0;
/* draw outward faces of teeth */
if (!wire)
glBegin(GL_QUAD_STRIP);
- for (i = 0; i < teeth; i++) {
+ for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
- if (wire)
- glBegin(GL_LINES);
- glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
- glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
- u = r2 * cos(angle + da) - r1 * cos(angle);
- v = r2 * sin(angle + da) - r1 * sin(angle);
+ if(!invert) {
+ u = r2 * cos(angle + da) - r1 * cos(angle);
+ v = r2 * sin(angle + da) - r1 * sin(angle);
+ } else {
+ u = r2 * cos(angle + da + M_PI/2) - r1 * cos(angle + M_PI/2);
+ v = r2 * sin(angle + da + M_PI/2) - r1 * sin(angle + M_PI/2);
+ }
+
len = sqrt(u * u + v * v);
u /= len;
v /= len;
glNormal3f(v, -u, 0.0);
+
+ if (wire)
+ glBegin(GL_LINES);
+ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
+ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
+
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
- glNormal3f(cos(angle), sin(angle), 0.0);
+
+ if(!invert)
+ glNormal3f(cos(angle), sin(angle), 0.0);
+ else
+ glNormal3f(cos(angle + M_PI/2), sin(angle + M_PI/2), 0.0);
+
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
- u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
- v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
+
+ if(!invert) {
+ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
+ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
+ } else {
+ u = r1 * cos(angle + 3 * da + M_PI/2) - r2 * cos(angle + 2 * da + M_PI/2);
+ v = r1 * sin(angle + 3 * da + M_PI/2) - r2 * sin(angle + 2 * da + M_PI/2);
+ }
+
glNormal3f(v, -u, 0.0);
+
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
- glNormal3f(cos(angle), sin(angle), 0.0);
+
+ if (!invert)
+ glNormal3f(cos(angle), sin(angle), 0.0);
+ else
+ glNormal3f(cos(angle + M_PI/2), sin(angle + M_PI/2), 0.0);
+
if (wire)
glEnd();
}
angle = i * 2.0 * M_PI / teeth;
if (wire)
glBegin(GL_LINES);
- glNormal3f(-cos(angle), -sin(angle), 0.0);
+
+ if (!invert)
+ glNormal3f(-cos(angle), -sin(angle), 0.0);
+ else
+ glNormal3f(cos(angle), sin(angle), 0.0);
+
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
if (wire) {
}
+
+
+static void
+tube(GLfloat radius, GLfloat width, GLint facets, Bool wire)
+{
+ GLint i;
+ GLfloat da = 2.0 * M_PI / facets / 4.0;
+
+ glFrontFace(GL_CCW);
+
+ /* draw bottom of tube */
+
+ glShadeModel(GL_FLAT);
+ glNormal3f(0, 0, 1);
+ if (!wire)
+ {
+ glBegin(GL_TRIANGLE_FAN);
+ glVertex3f(0, 0, width * 0.5);
+ for (i = 0; i <= facets; i++) {
+ GLfloat angle = i * 2.0 * M_PI / facets;
+ glVertex3f(radius * cos(angle), radius * sin(angle), width * 0.5);
+ }
+ glEnd();
+ }
+
+ /* draw top of tube */
+
+ glShadeModel(GL_FLAT);
+ glNormal3f(0, 0, -1);
+ glFrontFace(GL_CW);
+ if (!wire)
+ {
+ glBegin(GL_TRIANGLE_FAN);
+ glVertex3f(0, 0, -width * 0.5);
+ for (i = 0; i <= facets; i++) {
+ GLfloat angle = i * 2.0 * M_PI / facets;
+ glVertex3f(radius * cos(angle), radius * sin(angle), -width * 0.5);
+ }
+ glEnd();
+ }
+
+ /* draw side of tube */
+ glFrontFace(GL_CW);
+ glShadeModel(GL_SMOOTH);
+
+ if (!wire)
+ glBegin(GL_QUAD_STRIP);
+
+ for (i = 0; i <= facets; i++) {
+ GLfloat angle = i * 2.0 * M_PI / facets;
+
+ if (wire)
+ glBegin(GL_LINES);
+
+ glNormal3f(cos(angle), sin(angle), 0.0);
+
+ glVertex3f(radius * cos(angle), radius * sin(angle), -width * 0.5);
+ glVertex3f(radius * cos(angle), radius * sin(angle), width * 0.5);
+
+ if (wire) {
+ glVertex3f(radius * cos(angle), radius * sin(angle), -width * 0.5);
+ glVertex3f(radius * cos(angle + 4 * da), radius * sin(angle + 4 * da), -width * 0.5);
+ glVertex3f(radius * cos(angle), radius * sin(angle), width * 0.5);
+ glVertex3f(radius * cos(angle + 4 * da), radius * sin(angle + 4 * da), width * 0.5);
+ glEnd();
+ }
+ }
+
+ if (!wire)
+ glEnd();
+
+ glFrontFace(GL_CCW);
+}
+
+
+static void
+arm(GLfloat length,
+ GLfloat width1, GLfloat height1,
+ GLfloat width2, GLfloat height2,
+ Bool wire)
+{
+ glShadeModel(GL_FLAT);
+
+#if 0 /* don't need these - they're embedded in other objects */
+ /* draw end 1 */
+ glFrontFace(GL_CW);
+ glNormal3f(-1, 0, 0);
+ glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
+ glVertex3f(-length/2, -width1/2, -height1/2);
+ glVertex3f(-length/2, width1/2, -height1/2);
+ glVertex3f(-length/2, width1/2, height1/2);
+ glVertex3f(-length/2, -width1/2, height1/2);
+ glEnd();
+
+ /* draw end 2 */
+ glFrontFace(GL_CCW);
+ glNormal3f(1, 0, 0);
+ glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
+ glVertex3f(length/2, -width2/2, -height2/2);
+ glVertex3f(length/2, width2/2, -height2/2);
+ glVertex3f(length/2, width2/2, height2/2);
+ glVertex3f(length/2, -width2/2, height2/2);
+ glEnd();
+#endif
+
+ /* draw top */
+ glFrontFace(GL_CCW);
+ glNormal3f(0, 0, -1);
+ glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
+ glVertex3f(-length/2, -width1/2, -height1/2);
+ glVertex3f(-length/2, width1/2, -height1/2);
+ glVertex3f( length/2, width2/2, -height2/2);
+ glVertex3f( length/2, -width2/2, -height2/2);
+ glEnd();
+
+ /* draw bottom */
+ glFrontFace(GL_CW);
+ glNormal3f(0, 0, 1);
+ glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
+ glVertex3f(-length/2, -width1/2, height1/2);
+ glVertex3f(-length/2, width1/2, height1/2);
+ glVertex3f( length/2, width2/2, height2/2);
+ glVertex3f( length/2, -width2/2, height2/2);
+ glEnd();
+
+ /* draw left */
+ glFrontFace(GL_CW);
+ glNormal3f(0, -1, 0);
+ glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
+ glVertex3f(-length/2, -width1/2, -height1/2);
+ glVertex3f(-length/2, -width1/2, height1/2);
+ glVertex3f( length/2, -width2/2, height2/2);
+ glVertex3f( length/2, -width2/2, -height2/2);
+ glEnd();
+
+ /* draw right */
+ glFrontFace(GL_CCW);
+ glNormal3f(0, 1, 0);
+ glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
+ glVertex3f(-length/2, width1/2, -height1/2);
+ glVertex3f(-length/2, width1/2, height1/2);
+ glVertex3f( length/2, width2/2, height2/2);
+ glVertex3f( length/2, width2/2, -height2/2);
+ glEnd();
+
+ glFrontFace(GL_CCW);
+}
+
+
static void
draw(ModeInfo * mi)
{
gearsstruct *gp = &gears[MI_SCREEN(mi)];
- int wire = MI_WIN_IS_WIREFRAME(mi) || gp->mono;
+ int wire = MI_IS_WIREFRAME(mi);
if (!wire) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glPushMatrix();
- glRotatef(gp->view_rotx, 1.0, 0.0, 0.0);
- glRotatef(gp->view_roty, 0.0, 1.0, 0.0);
- glRotatef(gp->view_rotz, 0.0, 0.0, 1.0);
- glPushMatrix();
- glTranslatef(-3.0, -2.0, 0.0);
- glRotatef(gp->angle, 0.0, 0.0, 1.0);
+ {
+ GLfloat x = gp->rotx;
+ GLfloat y = gp->roty;
+ GLfloat z = gp->rotz;
+ if (x < 0) x = 1 - (x + 1);
+ if (y < 0) y = 1 - (y + 1);
+ if (z < 0) z = 1 - (z + 1);
+ glRotatef(x * 360, 1.0, 0.0, 0.0);
+ glRotatef(y * 360, 0.0, 1.0, 0.0);
+ glRotatef(z * 360, 0.0, 0.0, 1.0);
+ }
+
+ if (!planetary) {
+ glPushMatrix();
+ glTranslatef(-3.0, -2.0, 0.0);
+ glRotatef(gp->angle, 0.0, 0.0, 1.0);
/* PURIFY 4.0.1 reports an unitialized memory read on the next line when using
* MesaGL 2.2 and -mono. This has been fixed in MesaGL 2.3 and later. */
- glCallList(gp->gear1);
- glPopMatrix();
-
- glPushMatrix();
- glTranslatef(3.1, -2.0, 0.0);
- glRotatef(-2.0 * gp->angle - 9.0, 0.0, 0.0, 1.0);
- glCallList(gp->gear2);
- glPopMatrix();
-
- glPushMatrix();
- glTranslatef(-3.1, 4.2, 0.0);
- glRotatef(-2.0 * gp->angle - 25.0, 0.0, 0.0, 1.0);
- glCallList(gp->gear3);
- glPopMatrix();
+ glCallList(gp->gear1);
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslatef(3.1, -2.0, 0.0);
+ glRotatef(-2.0 * gp->angle - 9.0, 0.0, 0.0, 1.0);
+ glCallList(gp->gear2);
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslatef(-3.1, 4.2, 0.0);
+ glRotatef(-2.0 * gp->angle - 25.0, 0.0, 0.0, 1.0);
+ glCallList(gp->gear3);
+ glPopMatrix();
+
+ } else { /* planetary */
+
+ glScalef(0.8, 0.8, 0.8);
+
+ glPushMatrix();
+ glTranslatef(0.0, 4.2, 0.0);
+ glRotatef(gp->angle - 7.0, 0.0, 0.0, 1.0);
+ glCallList(gp->gear1);
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(120, 0.0, 0.0, 1.0);
+ glTranslatef(0.0, 4.2, 0.0);
+ glRotatef(gp->angle - 7.0, 0.0, 0.0, 1.0);
+ glCallList(gp->gear2);
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(240, 0.0, 0.0, 1.0);
+ glTranslatef(0.0, 4.2, 0.0);
+ glRotatef(gp->angle - 7.0, 0.0, 0.0, 1.0);
+ glCallList(gp->gear3);
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslatef(0.0, 0.0, 0.0);
+ glRotatef(-gp->angle, 0.0, 0.0, 1.0);
+ glCallList(gp->gear_inner);
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslatef(0.0, 0.0, 0.0);
+ glRotatef((gp->angle / 3.0) - 7.5, 0.0, 0.0, 1.0);
+ glCallList(gp->gear_outer);
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslatef(0.0, 0.0, 0.0);
+ glCallList(gp->armature);
+ glPopMatrix();
+ }
glPopMatrix();
}
/* new window size or exposure */
-static void
-reshape(int width, int height)
+void
+reshape_gears(ModeInfo *mi, int width, int height)
{
GLfloat h = (GLfloat) height / (GLfloat) width;
{0.0, 0.8, 0.2, 1.0};
static GLfloat blue[4] =
{0.2, 0.2, 1.0, 1.0};
- int wire = MI_WIN_IS_WIREFRAME(mi) || gp->mono;
+ static GLfloat gray[4] =
+ {0.5, 0.5, 0.5, 1.0};
+ static GLfloat white[4] =
+ {1.0, 1.0, 1.0, 1.0};
+ int wire = MI_IS_WIREFRAME(mi);
+ int mono = MI_IS_MONO(mi);
if (!wire) {
glLightfv(GL_LIGHT0, GL_POSITION, pos);
* 2nd time mode is run it is Grayscale on PseudoColor.
* The code below forces monochrome on TrueColor.
*/
- if (MI_WIN_IS_MONO(mi)) {
+ if (MI_IS_MONO(mi)) {
red[0] = red[1] = red[2] = 1.0;
green[0] = green[1] = green[2] = 1.0;
blue[0] = blue[1] = blue[2] = 1.0;
#endif
/* make the gears */
- gp->gear1 = glGenLists(1);
- glNewList(gp->gear1, GL_COMPILE);
- if (!wire)
- glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
- else
- glColor4fv(red);
- gear(1.0, 4.0, 1.0, 20, 0.7, wire);
- glEndList();
-
- gp->gear2 = glGenLists(1);
- glNewList(gp->gear2, GL_COMPILE);
- if (!wire)
- glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
- else
- glColor4fv(green);
- gear(0.5, 2.0, 2.0, 10, 0.7, wire);
- glEndList();
-
- gp->gear3 = glGenLists(1);
- glNewList(gp->gear3, GL_COMPILE);
- if (!wire)
- glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
- else
- glColor4fv(blue);
- gear(1.3, 2.0, 0.5, 10, 0.7, wire);
- glEndList();
- if (!wire)
+
+ if (! planetary) {
+
+ gp->gear1 = glGenLists(1);
+ glNewList(gp->gear1, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(red);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
+ }
+
+ gear(1.0, 4.0, 1.0, 20, 0.7, wire, False);
+ glEndList();
+
+ gp->gear2 = glGenLists(1);
+ glNewList(gp->gear2, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(green);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
+ }
+ gear(0.5, 2.0, 2.0, 10, 0.7, wire, False);
+ glEndList();
+
+ gp->gear3 = glGenLists(1);
+ glNewList(gp->gear3, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(blue);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
+ }
+ gear(1.3, 2.0, 0.5, 10, 0.7, wire, False);
+ glEndList();
+ if (!wire)
+ glEnable(GL_NORMALIZE);
+
+ } else { /* planetary */
+
+ gp->gear1 = glGenLists(1);
+ glNewList(gp->gear1, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(red);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
+ }
+ gear(1.3, 2.0, 2.0, 12, 0.7, wire, False);
+ glEndList();
+
+ gp->gear2 = glGenLists(1);
+ glNewList(gp->gear2, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(green);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
+ }
+ gear(1.3, 2.0, 2.0, 12, 0.7, wire, False);
+ glEndList();
+
+ gp->gear3 = glGenLists(1);
+ glNewList(gp->gear3, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(blue);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
+ }
+ gear(1.3, 2.0, 2.0, 12, 0.7, wire, False);
+ glEndList();
+ if (!wire)
+ glEnable(GL_NORMALIZE);
+
+
+ gp->gear_inner = glGenLists(1);
+ glNewList(gp->gear_inner, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(blue);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
+ }
+ gear(1.0, 2.0, 2.0, 12, 0.7, wire, False);
+ glEndList();
+ if (!wire)
glEnable(GL_NORMALIZE);
+
+
+ gp->gear_outer = glGenLists(1);
+ glNewList(gp->gear_outer, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(blue);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
+ }
+ gear(5.7, 7.0, 2.0, 36, 0.7, wire, True);
+
+ /* put some nubs on the outer ring, so we can tell how it's moving */
+ glPushMatrix();
+ glTranslatef(7.0, 0, 0);
+ glRotatef(90, 0, 1, 0);
+ tube(0.5, 0.5, 10, wire); /* nub 1 */
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(120, 0, 0, 1);
+ glTranslatef(7.0, 0, 0);
+ glRotatef(90, 0, 1, 0);
+ tube(0.5, 0.5, 10, wire); /* nub 2 */
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(240, 0, 0, 1);
+ glTranslatef(7.0, 0, 0);
+ glRotatef(90, 0, 1, 0);
+ tube(0.5, 0.5, 10, wire); /* nub 3 */
+ glPopMatrix();
+
+
+ glEndList();
+ if (!wire)
+ glEnable(GL_NORMALIZE);
+
+ gp->armature = glGenLists(1);
+ glNewList(gp->armature, GL_COMPILE);
+ if (wire) {
+ if (mono)
+ glColor4fv(white);
+ else
+ glColor4fv(blue);
+ } else {
+ if (mono)
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ else
+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
+ }
+
+ glTranslatef(0, 0, 1.5);
+
+ tube(0.5, 10, 15, wire); /* center axle */
+
+ glPushMatrix();
+ glTranslatef(0.0, 4.2, -1);
+ tube(0.5, 3, 15, wire); /* axle 1 */
+ glTranslatef(0, 0, 1.8);
+ tube(0.7, 0.7, 15, wire);
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(120, 0.0, 0.0, 1.0);
+ glTranslatef(0.0, 4.2, -1);
+ tube(0.5, 3, 15, wire); /* axle 2 */
+ glTranslatef(0, 0, 1.8);
+ tube(0.7, 0.7, 15, wire);
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(240, 0.0, 0.0, 1.0);
+ glTranslatef(0.0, 4.2, -1);
+ tube(0.5, 3, 15, wire); /* axle 3 */
+ glTranslatef(0, 0, 1.8);
+ tube(0.7, 0.7, 15, wire);
+ glPopMatrix();
+
+ glTranslatef(0, 0, 1.5); /* center disk */
+ tube(1.5, 2, 20, wire);
+
+ glPushMatrix();
+ glRotatef(270, 0, 0, 1);
+ glRotatef(-10, 0, 1, 0);
+ glTranslatef(-2.2, 0, 0);
+ arm(4.0, 1.0, 0.5, 2.0, 1.0, wire); /* arm 1 */
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(30, 0, 0, 1);
+ glRotatef(-10, 0, 1, 0);
+ glTranslatef(-2.2, 0, 0);
+ arm(4.0, 1.0, 0.5, 2.0, 1.0, wire); /* arm 2 */
+ glPopMatrix();
+
+ glPushMatrix();
+ glRotatef(150, 0, 0, 1);
+ glRotatef(-10, 0, 1, 0);
+ glTranslatef(-2.2, 0, 0);
+ arm(4.0, 1.0, 0.5, 2.0, 1.0, wire); /* arm 3 */
+ glPopMatrix();
+
+ glEndList();
+ if (!wire)
+ glEnable(GL_NORMALIZE);
+ }
}
+
+/* lifted from lament.c */
+#define RAND(n) ((long) ((random() & 0x7fffffff) % ((long) (n))))
+#define RANDSIGN() ((random() & 1) ? 1 : -1)
+
+static void
+rotate(GLfloat *pos, GLfloat *v, GLfloat *dv, GLfloat max_v)
+{
+ double ppos = *pos;
+
+ /* tick position */
+ if (ppos < 0)
+ ppos = -(ppos + *v);
+ else
+ ppos += *v;
+
+ if (ppos > 1.0)
+ ppos -= 1.0;
+ else if (ppos < 0)
+ ppos += 1.0;
+
+ if (ppos < 0) abort();
+ if (ppos > 1.0) abort();
+ *pos = (*pos > 0 ? ppos : -ppos);
+
+ /* accelerate */
+ *v += *dv;
+
+ /* clamp velocity */
+ if (*v > max_v || *v < -max_v)
+ {
+ *dv = -*dv;
+ }
+ /* If it stops, start it going in the other direction. */
+ else if (*v < 0)
+ {
+ if (random() % 4)
+ {
+ *v = 0;
+
+ /* keep going in the same direction */
+ if (random() % 2)
+ *dv = 0;
+ else if (*dv < 0)
+ *dv = -*dv;
+ }
+ else
+ {
+ /* reverse gears */
+ *v = -*v;
+ *dv = -*dv;
+ *pos = -*pos;
+ }
+ }
+
+ /* Alter direction of rotational acceleration randomly. */
+ if (! (random() % 120))
+ *dv = -*dv;
+
+ /* Change acceleration very occasionally. */
+ if (! (random() % 200))
+ {
+ if (*dv == 0)
+ *dv = 0.00001;
+ else if (random() & 1)
+ *dv *= 1.2;
+ else
+ *dv *= 0.8;
+ }
+}
+
+
void
init_gears(ModeInfo * mi)
{
-#if 0
- Display *display = MI_DISPLAY(mi);
- Window window = MI_WINDOW(mi);
-
-#endif
int screen = MI_SCREEN(mi);
/*Colormap cmap; */
}
gp = &gears[screen];
-#if 0
- gp->win = window;
-#endif
- gp->view_rotx = NRAND(360);
- gp->view_roty = NRAND(360);
- gp->view_rotz = NRAND(360);
- gp->angle = NRAND(360);
- gp->mono = (MI_WIN_IS_MONO(mi) ? 1 : 0);
+ gp->window = MI_WINDOW(mi);
+
+ gp->rotx = frand(1.0) * RANDSIGN();
+ gp->roty = frand(1.0) * RANDSIGN();
+ gp->rotz = frand(1.0) * RANDSIGN();
+
+ /* bell curve from 0-1.5 degrees, avg 0.75 */
+ gp->dx = (frand(1) + frand(1) + frand(1)) / (360*2);
+ gp->dy = (frand(1) + frand(1) + frand(1)) / (360*2);
+ gp->dz = (frand(1) + frand(1) + frand(1)) / (360*2);
+
+ gp->d_max = gp->dx * 2;
- gp->glx_context = init_GL(mi);
+ gp->ddx = 0.00006 + frand(0.00003);
+ gp->ddy = 0.00006 + frand(0.00003);
+ gp->ddz = 0.00006 + frand(0.00003);
- reshape(MI_WIN_WIDTH(mi), MI_WIN_HEIGHT(mi));
- pinit(mi);
+ gp->ddx = 0.00001;
+ gp->ddy = 0.00001;
+ gp->ddz = 0.00001;
+
+ if ((gp->glx_context = init_GL(mi)) != NULL) {
+ reshape_gears(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
+ pinit(mi);
+ } else {
+ MI_CLEARWINDOW(mi);
+ }
}
void
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int angle_incr = MI_CYCLES(mi) ? MI_CYCLES(mi) : 2;
- int rot_incr = MI_BATCHCOUNT(mi) ? MI_BATCHCOUNT(mi) : 1;
+
+ if (planetary)
+ angle_incr *= 3;
+
+ if (!gp->glx_context)
+ return;
glDrawBuffer(GL_BACK);
- glXMakeCurrent(display, window, gp->glx_context);
+ glXMakeCurrent(display, window, *(gp->glx_context));
draw(mi);
/* let's do something so we don't get bored */
gp->angle = (int) (gp->angle + angle_incr) % 360;
- gp->view_rotx = (int) (gp->view_rotx + rot_incr) % 360;
- gp->view_roty = (int) (gp->view_roty + rot_incr) % 360;
- gp->view_rotz = (int) (gp->view_rotz + rot_incr) % 360;
+ rotate(&gp->rotx, &gp->dx, &gp->ddx, gp->d_max);
+ rotate(&gp->roty, &gp->dy, &gp->ddy, gp->d_max);
+ rotate(&gp->rotz, &gp->dz, &gp->ddz, gp->d_max);
+
+ if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(display, window);
}
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
gearsstruct *gp = &gears[screen];
- /* Display lists MUST be freed while their glXContext is current. */
- glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), gp->glx_context);
-
- if (glIsList(gp->gear1))
- glDeleteLists(gp->gear1, 1);
- if (glIsList(gp->gear2))
- glDeleteLists(gp->gear2, 1);
- if (glIsList(gp->gear3))
- glDeleteLists(gp->gear3, 1);
-
- /* Don't destroy the glXContext. init_GL does that. */
-
+ if (gp->glx_context) {
+ /* Display lists MUST be freed while their glXContext is current. */
+ glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
+
+ if (glIsList(gp->gear1))
+ glDeleteLists(gp->gear1, 1);
+ if (glIsList(gp->gear2))
+ glDeleteLists(gp->gear2, 1);
+ if (glIsList(gp->gear3))
+ glDeleteLists(gp->gear3, 1);
+ if (glIsList(gp->gear_inner))
+ glDeleteLists(gp->gear_inner, 1);
+ if (glIsList(gp->gear_outer))
+ glDeleteLists(gp->gear_outer, 1);
+
+ }
}
(void) free((void *) gears);
gears = NULL;
}
+ FreeAllGL(mi);
}