void mouse(int button, int state, int x, int y) { if (button == GLUT_LEFT_BUTTON) { if (state == GLUT_DOWN) { glutSetCursor(GLUT_CURSOR_LEFT_RIGHT); moving = 1; begin = x; } else if (state == GLUT_UP) { glutSetCursor(GLUT_CURSOR_INHERIT); moving = 0; } } if (overlaySupport && button == GLUT_MIDDLE_BUTTON) { if (state == GLUT_DOWN) { help = 0; clearHelp = 1; rubberbanding = 1; anchorx = x; anchory = y; stretchx = x; stretchy = y; glutShowOverlay(); } else if (state == GLUT_UP) { rubberbanding = 0; glutHideOverlay(); glutUseLayer(GLUT_NORMAL); glMatrixMode(GL_PROJECTION); glLoadIdentity(); #undef max #undef min #define max(a,b) ((a) > (b) ? (a) : (b)) #define min(a,b) ((a) < (b) ? (a) : (b)) wx = min(anchorx, stretchx); wy = min(H - anchory, H - stretchy); wx2 = max(anchorx, stretchx); wy2 = max(H - anchory, H - stretchy); ww = wx2 - wx; wh = wy2 - wy; if (ww == 0 || wh == 0) { glutUseLayer(GLUT_NORMAL); defaultProjection(); } else { vx2 = wx2 / W * vw + vx; vx = wx / W * vw + vx; vy2 = wy2 / H * vh + vy; vy = wy / H * vh + vy; vw = vx2 - vx; vh = vy2 - vy; glFrustum(vx, vx + vw, vy, vy + vh, 1.0, 40); } glutPostRedisplay(); glMatrixMode(GL_MODELVIEW); } } }
static void Idle(void) { if (overlayInit == GL_FALSE) { glutUseLayer(GLUT_OVERLAY); glClear(GL_COLOR_BUFFER_BIT); /* glColor3f(1.0, 0.0, 0.0);*/ glIndexf( 2.0 ); glBegin(GL_POLYGON); glVertex2i(windW/4-10, windH/4-10); glVertex2i(windW/2-10, windH/4-10); glVertex2i(windW/2-10, windH/2-10); glVertex2i(windW/4-10, windH/2-10); glEnd(); glIndexf( 0.0 ); glBegin(GL_POLYGON); glVertex2i(windW/4, windH/4); glVertex2i(windW/2, windH/4); glVertex2i(windW/2, windH/2); glVertex2i(windW/4, windH/2); glEnd(); glIndexf( 1.0 ); glBegin(GL_POLYGON); glVertex2i(windW/4+10, windH/4+10); glVertex2i(windW/2+10, windH/4+10); glVertex2i(windW/2+10, windH/2+10); glVertex2i(windW/4+10, windH/2+10); glEnd(); glutUseLayer(GLUT_NORMAL); overlayInit = GL_TRUE; } MoveStars(); ShowStars(); if (nitro > 0) { speed = (float)(nitro / 10) + 1.0; if (speed > MAXWARP) { speed = MAXWARP; } if (++nitro > MAXWARP*10) { nitro = -nitro; } } else if (nitro < 0) { nitro++; speed = (float)(-nitro / 10) + 1.0; if (speed > MAXWARP) { speed = MAXWARP; } } glFlush(); if (doubleBuffer) { glutSwapBuffers(); } }
static void render(void) { glutUseLayer(GLUT_NORMAL); render_normal(); if (glutLayerGet(GLUT_HAS_OVERLAY)) { glutUseLayer(GLUT_OVERLAY); render_overlay(); } }
void reshape(int w, int h) { glutUseLayer(GLUT_NORMAL); glViewport(0, 0, w, h); if (on) { glutUseLayer(GLUT_OVERLAY); glViewport(0, 0, w, h); printf("w=%d, h=%d\n", w, h); } }
void reshape(int w, int h) { width = w; height = h; /* Reshape both layers. */ glutUseLayer(GLUT_OVERLAY); glViewport(0, 0, w, h); glutUseLayer(GLUT_NORMAL); glViewport(0, 0, w, h); /* Read back viewport for gluUnProject. */ glGetIntegerv(GL_VIEWPORT, viewport); }
void mouse(int button, int state, int x, int y) { GLdouble objx, objy, objz; gluUnProject(x, height - y, 0.95, modelMatrix, projMatrix, viewport, &objx, &objy, &objz); overlaySphere.x = objx; overlaySphere.y = objy; overlaySphere.z = objz; overlaySphere.material = button; glutUseLayer(GLUT_OVERLAY); glutSetColor(opaque, 2 * matColor[button][0], /* Red. */ 2 * matColor[button][1], /* Green. */ 2 * matColor[button][2]); /* Blue. */ if (state == GLUT_UP) { glutHideOverlay(); if (spheres < MAX_SPHERES) { sphereInfo[spheres] = overlaySphere; sphereInfo[spheres].detail = 25; /* Fine tesselation. */ spheres++; } else { printf("oversphere: Out of spheres.\n"); } glutPostRedisplay(); } else { overlaySphere.detail = 10; /* Coarse tesselation. */ glutShowOverlay(); glutPostOverlayRedisplay(); } }
void display2(void) { glutUseLayer(GLUT_NORMAL); glClear(GL_COLOR_BUFFER_BIT); glFlush(); if (glutLayerGet(GLUT_HAS_OVERLAY)) { glutUseLayer(GLUT_OVERLAY); glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POLYGON); glVertex2f(.2, .28); glVertex2f(.5, .58); glVertex2f(.2, .58); glEnd(); glFlush(); } }
void reshape(int w, int h) { if (overlaySupport) { glutUseLayer(GLUT_OVERLAY); glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, w, 0, h); glScalef(1, -1, 1); glTranslatef(0, -h, 0); glMatrixMode(GL_MODELVIEW); glutUseLayer(GLUT_NORMAL); } glViewport(0, 0, w, h); W = w; H = h; }
static void render_normal(void) { glutUseLayer(GLUT_NORMAL); glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0, 0.0, 1.0); glBegin(GL_POLYGON); glVertex2f(.2, .28); glVertex2f(.5, .58); glVertex2f(.2, .58); glEnd(); glFlush(); }
static void Reshape(int width, int height) { windW = (GLint)width; windH = (GLint)height; glutUseLayer(GLUT_OVERLAY); glViewport(0, 0, windW, windH); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5); glMatrixMode(GL_MODELVIEW); overlayInit = GL_FALSE; glutUseLayer(GLUT_NORMAL); glViewport(0, 0, windW, windH); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5); glMatrixMode(GL_MODELVIEW); }
void overlay_display(void) { printf("overlay_display: damaged=%d\n", glutLayerGet(GLUT_OVERLAY_DAMAGED)); if (on) { glutUseLayer(GLUT_OVERLAY); glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POLYGON); glVertex2f(.2 + x, .2 + y); glVertex2f(.5 + x, .5 + y); glVertex2f(.2 + x, .5 + y); glEnd(); glFlush(); } }
/* 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; } }
void display(void) { printf("normal_display: damaged=%d\n", glutLayerGet(GLUT_NORMAL_DAMAGED)); glutUseLayer(GLUT_NORMAL); glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 0.0, 0.0); glBegin(GL_POLYGON); glVertex2f(.2, .28); glVertex2f(.5, .58); glVertex2f(.2, .58); glEnd(); if (!independent) { overlay_display(); } else { printf("not calling overlay_display\n"); } }
void controlLights(int value) { glutUseLayer(GLUT_NORMAL); switch (value) { case 1: lightZeroSwitch = !lightZeroSwitch; if (lightZeroSwitch) { glEnable(GL_LIGHT0); } else { glDisable(GL_LIGHT0); } break; case 2: lightOneSwitch = !lightOneSwitch; if (lightOneSwitch) { glEnable(GL_LIGHT1); } else { glDisable(GL_LIGHT1); } break; case 3: defaultProjection(); break; case 4: fancy = 1; break; case 5: fancy = 0; wasFancy = 1; break; case 6: if (!rubberbanding) help = 1; glutShowOverlay(); glutPostOverlayRedisplay(); break; } glutPostRedisplay(); }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitWindowSize(300, 300); glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX); if (!glutLayerGet(GLUT_OVERLAY_POSSIBLE)) { printf("UNRESOLVED: need overlays for this test (your window system lacks overlays)\n"); exit(0); } glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); main_win = glutCreateWindow("test17"); if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_OVERLAY) { printf("FAIL: overlay should not be in use\n"); exit(1); } if (glutLayerGet(GLUT_HAS_OVERLAY)) { printf("FAIL: overlay should not exist\n"); exit(1); } if (glutLayerGet(GLUT_TRANSPARENT_INDEX) != -1) { printf("FAIL: transparent pixel of normal plane should be -1\n"); exit(1); } if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) { printf("FAIL: no normal damage yet\n"); exit(1); } if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != -1) { printf("FAIL: no overlay damage status yet\n"); exit(1); } glClearColor(0.0, 1.0, 0.0, 0.0); glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX); /* Small torture test. */ glutEstablishOverlay(); glutRemoveOverlay(); glutEstablishOverlay(); glutEstablishOverlay(); glutShowOverlay(); glutHideOverlay(); glutShowOverlay(); glutRemoveOverlay(); glutRemoveOverlay(); glutEstablishOverlay(); if (glutGet(GLUT_WINDOW_RGBA)) { printf("FAIL: overlay should not be RGBA\n"); exit(1); } glutUseLayer(GLUT_NORMAL); if (!glutGet(GLUT_WINDOW_RGBA)) { printf("FAIL: normal should be RGBA\n"); exit(1); } glutUseLayer(GLUT_OVERLAY); if (glutGet(GLUT_WINDOW_RGBA)) { printf("FAIL: overlay should not be RGBA\n"); exit(1); } if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_NORMAL) { printf("FAIL: overlay should be in use\n"); exit(1); } if (glutLayerGet(GLUT_HAS_OVERLAY) == 0) { printf("FAIL: overlay should exist\n"); exit(1); } if (glutLayerGet(GLUT_TRANSPARENT_INDEX) == -1) { printf("FAIL: transparent pixel should exist\n"); exit(1); } if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) { printf("FAIL: no normal damage yet\n"); exit(1); } if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != 0) { printf("FAIL: no overlay damage yet\n"); exit(1); } transP = glutLayerGet(GLUT_TRANSPARENT_INDEX); glClearIndex(glutLayerGet(GLUT_TRANSPARENT_INDEX)); glutSetColor((transP + 1) % 2, 1.0, 0.0, 1.0); glIndexi((transP + 1) % 2); glutUseLayer(GLUT_NORMAL); if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_OVERLAY) { printf("FAIL: overlay should not be in use\n"); exit(1); } glutDisplayFunc(display); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
/* * Class: gruenewa_opengl_GLUT__ * Method: glutUseLayer * Signature: (I)V */ JNIEXPORT void JNICALL Java_gruenewa_opengl_GLUT_00024_glutUseLayer (JNIEnv * jenv, jobject jobj, jint arg1) { glutUseLayer(arg1); }