static void
move_on(void)
{
display_count++;
if (display_count == 2) {
damage_expectation = 1;
glutIconifyWindow();
glutTimerFunc(500, timer, 777);
}
if (display_count == 4) {
printf("display_count == 4\n");
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateSubWindow(main_win, 10, 10, 150, 150);
glClearColor(0.5, 0.5, 0.5, 0.0);
glutDisplayFunc(render_sub);
glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
glutEstablishOverlay();
glutCopyColormap(main_win);
glutSetColor((transP + 1) % 2, 0.0, 1.0, 1.0);
glutRemoveOverlay();
glutEstablishOverlay();
glutCopyColormap(main_win);
glutCopyColormap(main_win);
glutSetColor((transP + 1) % 2, 1.0, 1.0, 1.0);
glClearIndex(transP);
glIndexf((transP + 1) % 2);
glutSetWindow(main_win);
glutRemoveOverlay();
glutTimerFunc(500, time2, 888);
}
}
static void Init(void)
{
GLint i;
if (!rgb) {
glutSetColor(0, 0.0, 0.0, 0.0);
glutSetColor(1, 1.0, 0.0, 0.0);
glutSetColor(2, 0.0, 1.0, 0.0);
glutSetColor(3, 1.0, 1.0, 0.0);
glutSetColor(4, 0.0, 0.0, 1.0);
glutSetColor(5, 1.0, 0.0, 1.0);
glutSetColor(6, 0.0, 1.0, 1.0);
glutSetColor(7, 1.0, 1.0, 1.0);
}
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearIndex(0.0);
glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
for (i = 0; i < 7; i++) {
exp_lists[i] = glGenLists(1);
glNewList(exp_lists[i], GL_COMPILE);
glBitmap(80, 80, 40.0, 40.0, 0.0, 0.0, exp_bits[i]);
glEndList();
}
abuse = GL_FALSE;
useLists = GL_TRUE;
}
GLvoid TOpenGL_Form::initializeGL(GLsizei width, GLsizei height)
{
GLfloat maxObjectSize, aspect;
GLdouble near_plane;
glClearIndex( (GLfloat)BLACK_INDEX);
glClearDepth( 1.0 );
glEnable(GL_DEPTH_TEST);
glMatrixMode( GL_PROJECTION );
aspect = (GLfloat) width / height;
gluPerspective( 45.0, aspect, 3.0, 7.0 );
glMatrixMode( GL_MODELVIEW );
near_plane = 3.0;
maxObjectSize = 3.0F;
radius = near_plane + maxObjectSize/2.0;
latitude = 0.0F;
longitude = 0.0F;
latinc = 6.0F;
longinc = 2.5F;
createObjects();
}
void
init(void)
{
int i;
tbInit(GLUT_MIDDLE_BUTTON);
tbAnimate(GL_FALSE);
/* create initial display lists */
lists();
/* lighting */
glDisable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glutSetColor(NUMCOLORS+1, 0.0, 0.0, 0.0);
glClearIndex(NUMCOLORS+1);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
}
static void Init(void)
{
cursor = 0;
glutSetCursor(cursor);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearIndex(0.0);
}
void
ReadPixSanityTest::checkIndex(ReadPixSanityResult& r, Window& w) {
DrawingSurfaceConfig& config = *r.config;
RandomBits iRand(config.bufSize, 2);
r.passIndex = true;
for (int i = 0; i < 100 && r.passIndex; ++i) {
GLuint expected = iRand.next();
glClearIndex(expected);
glClear(GL_COLOR_BUFFER_BIT);
GLuint buf[READPIX_SANITY_WIN_SIZE][READPIX_SANITY_WIN_SIZE];
glReadPixels(0, 0, READPIX_SANITY_WIN_SIZE,
READPIX_SANITY_WIN_SIZE, GL_COLOR_INDEX,
GL_UNSIGNED_INT, buf);
for (int y = 0; y < READPIX_SANITY_WIN_SIZE && r.passIndex; ++y)
for (int x = 0; x < READPIX_SANITY_WIN_SIZE; ++x)
if (buf[y][x] != expected) {
r.passIndex = false;
r.xIndex = x;
r.yIndex = y;
r.expectedIndex = expected;
r.actualIndex = buf[y][x];
break;
}
w.swap();
}
} // ReadPixSanityTest::checkIndex
void
init(void)
{
GLfloat matDiff[4] = { 0.65F, 0.05F, 0.20F, 0.60F };
GLfloat matSpec[4] = { 0.50F, 0.50F, 0.50F, 1.00F };
GLfloat matShine = 20.00F;
GLint indexes[3];
GLfloat light0Pos[4] = { 0.70F, 0.70F, 1.25F, 0.00F };
glClearColor(colors[2].diff[0], colors[2].diff[1], colors[2].diff[2], 1.0F);
glClearIndex((GLfloat) colors[2].indexes[1]);
setProjection();
glTranslatef(0.0F, 0.0F, -2.0F);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, matDiff);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, matShine);
indexes[0] = 0;
indexes[1] = colors[0].indexes[1] - colors[0].indexes[0];
indexes[2] = colors[0].indexes[2] - colors[0].indexes[0];
glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, indexes);
glLightfv(GL_LIGHT0, GL_POSITION, light0Pos);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
setCheckTexture();
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
}
int
main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("zoomdino");
glutDisplayFunc(redraw);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutCreateMenu(controlLights);
glutAddMenuEntry("Toggle right light", 1);
glutAddMenuEntry("Toggle left light", 2);
glutAttachMenu(GLUT_RIGHT_BUTTON);
makeDinosaur();
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
defaultProjection();
gluLookAt(0.0, 0.0, 30.0, /* eye is at (0,0,30) */
0.0, 0.0, 0.0, /* center is at (0,0,0) */
0.0, 1.0, 0.); /* up is in postivie Y direction */
glPushMatrix(); /* dummy push so we can pop on model
recalc */
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor);
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05);
glLightfv(GL_LIGHT1, GL_POSITION, lightOnePosition);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightOneColor);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
overlaySupport = glutLayerGet(GLUT_OVERLAY_POSSIBLE);
if (overlaySupport) {
glutEstablishOverlay();
glutHideOverlay();
transparent = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transparent);
red = (transparent + 1) % glutGet(GLUT_WINDOW_COLORMAP_SIZE);
white = (transparent + 2) % glutGet(GLUT_WINDOW_COLORMAP_SIZE);
glutSetColor(red, 1.0, 0.0, 0.0); /* Red. */
glutSetColor(white, 1.0, 1.0, 1.0); /* White. */
glutOverlayDisplayFunc(redrawOverlay);
glutReshapeFunc(reshape);
glutSetWindowTitle("zoomdino with rubber-banding");
glutAddMenuEntry("------------------", 0);
glutAddMenuEntry("Reset projection", 3);
glutAddMenuEntry("------------------", 0);
glutAddMenuEntry("Fancy rubber-banding", 4);
glutAddMenuEntry("Simple rubber-banding", 5);
glutAddMenuEntry("------------------", 0);
glutAddMenuEntry("Show help", 6);
} else {
printf("Sorry, no whizzy zoomdino overlay usage!\n");
}
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
static void hugsprim_glClearIndex_7(HugsStackPtr hugs_root)
{
HsFloat arg1;
arg1 = hugs->getFloat();
glClearIndex(arg1);
hugs->returnIO(hugs_root,0);
}
void MAOpenGLInitCb(
Widget w,
XtPointer clientData,
XtPointer callData)
{
static String xFontStr = "-*-courier-*-*-*-*-14-*-*-*-*-*-*-*";
Font xFont;
WlzDVertex3 tVtx, orgVtx;
Display *dpy = XtDisplay( w );
(void )HGUglwCreateCanvasGlxContext(w, NULL);
HGUglwCanvasGlxMakeCurrent(w, NULL);
xFont = XLoadFont(XtDisplay(w), xFontStr);
if(xFont)
{
threeDFont = HGUglTextFontCreate(xFont);
}
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
if( globals.toplDepth == 24 ){
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_FOG);
glFogf(GL_FOG_MODE, GL_LINEAR);
}
else {
glClearIndex( (GLfloat) BlackPixelOfScreen(XtScreen(w)) );
}
/* set the initial transform - should be from resources */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotated( (GLdouble) 90.0, (GLdouble) 1.0, (GLdouble) 0.0, (GLdouble) 0.0);
glRotated((GLdouble) -40.0, (GLdouble) 0.0, (GLdouble) 0.0, (GLdouble) 1.0);
glRotated( (GLdouble) 20.0, (GLdouble) 0.6, (GLdouble) 0.4, (GLdouble) 0.0);
glGetDoublev(GL_MODELVIEW_MATRIX, &initial_rot[0][0]);
/* create the default 3D display DisplayList */
globals.ref_display_list = glGenLists( (GLsizei) 1 );
glNewList( globals.ref_display_list, GL_COMPILE );
WLZ_VTX_3_SET(tVtx, 10.0, 10.0, 10.0);
WLZ_VTX_3_SET(orgVtx, 5.0, 5.0, 5.0);
if( globals.toplDepth == 24 ){
glColor3d((GLdouble) 1.0, (GLdouble) 1.0, (GLdouble) 1.0);
}
else {
glIndexi( HGU_XGetColorPixel(dpy, globals.cmap, 1.0, 1.0, 1.0) );
}
HGUglShapeWireCube(tVtx, orgVtx);
glEndList();
WLZ_VTX_3_SET(globals.bbox_vtx, -2.0, -2.0, -2.0);
WLZ_VTX_3_SET(globals.bbox_size, 14.0, 14.0, 14.0);
return;
}
/* Clears the current window to the given color index */
void utilClearWindow(int index)
{
glClearIndex(index);
/* DNM: need to set clear colors for rgb mode */
if (App->rgba) {
QColor qcol = ImodPrefs->namedColor(index);
glClearColor(qcol.red()/255., qcol.green()/255. , qcol.blue()/255., 0.);
}
glClear(GL_COLOR_BUFFER_BIT);
}
void QGLWidget::qglClearColor( const QColor& c ) const
{
const QGLContext* ctx = QGLContext::currentContext();
if ( ctx ) {
if ( ctx->format().rgba() )
glClearColor( (GLfloat)c.red() / 255.0, (GLfloat)c.green() / 255.0,
(GLfloat)c.blue() / 255.0, (GLfloat) 0.0 );
else
glClearIndex( ctx->colorIndex( c ) );
}
}
int
main(int argc, char **argv)
{
glutInitWindowSize(350, 350);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("Overlay Sphere Positioning Demo");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE); /* Solid spheres benefit greatly
from back face culling. */
setupMatrices();
/* Read back matrices for use by gluUnProject. */
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
/* Set up lighting. */
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiff);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpec);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glutInitDisplayMode(GLUT_INDEX | GLUT_SINGLE);
if (glutLayerGet(GLUT_OVERLAY_POSSIBLE) == 0) {
printf("oversphere: no overlays supported; aborting.\n");
exit(1);
}
glutEstablishOverlay();
glutHideOverlay();
glutOverlayDisplayFunc(overlayDisplay);
/* Find transparent and opaque index. */
transparent = glutLayerGet(GLUT_TRANSPARENT_INDEX);
opaque = (transparent + 1)
% glutGet(GLUT_WINDOW_COLORMAP_SIZE);
/* Draw overlay sphere as an outline. */
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
/* Make sure overlay clears to transparent. */
glClearIndex(transparent);
/* Set up overlay matrices same as normal plane. */
setupMatrices();
glutMainLoop();
return 0;
}
/* Initialize point antialiasing for color index mode,
* including loading a grey color ramp starting at
* RAMPSTART, which must be a multiple of 16.
*/
void myinit(void)
{
int i;
for (i = 0; i < RAMPSIZE; i++) {
GLfloat shade;
shade = (GLfloat) i/(GLfloat) RAMPSIZE;
auxSetOneColor (RAMPSTART+(GLint)i, shade, shade, shade);
}
glEnable (GL_POINT_SMOOTH);
glHint (GL_POINT_SMOOTH_HINT, GL_FASTEST);
glPointSize (3.0);
glClearIndex ((GLfloat) RAMPSTART);
}
UGL_LOCAL void initGL (void)
{
uglMesaSetColor(BLACK, 0.0, 0.0, 0.0);
uglMesaSetColor(RED, 1.0, 0.3, 0.3);
uglMesaSetColor(GREEN, 0.3, 1.0, 0.3);
uglMesaSetColor(BLUE, 0.3, 0.3, 1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearIndex(BLACK);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
int
main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB);
main_w = glutCreateWindow("test9");
glClearColor(0.0, 0.0, 0.0, 0.0); /* black */
glutDisplayFunc(display);
glutInitDisplayMode(GLUT_INDEX);
if (!glutGet(GLUT_DISPLAY_MODE_POSSIBLE)) {
printf("UNRESOLVED: test9 (your OpenGL lacks color index support)\n");
exit(0);
}
w1 = glutCreateSubWindow(main_w, 10, 10, 10, 10);
glutSetColor(1, 1.0, 0.0, 0.0); /* red */
glutSetColor(2, 0.0, 1.0, 0.0); /* green */
glutSetColor(3, 0.0, 0.0, 1.0); /* blue */
glClearIndex(1);
glutDisplayFunc(display);
w2 = glutCreateSubWindow(main_w, 30, 30, 10, 10);
glutCopyColormap(w1);
glClearIndex(2);
glutDisplayFunc(display);
w3 = glutCreateSubWindow(main_w, 50, 50, 10, 10);
glutCopyColormap(w1);
glClearIndex(3);
glutDisplayFunc(display);
w4 = glutCreateSubWindow(main_w, 70, 70, 10, 10);
glutCopyColormap(w1);
glutSetColor(3, 1.0, 1.0, 1.0); /* white */
glClearIndex(3);
glutDisplayFunc(display);
glutTimerFunc(750, time1, 0);
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
static void Init(void)
{
static float ambient[] = {0.1, 0.1, 0.1, 1.0};
static float diffuse[] = {1.0, 1.0, 1.0, 1.0};
static float position[] = {90.0, 90.0, 0.0, 0.0};
static float front_mat_shininess[] = {30.0};
static float front_mat_specular[] = {0.0, 0.0, 0.0, 1.0};
static float front_mat_diffuse[] = {0.0, 1.0, 0.0, 1.0};
static float back_mat_shininess[] = {50.0};
static float back_mat_specular[] = {0.0, 0.0, 1.0, 1.0};
static float back_mat_diffuse[] = {1.0, 0.0, 0.0, 1.0};
static float lmodel_ambient[] = {0.0, 0.0, 0.0, 1.0};
static float fog_color[] = {0.8, 0.8, 0.8, 1.0};
glFrontFace(GL_CW);
glEnable(GL_DEPTH_TEST);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);
glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, fogDensity);
if (rgb) {
glFogfv(GL_FOG_COLOR, fog_color);
glClearColor(0.8, 0.8, 0.8, 1.0);
} else {
glFogi(GL_FOG_INDEX, 1<<5);
SetFogRamp(5, 3);
glClearIndex(128);
}
Build_lists();
}
static void
init(void)
{
GLint i, j;
GLfloat f;
glIndexFuncSGIptr = (void *) wglGetProcAddress("glIndexFuncSGI");
if (!glIndexFuncSGIptr) {
printf("Note: renderer doesn't support GL_SGI_index_func extension.\n");
}
setPaletteIndex( 10, 0.0F, 0.5F, 0.5F );
glClearIndex( 10.0f );
for (i=11;i<240;i++) {
GLfloat t = (GLfloat) (i-11) / (GLfloat) (240-11);
setPaletteIndex( i, t, t, 0.0F );
}
Image = (GLubyte *) malloc( 32*32*sizeof(GLubyte) );
for (i = 0; i < 32; i++)
for (j = 0; j < 32; j++) {
double d;
d = sqrt((i - 16) * (i - 16) + (j - 16) * (j - 16)) / 23.0;
Image[(32 * i) + j] = 11 + (int)((240 - 11) * d);
}
#ifdef GL_SGI_index_func
if (glIndexFuncSGIptr) {
/* Sanity checks */
glEnable( GL_INDEX_TEST_SGI );
(*glIndexFuncSGIptr)( GL_GEQUAL, 10.0F );
glPushAttrib( GL_COLOR_BUFFER_BIT );
glDisable( GL_INDEX_TEST_SGI );
(*glIndexFuncSGIptr)( GL_LESS, 99.0F );
glPopAttrib();
assert( glIsEnabled(GL_INDEX_TEST_SGI) );
glGetIntegerv( GL_INDEX_TEST_FUNC_SGI, &i );
assert( i==GL_GEQUAL );
glGetFloatv( GL_INDEX_TEST_REF_SGI, &f );
assert( f==10.0f );
}
#endif
checkError("after init");
}
/* Initialize antialiasing for color index mode,
* including loading a green color ramp starting
* at RAMP1START, and a blue color ramp starting
* at RAMP2START. The ramps must be a multiple of 16.
*/
static void init(void)
{
int i;
for (i = 0; i < RAMPSIZE; i++) {
GLfloat shade;
shade = (GLfloat) i/(GLfloat) RAMPSIZE;
glutSetColor(RAMP1START+(GLint)i, 0., shade, 0.);
glutSetColor(RAMP2START+(GLint)i, 0., 0., shade);
}
glEnable (GL_LINE_SMOOTH);
glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glLineWidth (1.5);
glClearIndex ((GLfloat) RAMP1START);
}
static void init(void) {
int i;
glEnable(GL_DEPTH_TEST);
for (i=0; i<NUMCOLORS; i++) {
GLfloat shade;
shade = (GLfloat)(NUMCOLORS - i)/(GLfloat)NUMCOLORS;
glutSetColor(RAMPSTART + i, shade, shade, shade);
}
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogi(GL_FOG_INDEX, NUMCOLORS);
glFogi(GL_FOG_START, 1.0);
glFogf(GL_FOG_END, 6.0);
glHint(GL_FOG_HINT, GL_NICEST);
glClearIndex((GLfloat)(NUMCOLORS+RAMPSTART-1));
}
/* ARGSUSED1 */
void
key2(unsigned char c, int w, int h)
{
int transP;
printf("c=%d\n", c);
switch (c) {
case 'g':
glutReshapeWindow(
glutGet(GLUT_WINDOW_WIDTH) + 2, glutGet(GLUT_WINDOW_HEIGHT) + 2);
break;
case 's':
glutReshapeWindow(
glutGet(GLUT_WINDOW_WIDTH) - 2, glutGet(GLUT_WINDOW_HEIGHT) - 2);
break;
case 'u':
glutPopWindow();
break;
case 'd':
glutPushWindow();
break;
case 'e':
glutEstablishOverlay();
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transP);
glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
glIndexi((transP + 1) % 2);
break;
case 'c':
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
glutUseLayer(GLUT_OVERLAY);
glutCopyColormap(main_w);
}
break;
case 'r':
glutRemoveOverlay();
break;
case ' ':
printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE));
printf("layer in use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE));
printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY));
printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX));
break;
}
}
/* Initialize antialiasing for color index mode,
* including loading a grey color ramp starting
* at RAMPSTART, which must be a multiple of 16.
*/
void myinit(void)
{
int i;
for (i = 0; i < RAMPSIZE; i++) {
GLfloat shade;
shade = (GLfloat) i/(GLfloat) RAMPSIZE;
auxSetOneColor(RAMPSTART+(GLint)i, shade, shade, shade);
}
glEnable (GL_LINE_SMOOTH);
glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glLineWidth (1.5);
glClearIndex ((GLfloat) RAMPSTART);
glShadeModel(GL_FLAT);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
}
static void Init(void)
{
GLint i;
if (!rgb) {
for (i = 0; i < 16; i++) {
glutSetColor(i+CI_OFFSET_1, 0.0, 0.0, i/15.0);
glutSetColor(i+CI_OFFSET_2, 0.0, i/15.0, 0.0);
}
}
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearIndex(0.0);
glPolygonStipple(stippleBits);
antiAlias = GL_FALSE;
stipple = GL_FALSE;
}
/*
* Togl widget display callback. This is called by Tcl/Tk when the widget's
* contents have to be redrawn. Typically, we clear the color and depth
* buffers, render our objects, then swap the front/back color buffers.
*/
void
display_cb(Togl *togl)
{
glClearIndex(black);
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.3, -0.3, 0.0);
glRotatef(Angle, 0.0, 0.0, 1.0);
glIndexi(red);
glBegin(GL_TRIANGLES);
glVertex2f(-0.5, -0.3);
glVertex2f(0.5, -0.3);
glVertex2f(0.0, 0.6);
glEnd();
glPopMatrix();
glPushMatrix();
glRotatef(Angle, 0.0, 0.0, 1.0);
glIndexi(green);
glBegin(GL_TRIANGLES);
glVertex2f(-0.5, -0.3);
glVertex2f(0.5, -0.3);
glVertex2f(0.0, 0.6);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(-0.3, 0.3, 0.0);
glRotatef(Angle, 0.0, 0.0, 1.0);
glIndexi(blue);
glBegin(GL_TRIANGLES);
glVertex2f(-0.5, -0.3);
glVertex2f(0.5, -0.3);
glVertex2f(0.0, 0.6);
glEnd();
glPopMatrix();
glFlush();
Togl_SwapBuffers(togl);
}
void
s2_menu(int option)
{
int transP;
switch (option) {
case 1:
glutRemoveOverlay();
break;
case 2:
glutEstablishOverlay();
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transP);
glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
glIndexi((transP + 1) % 2);
break;
case 666:
exit(0);
break;
}
}
void initDisplay( ){
/* Perspective projection parameters */
pD.fieldOfView = 45.0;
pD.aspect = (float)IMAGE_WIDTH/IMAGE_HEIGHT;
pD.nearPlane = 0.1;
pD.farPlane = 50.0;
/* setup context */
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
gluPerspective( pD.fieldOfView, pD.aspect, pD.nearPlane, pD.farPlane );
glEnable( GL_DEPTH_TEST );
glDisable( GL_CULL_FACE );
glClearColor( 0.0, 0.0, 0.0, 1.0 );
glClearIndex( 0 );
glClearDepth( 1 );
glMatrixMode( GL_MODELVIEW );
}
void
myinit(void)
{
int i;
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
for (i = 0; i < NUM_COLORS; i++) {
GLfloat shade;
shade = (GLfloat) (NUM_COLORS - i) / (GLfloat) NUM_COLORS;
glutSetColor(16 + i, shade, shade, shade);
}
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogi(GL_FOG_INDEX, NUM_COLORS);
glFogf(GL_FOG_START, 0.0);
glFogf(GL_FOG_END, 4.0);
glHint(GL_FOG_HINT, GL_NICEST);
glClearIndex((GLfloat) (NUM_COLORS + RAMPSTART - 1));
}
static void display_loop( void )
{
GLfloat xrot, yrot, zrot;
xrot = yrot = zrot = 0.0;
glClearColor( 0.0, 0.0, 0.0, 0.0 );
glClearIndex( Black );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glFrustum( -1.0, 1.0, -1.0, 1.0, 1.0, 10.0 );
glTranslatef( 0.0, 0.0, -5.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glCullFace( GL_BACK );
glEnable( GL_CULL_FACE );
glShadeModel( GL_FLAT );
while (1) {
glClear( GL_COLOR_BUFFER_BIT );
glPushMatrix();
glRotatef( xrot, 1.0, 0.0, 0.0 );
glRotatef( yrot, 0.0, 1.0, 0.0 );
glRotatef( zrot, 0.0, 0.0, 1.0 );
draw_cube();
glPopMatrix();
glFinish();
xrot += 10.0;
yrot += 7.0;
zrot -= 3.0;
}
}
/* Initialize material property, light source, and lighting model.
*/
void myinit(void)
{
GLint i;
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
GLfloat mat_colormap[] = { 16.0, 48.0, 79.0 };
GLfloat mat_shininess[] = { 10.0 };
glMaterialfv(GL_FRONT, GL_COLOR_INDEXES, mat_colormap);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
for (i = 0; i < 32; i++) {
auxSetOneColor (16 + i, 1.0 * (i/32.0), 0.0, 1.0 * (i/32.0));
auxSetOneColor (48 + i, 1.0, 1.0 * (i/32.0), 1.0);
}
glClearIndex(0);
}
///////////////////////////////////////////////////////////////////////////
// Initialize OpenGL State Setting for blending & texture mapping /////////
///////////////////////////////////////////////////////////////////////////
static void Init(void)
{
/* one-time init (clearColor, set palette, etc) */
glClearIndex(0.0);
glShadeModel(GL_FLAT);
if(_background)
{
glPixelStorei(GL_PACK_ALIGNMENT, 4);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, _teximageWidth,
_teximageHeight, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)_teximage);
}
// enable the alpha channel
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
_timeout = rand()%20;
}
