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); } }
bool GLUTBackendCreateWindow(unsigned int Width, unsigned int Height, unsigned int bpp, bool isFullScreen, const char* pTitle) { if (isFullScreen) { char ModeString[64] = { 0 }; #ifdef WIN32 _snprintf_s(ModeString, sizeof(ModeString), "%dx%d@%d", Width, Height, bpp); #else snprintf(ModeString, sizeof(ModeString), "%dx%d@%d", Width, Height, bpp); #endif glutGameModeString(ModeString); glutEnterGameMode(); } else { glutInitWindowSize(Width, Height); glutCreateWindow(pTitle); } // Must be done after glut is initialized! GLenum res = glewInit(); if (res != GLEW_OK) { fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res)); return false; } glutLayerGet(GLUT_OVERLAY_POSSIBLE); //printf("%s",glutLayerGet(GLUT_OVERLAY_POSSIBLE)); glutEstablishOverlay(); return true; }
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. */ }
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; }
/* 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 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; } }
int main(int argc, char **argv) { GLenum type; glutInit(&argc, argv); if (!glutLayerGet(GLUT_OVERLAY_POSSIBLE)) { fprintf(stderr, "Overlay not available\n"); return(1); } if (Args(argc, argv) == GL_FALSE) { return(1); } windW = 300; windH = 300; glutInitWindowPosition(0, 0); glutInitWindowSize( 300, 300); type = GLUT_RGB; type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; glutInitDisplayMode(type); if (glutCreateWindow("Overlay Test") == GL_FALSE) { return(1); } glutEstablishOverlay(); Init(); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutIdleFunc(Idle); glutMainLoop(); return 0; }
void key(unsigned char c, int w, int h) { int transP; printf("c=%d w=%d h=%d\n", c, w, h); switch (c) { case 'e': glutEstablishOverlay(); independent = 0; transP = glutLayerGet(GLUT_TRANSPARENT_INDEX); glClearIndex(transP); glutSetColor((transP + 1) % 2, 1.0, 1.0, 0.0); glIndexi((transP + 1) % 2); on = 1; break; case 'r': glutRemoveOverlay(); on = 0; break; case 'm': if (glutLayerGet(GLUT_HAS_OVERLAY)) { int pixel; GLfloat red, green, blue; transP = glutLayerGet(GLUT_TRANSPARENT_INDEX); pixel = (transP + 1) % 2; red = glutGetColor(pixel, GLUT_RED) + 0.2; if (red > 1.0) red = red - 1.0; green = glutGetColor(pixel, GLUT_GREEN) - 0.1; if (green > 1.0) green = green - 1.0; blue = glutGetColor(pixel, GLUT_BLUE) + 0.1; if (blue > 1.0) blue = blue - 1.0; glutSetColor(pixel, red, green, blue); } break; case 'h': glutSetWindow(hidden_w); glutHideWindow(); glutSetWindow(s2); glutHideWindow(); break; case 's': glutSetWindow(hidden_w); glutShowWindow(); glutSetWindow(s2); glutShowWindow(); break; case 'H': glutHideOverlay(); break; case 'S': glutShowOverlay(); break; case 'D': glutDestroyWindow(main_w); exit(0); 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; } }
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: glutEstablishOverlay * Signature: ()V */ JNIEXPORT void JNICALL Java_gruenewa_opengl_GLUT_00024_glutEstablishOverlay (JNIEnv * jenv, jobject jobj) { glutEstablishOverlay(); }