#undef FLAT_SHADING
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <GL/gl.h>
#include "gl42ogl.h"
#include "tk.h"
#include "insect.h"
#include "insectco.h"
GLushort ls = 0xaaaa;
unsigned char halftone[] = {
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA,
0x55, 0x55, 0x55, 0x55,
};
GLfloat sdepth = 10.;
float light[3],
phi = PI / 4.0,
theta = PI / 4.0;
GLfloat ctheta = -900, cphi, cvtheta, cvphi;
float fabso (float a );
/* Changes for ECLIPSE 8 bit machine */
/* don't use 7 and 8 for appearances. These are the text standards */
unsigned short ECLIPSE8_RAMP[10] = {4, 5, 6, 8, 9, 10, 11, 12, 13, 14};
GLboolean is_8bit;
short savearray[384];
/** change for new window control */
float halfwinx, halfwiny;
long worgx, worgy;
long wsizex, wsizey;
long pikx, piky;
GLboolean follow;
float px, py;
float light[3];
float cx, cy, cz, cvx, cvy, cvz;
float dmr[6], fr[6];
GLfloat knee[6];
GLfloat hip_phi[6];
GLfloat hip_theta[6];
GLboolean legup[6];
float legx[6], legy[6];
enum {
NOTHING,
FORWARD,
BACKWARD,
LEFT,
MIDDLE
};
short function;
/* mymakerange -- color ramp utilities */
void
mymakerange (unsigned short a, unsigned short b, GLubyte red1, GLubyte red2,
GLubyte green1, GLubyte green2, GLubyte blue1, GLubyte blue2)
{
float i;
int j;
float dr,
dg,
db;
i = (float) (b - a);
dr = (float) (red2 - red1) / i;
dg = (float) (green2 - green1) / i;
db = (float) (blue2 - blue1) / i;
for (j = 0; j <= (int) i; j++)
mapcolor ((unsigned short) j + a,
(short) (dr * (float) j + red1),
(short) (dg * (float) j + green1),
(short) (db * (float) j + blue1));
/* mapcolor ((unsigned short) j + a,
(GLubyte) (dr * (float) j + red1),
(GLubyte) (dg * (float) j + green1),
(GLubyte) (db * (float) j + blue1));
*/
}
/* Set up Eclipse 8 bit color ramp */
void
make_eclipse8_range(unsigned short e_ramp[], int red1, int red2,
int green1, int green2, int blue1, int blue2)
{
int i;
float rinc, ginc, binc;
rinc = (float)(red2 - red1) / (float)ECLIPSE8_NCOLORS;
ginc = (float)(green2 - green1) / (float)ECLIPSE8_NCOLORS;
binc = (float)(blue2 - blue1) / (float)ECLIPSE8_NCOLORS;
for (i = 0; i < ECLIPSE8_NCOLORS; i++) {
mapcolor(e_ramp[i],
(short)(i * rinc + red1),
(short)(i * ginc + green1),
(short)(i * binc + blue1));
}
}
/* setupcolors -- load color map */
/* Changed for ECLIPSE 8 bit machine */
void
setupcolors (void) {
if (!is_8bit) {
mapcolor (GRAY, 128, 128, 128);
mapcolor (GRID, 128, 200, 250);
mapcolor (SKYBLUE, 50, 50, 150);
mymakerange (RAMPB5, RAMPE5, 125, 250, 125, 250, 0, 0);
mymakerange (RAMPB4, RAMPE4, 100, 200, 125, 250, 0, 0);
mymakerange (RAMPB3, RAMPE3, 75, 150, 125, 250, 0, 0);
mymakerange (RAMPB2, RAMPE2, 50, 100, 125, 250, 0, 0);
mymakerange (RAMPB, RAMPE, 25, 50, 125, 250, 0, 0);
} else {
mapcolor (ECLIPSE8_GRAY, 128, 128, 128);
mapcolor (ECLIPSE8_GRID, 128, 200, 250);
mapcolor (ECLIPSE8_SKYBLUE, 50, 50, 150);
/*
mapcolor (BLACK, 0, 0, 0);
mapcolor (COLORS, 255, 0, 0);
mapcolor (COLOR1, 0, 255, 0);
mapcolor (COLOR2, 255, 255, 0);
*/
make_eclipse8_range(ECLIPSE8_RAMP, 25, 250, 125, 250, 0, 0);
}
}
/**** New routines for ECLIPSE 8 bit machine */
/* reduces color index value to the lower 16 indices in the color table
see ECLIPSE8_RAMP[] for which entries are used for ramp */
short
reduce_index (short c)
{
c = c - RAMPB + 4;
while (c > 13)
c -= 10;
if (c > 6)
c++;
return(c);
}
void
getcoords (void)
{
pikx = getvaluator(MOUSEX);
piky = getvaluator(MOUSEY);
if (pikx <= worgx || pikx >= worgx + wsizex ||
piky <= worgy || piky >= worgy + wsizey) {
pikx = worgx + wsizex / 2 + 1;
piky = worgy + wsizey / 2 + 1;
}
}
static void
getMouseCoords (void) {
int x, y;
tkGetMouseLoc (&x, &y);
pikx = x;
piky = wsizey - y;
if ( (pikx < 0) || (pikx > wsizex) ||
(piky < 0) || (piky > wsizey) ) {
pikx = wsizex / 2 + 1;
piky = wsizey / 2 + 1;
}
}
int
l05 (int i)
{
if (i < 0)
return (i + 6);
if (i > 5)
return (i - 6);
return (i);
}
int
sgn (float i)
{
if (i < 0)
return (-1);
if (i > 0)
return (1);
return (0);
}
static void
fixWindow (void) {
halfwinx = (float)wsizex / 2.0;
halfwiny = (float)wsizey / 2.0;
glViewport (0, 0, wsizex, wsizey);
glPopMatrix();
glPushMatrix();
gluPerspective (80, wsizex / (float) wsizey, 0.01, 131072);
}
/* draw_shadow -- draw halftone shape of insect onto the floor */
void
draw_shadow (void) {
int leg;
glPushMatrix ();
glCallList (shadow);
glEnable (GL_POLYGON_STIPPLE);
glTranslatef (px, py, 1.0);
glCallList (body_shadow);
for (leg = 0; leg < 6; leg++) {
glPushMatrix ();
/*
glRotatef ((GLfloat) (-leg * 600), 0, 0, 1);
*/
glRotatef ((GLfloat) (-leg * 60), 0, 0, 1);
glTranslatef (0.0, 0.5, 0.0);
glCallList (hip_shadow);
/*
glRotatef (hip_phi[leg], 0, 0, 1);
glRotatef (hip_theta[leg], 1, 0, 0);
*/
glRotatef (hip_phi[leg] / 10, 0, 0, 1);
glRotatef (hip_theta[leg]/10, 1, 0, 0);
glCallList (thigh_shadow);
glCallList (kneeball_shadow);
glTranslatef (0.0, 1.0, 0.0);
/*
glRotatef (knee[leg], 1, 0, 0);
*/
glRotatef (knee[leg]/10, 1, 0, 0);
glCallList (shin_shadow);
glPopMatrix ();
}
glDisable (GL_POLYGON_STIPPLE);
glPopMatrix ();
}
/* draw_hind -- draw a rear leg. First draw hip, then shin, then thigh
and knee joint */
void
draw_hind (int leg)
{
glPushMatrix ();
/*
glRotatef ((GLfloat) (-leg * 600), 0, 0, 1);
*/
glRotatef ((GLfloat) (-leg * 60), 0, 0, 1);
glTranslatef (0.0, 0.5, 0.0);
glCallList (hip[leg]);
/*
glRotatef (hip_phi[leg], 0, 0, 1);
glRotatef (hip_theta[leg], 1, 0, 0);
*/
glRotatef (hip_phi[leg]/10, 0, 0, 1);
glRotatef (hip_theta[leg]/10, 1, 0, 0);
glPushMatrix (); /* draw thigh */
glTranslatef (0.0, 1.0, 0.0);
/*
glRotatef (knee[leg], 1, 0, 0);
*/
glRotatef (knee[leg]/10, 1, 0, 0);
glCallList (shin[leg]);
glPopMatrix ();
if (cz < -5.0) {
glCallList (kneeball[leg]);
glCallList (thigh[leg]);
}
else {
glCallList (kneeball[leg]);
glCallList (thigh[leg]);
}
glPopMatrix ();
}
/* draw_fore -- draw a front leg. First draw hip, then thigh,
knee joint and finally shin */
void
draw_fore (int leg)
{
glPushMatrix ();
/*
glRotatef ((GLfloat) (-leg * 600), 0, 0, 1);
*/
glRotatef ((GLfloat) (-leg * 60), 0, 0, 1);
glTranslatef (0.0, 0.5, 0.0);
glCallList (hip[leg]);
/*
glRotatef (hip_phi[leg], 0, 0, 1);
glRotatef (hip_theta[leg], 1, 0, 0);
*/
glRotatef (hip_phi[leg]/10, 0, 0, 1);
glRotatef (hip_theta[leg]/10, 1, 0, 0);
glCallList (thigh[leg]);
glCallList (kneeball[leg]);
glTranslatef (0.0, 1.0, 0.0);
/*
glRotatef (knee[leg], 1, 0, 0);
*/
glRotatef (knee[leg]/10, 1, 0, 0);
glCallList (shin[leg]);
glPopMatrix ();
}
/* draw_insect -- draw rear legs, body and forelegs of insect
the order of drawing the objects is important to
insure proper hidden surface elimination -- painter's algorithm */
void
draw_insect (void) {
GLfloat a;
float o;
int order;
o = atan2 (cy + py, cx + px) + PI - (PI / 3.0);
order = l05 ((int) integer (o / (PI / 3.0)));
glPushMatrix (); /* world */
glTranslatef (px, py, 1.0);
draw_hind (l05 (3 - order));
draw_hind (l05 (4 - order));
draw_hind (l05 (2 - order));
glCallList (body);
draw_fore (l05 (5 - order));
draw_fore (l05 (1 - order));
draw_fore (l05 (0 - order));
glPopMatrix ();
}
/* spin_scene -- poll input devices, keyboard and mouse
move eye position based upon user input */
void
spin_scene (void) {
float sin1,
cos1,
sin2,
cos2,
t;
int mx,
my;
/* big change to keep movement relative to window */
/* check if still in window x and y are globals - see getcoords */
/*
getcoords ();
mx = 64 * ((pikx - worgx) - (wsizex / 2)) / wsizex;
my = 64 * ((piky - worgy) - (wsizey / 2)) / wsizey;
*/
getMouseCoords();
mx = 64 * (pikx - (wsizex/2)) / wsizex;
my = 64 * (piky - (wsizey/2)) / wsizey;
/*
mx = (getvaluator (MOUSEX) - 640) / 16;
my = (getvaluator (MOUSEY) - 512) / 16;
*/
switch (function) {
case BACKWARD:
gl_sincos (ctheta, &sin1, &cos1);
gl_sincos (cphi, &sin2, &cos2);
cvz -= cos1;
cvx -= sin2 * sin1;
cvy -= cos2 * sin1;
function = NOTHING;
break;
case FORWARD:
gl_sincos (ctheta, &sin1, &cos1);
gl_sincos (cphi, &sin2, &cos2);
cvz += cos1;
cvx += sin2 * sin1;
cvy += cos2 * sin1;
function = NOTHING;
break;
case LEFT:
cvz = (float) - my;
gl_sincos (cphi, &sin1, &cos1);
cvx = cos1 * (float) (-mx);
cvy = -sin1 * (float) (-mx);
break;
default:
cvx = cvx * 0.7;
cvy = cvy * 0.7;
cvz = cvz * 0.7;
break;
}
if (function == MIDDLE) {
cvtheta = my;
cvphi = mx;
}
else {
cvtheta += -cvtheta / 4;
if ((cvtheta < 4) && (cvtheta > -4))
cvtheta = 0;
cvphi += -cvphi / 4;
if ((cvphi < 4) && (cvphi > -4))
cvphi = 0;
if (function != LEFT) function = NOTHING;
}
cx += cvx * 0.0078125;
cy += cvy * 0.0078125;
if (cz > 0.0) {
cz = 0.0;
cvz = 0.0;
}
else
cz += cvz * 0.0078125;
ctheta += cvtheta;
cphi += cvphi;
}
GLfloat degrees (float a)
{
return ((GLfloat) (a * 1800.0 / PI));
}
void
getstuff (void) {
int x,
y,
i;
int tr;
legup[0] = GL_FALSE;
legup[2] = GL_FALSE;
legup[4] = GL_FALSE;
legup[1] = GL_TRUE;
legup[3] = GL_TRUE;
legup[5] = GL_TRUE;
px = 0.0;
py = 0.0;
for (i = 0; i < 6; i++) {
legx[i] = 30.0 / 2.0 + (float) i;
legy[i] = 30.0 / 2.0 + (float) i;
}
}
void
dolegs (void) {
int i;
float r,
l,
gx,
gy,
k,
t,
a,
ux,
uy;
int leg,
tr;
for (leg = 0; leg < 6; leg++) {
gx = legx[leg] - 30.0 / 2.0;
gy = legy[leg] - 30.0 / 2.0;
ux = gx / (30.0 / 2.0);
uy = gy / (30.0 / 2.0);
switch (leg) {
case 0:
gx += 0.0;
gy += 30.0;
break;
case 1:
gx += (30.0 * 0.8660254);
gy += (30.0 * 0.5);
break;
case 2:
gx += (30.0 * 0.8660254);
gy += (30.0 * -0.5);
break;
case 3:
gx += 0.0;
gy += -30.0;
break;
case 4:
gx += (30.0 * -0.8660254);
gy += (30.0 * -0.5);;
break;
case 5:
gx += (30.0 * -0.8660254);
gy += (30.0 * 0.5);
break;
}
r = sqrt ((gx * gx) + (gy * gy)) / 30.0;
l = sqrt (1.0 + (r * r));
k = acos ((5.0 - (l * l)) / 4.0);
knee[leg] = (GLfloat) degrees (k);
t = (2.0 * sin (k)) / l;
if (t > 1.0)
t = 1.0;
a = asin (t);
if (l < 1.7320508)
a = PI - a;
hip_theta[leg] =
(GLfloat) (degrees (a - atan2 (1.0, r)));
if (gx == 0.0) {
hip_phi[leg] = (GLfloat) (900 * sgn (gy));
}
else {
hip_phi[leg] = (GLfloat) (degrees (atan2 (gy, gx)));
}
hip_phi[leg] += (-900 + 600 * leg);
if (legup[leg]) {
hip_theta[leg] += (GLfloat)
(200.0 * ((fr[leg] / 2.0) - fabso (dmr[leg] - (fr[leg] / 2.0))));
}
}
}
void
move_insect (void) {
register int i;
register float mx,
my,
vx,
vy,
dx,
dy,
dr,
lx,
ly,
lr,
dmx,
dmy;
float s,
c;
/* mx = (float) getvaluator (MOUSEX) / 640.0 - 1.0;
my = (float) getvaluator (MOUSEY) / 512.0 - 1.0;
*/
/* changed to keep input within the window.
x and y are globals - see getcoords */
/*
getcoords ();
mx = ((float)pikx - (float)worgx) / halfwinx - 1.0;
my = ((float)piky - (float)worgy) / halfwiny - 1.0;
*/
getMouseCoords();
mx = pikx / halfwinx - 1.0;
my = piky / halfwiny - 1.0;
gl_sincos (cphi, &s, &c);
dx = mx * c + my * s;
dy = -mx * s + my * c;
mx = dx;
my = dy;
px += mx / (float) (RES);
py += my / (float) (RES);
if (follow) {
cx -= mx / (float) (RES);
cy -= my / (float) (RES);
}
dr = sqrt (mx * mx + my * my);
dx = mx / dr;
dy = my / dr;
for (i = 0; i < 6; i++) {
lx = legx[i] - (float) (RES / 2);
ly = legy[i] - (float) (RES / 2);
lr = (float) (RES / 2);
lx = lx / lr;
ly = ly / lr;
dmx = (dx - lx);
dmy = (dy - ly);
dmr[i] = sqrt (dmx * dmx + dmy * dmy);
if (legup[i]) {
dmx = 3 * dr * dmx / dmr[i];
dmy = 3 * dr * dmy / dmr[i];
legx[i] += dmx;
legy[i] += dmy;
if ((dmr[i]) < 0.15) {
legup[i] = GL_FALSE;
}
}
else {
legx[i] -= mx;
legy[i] -= my;
if (!legup[l05 (i - 1)] && !legup[l05 (i + 1)] &&
(dmr[i] > REACH) &&
((lx * dx + ly * dy) < 0.0)) {
legup[i] = GL_TRUE;
fr[i] = dmr[i];
legx[i] += dmx;
legy[i] += dmy;
}
}
}
}
void
rotate60 (char c, int n, GLfloat a[][3])
{
int i,
j,
l;
float nx,
ny;
switch (c) {
case 'z':
i = 0;
j = 1;
break;
case 'y':
i = 2;
j = 0;
break;
case 'x':
i = 1;
j = 2;
break;
};
for (l = 0; l < n; l++) {
nx = a[l][i] * COS60 - a[l][j] * SIN60;
ny = a[l][i] * SIN60 + a[l][j] * COS60;
a[l][i] = nx;
a[l][j] = ny;
}
}
void
getpolycolor (int p, float pts[][3])
{
float norm[3];
float v1[3],
v2[3],
cons;
int i,
get;
float c;
for (i = 0; i < 3; i++)
norm[i] = 0.0;
i = 0;
get = 1;
i = 1;
v1[0] = pts[1][0] - pts[0][0];
v1[1] = pts[1][1] - pts[0][1];
v1[2] = pts[1][2] - pts[0][2];
v2[0] = pts[2][0] - pts[0][0];
v2[1] = pts[2][1] - pts[0][1];
v2[2] = pts[2][2] - pts[0][2];
norm[0] = v1[1] * v2[2] - v1[2] * v2[1];
norm[1] = v1[2] * v2[0] - v1[0] * v2[2];
norm[2] = v1[0] * v2[1] - v1[1] * v2[0];
cons = sqrt ((norm[0] * norm[0]) +
(norm[1] * norm[1]) + (norm[2] * norm[2]));
for (i = 0; i < 3; i++)
norm[i] = norm[i] / cons;
c = dot (norm, light);
if (c < 0.0)
c = 0.0;
if (c > 1.0)
c = 1.0;
switch (p) {
case 0:
c = (float) (RAMPE - RAMPB) * c + (float) (RAMPB);
if (((unsigned short) c) > RAMPE) c = (float) RAMPE;
#ifdef FLAT_SHADING
c = COLOR1;
#endif
break;
case 1:
c = (float) (RAMPE2 - RAMPB2) * c + (float) (RAMPB2);
if (((unsigned short) c) > RAMPE2) c = (float) RAMPE2;
#ifdef FLAT_SHADING
c = COLOR2;
#endif
break;
case 2:
c = (float) (RAMPE3 - RAMPB3) * c + (float) (RAMPB3);
if (((unsigned short) c) > RAMPE3) c = (float) RAMPE3;
#ifdef FLAT_SHADING
c = COLOR2;
#endif
break;
case 3:
c = (float) (RAMPE4 - RAMPB4) * c + (float) (RAMPB4);
if (((unsigned short) c) > RAMPE4) c = (float) RAMPE4;
#ifdef FLAT_SHADING
c = COLOR2;
#endif
break;
case 4:
c = (float) (RAMPE5 - RAMPB5) * c + (float) (RAMPB5);
if (((unsigned short) c) > RAMPE5) c = (float) RAMPE5;
#ifdef FLAT_SHADING
c = COLOR2;
#endif
break;
}
/* Changed for 8 bit ECLIPSE machine */
if (is_8bit)
c = (float)reduce_index((int)c);
glIndexi (c);
}
GLboolean
lit (int p, float pts[][3])
{
float norm[3];
float v1[3],
v2[3],
cons;
int i,
get;
float c;
for (i = 0; i < 3; i++)
norm[i] = 0.0;
i = 0;
get = 1;
i = 1;
v1[0] = pts[1][0] - pts[0][0];
v1[1] = pts[1][1] - pts[0][1];
v1[2] = pts[1][2] - pts[0][2];
v2[0] = pts[2][0] - pts[0][0];
v2[1] = pts[2][1] - pts[0][1];
v2[2] = pts[2][2] - pts[0][2];
norm[0] = v1[1] * v2[2] - v1[2] * v2[1];
norm[1] = v1[2] * v2[0] - v1[0] * v2[2];
norm[2] = v1[0] * v2[1] - v1[1] * v2[0];
cons = sqrt ((norm[0] * norm[0]) +
(norm[1] * norm[1]) + (norm[2] * norm[2]));
for (i = 0; i < 3; i++)
norm[i] = norm[i] / cons;
c = dot (norm, light);
return (c > 0.0);
}
float dot (float vec1[3], float vec2[3])
{
float xx;
xx = (vec1[1] * vec2[1])
+ (vec1[2] * vec2[2])
+ (vec1[0] * vec2[0]);
return ((float) xx);
}
void
getlightvector (void) {
float f;
light[2] = cos (theta);
f = sin (theta);
light[1] = -sin (phi) * f;
light[0] = -cos (phi) * f;
}
float integer (float x)
{
if (x < 0.0)
x -= 1.0;
x = (float) (int) x;
return (x);
}
float frac (float x)
{
return (x - integer (x));
}
float
fabso (float x)
{
if (x < 0.0)
return (-x);
else
return (x);
}
void
drawAll (void) {
/* new for ECLIPSE 8 bit version */
if (is_8bit)
glClearIndex (ECLIPSE8_SKYBLUE);
else
glClearIndex (SKYBLUE);
glClear (GL_COLOR_BUFFER_BIT);
glPushMatrix();
doViewit();
glCallList (screen);
draw_shadow();
draw_insect();
glPopMatrix();
}
static void Reshape(int width, int height)
{
wsizex = width;
wsizey = height;
fixWindow();
}
static GLenum Key(int key, GLenum mask)
{
switch (key) {
case TK_ESCAPE:
tkQuit();
break;
case TK_A:
case TK_a:
function = FORWARD;
break;
case TK_Z:
case TK_z:
function = BACKWARD;
break;
case TK_F:
case TK_f:
follow = !follow;
break;
default:
return GL_FALSE;
}
return GL_TRUE;
}
static GLenum MouseUp(int mouseX, int mouseY, GLenum button)
{
switch (button) {
case TK_LEFTBUTTON:
function = NOTHING;
break;
case TK_MIDDLEBUTTON:
function = NOTHING;
break;
default:
return GL_FALSE;
}
return GL_TRUE;
}
static GLenum MouseDown(int mouseX, int mouseY, GLenum button)
{
switch (button) {
case TK_LEFTBUTTON:
function = LEFT;
break;
case TK_MIDDLEBUTTON:
function = MIDDLE;
break;
default:
return GL_FALSE;
}
return GL_TRUE;
}
static void animate (void) {
spin_scene();
move_insect();
dolegs();
drawAll();
tkSwapBuffers();
}
/* main routine -- handle tokens of window manager
-- display shadow and insect
*/
void
main (int argc, char *argv[]) {
int i,
j,
k;
short dev,
val;
long nplanes;
GLboolean attached;
follow = GL_TRUE;
wsizex = 500;
wsizey = 400;
worgx = 252;
worgy = 184;
tkInitPosition(0, 0, wsizex, wsizey);
tkInitDisplayMode(TK_INDEX|TK_DOUBLE|TK_DIRECT|TK_DEPTH16);
if (tkInitWindow("Insect") == GL_FALSE) {
tkQuit();
}
glPolygonStipple ((unsigned char *) halftone);
glShadeModel(GL_FLAT);
getlightvector ();
/* Changes for ECLIPSE 8 bit machine */
/*
* Machines with enough bitplanes will use colormap entries CMAPSTART
* to CMAPSTART+127. If the machine doesn't have enough bitplanes,
* only colors 0 to 15 will be used (it is assumed that all machines
* have at least 4 bitplanes in colormap double-buffered mode).
*/
#ifdef ECLIPSE
nplanes = glGetI(GD_BITS_NORM_DBL_CMODE);
/* save color map in savearray */
if ((1<<nplanes) > (CMAPSTART+127)) {
is_8bit = GL_FALSE;
}
else {
is_8bit = GL_TRUE;
}
#else
nplanes = 4;
is_8bit = GL_TRUE;
#endif
setupcolors ();
/* initialize transformation stuff */
cx = 0.0;
cy = 10.0;
cz = -2.0;
cvx = cvy = cvz = 0.0;
ctheta = -900;
cphi = 0;
cvtheta = cvphi = 0.0;
function = NOTHING;
glPushMatrix();
fixWindow();
createobjects ();
getstuff ();
spin_scene ();
move_insect ();
dolegs ();
tkExposeFunc(Reshape);
tkReshapeFunc(Reshape);
tkKeyDownFunc(Key);
tkMouseDownFunc(MouseDown);
tkMouseUpFunc(MouseUp);
tkIdleFunc(animate);
tkExec();
glPopMatrix();
}