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; }
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; }
static void display(void) { if (glutLayerGet(GLUT_NORMAL_DAMAGED) == 0) { printf("FAIL: normal damage expected\n"); exit(1); } if (glutLayerGet(GLUT_OVERLAY_DAMAGED) == 0) { printf("FAIL: overlay damage expected\n"); exit(1); } render(); glutDisplayFunc(display2); glutPostRedisplay(); }
void display(void) { static int r = 0; //回転角の設定 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //デプスバッファのクリア glLoadIdentity(); /* 視点位置と視線方向 */ gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); /* 光源の位置設定 */ glLightfv(GL_LIGHT0, GL_POSITION, light0pos); glLightfv(GL_LIGHT1, GL_POSITION, light1pos); glPushMatrix(); glTranslatef(ox,oy,oz); glRotatef(r, 0.5, -0.5, -0.5); //回転:このように、複数の軸を中心に回転させることもできます。 /* 図形の色 (gold) */ glMaterialfv(GL_FRONT, GL_DIFFUSE, gold_diffuse); glMaterialfv(GL_FRONT, GL_AMBIENT, gold_ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, gold_specular); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, gold_shininess); /* 図形の描画 */ glutSolidTeapot(0.8); if (glutLayerGet(GLUT_NORMAL_DAMAGED) == 0)//画面が描き換えられたら { if (r++ >= 360) //角度rxを1増やした値(++r)が360以上になったら { r = 0; //角度を0に戻す glutIdleFunc(0); //アニメーションをとめる } } oy=oy-0.02; glPopMatrix(); glutPostRedisplay(); //再描画イベントを発生 glutSwapBuffers(); }
static void display_overlay(void) { if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != damage_expectation) { printf("FAIL: overlay damage not expected\n"); exit(1); } render_overlay(); move_on(); }
static void display_normal(void) { if (glutLayerGet(GLUT_NORMAL_DAMAGED) != damage_expectation) { printf("FAIL: normal damage not expected\n"); exit(1); } render_normal(); move_on(); }
static void render(void) { glutUseLayer(GLUT_NORMAL); render_normal(); if (glutLayerGet(GLUT_HAS_OVERLAY)) { glutUseLayer(GLUT_OVERLAY); render_overlay(); } }
void main_menu(int option) { switch (option) { case 1: if (glutLayerGet(GLUT_HAS_OVERLAY)) { independent = 1; glutOverlayDisplayFunc(overlay_display); } break; case 2: if (glutLayerGet(GLUT_HAS_OVERLAY)) { independent = 0; glutOverlayDisplayFunc(NULL); } break; case 666: exit(0); break; } }
static void display2(void) { static int been_here = 0; if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) { printf("FAIL: normal damage not expected\n"); exit(1); } if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != 0) { printf("FAIL: overlay damage not expected\n"); exit(1); } if (been_here) { glutPostOverlayRedisplay(); } else { glutOverlayDisplayFunc(display_overlay); glutDisplayFunc(display_normal); damage_expectation = 0; glutPostOverlayRedisplay(); glutPostRedisplay(); } }
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(); } }
void overlayDisplay(void) { if (glutLayerGet(GLUT_OVERLAY_DAMAGED)) { /* If damaged, clear the overlay. */ glClear(GL_COLOR_BUFFER_BIT); } else { /* If not damaged, undraw last overlay sphere. */ glIndexi(transparent); drawSphere(&oldOverlaySphere); } glIndexi(opaque); drawSphere(&overlaySphere); /* Single buffered window needs flush. */ glFlush(); /* Remember last overaly sphere position for undrawing. */ oldOverlaySphere = overlaySphere; }
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 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 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; }
/* 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 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; } }
/* * Class: gruenewa_opengl_GLUT__ * Method: glutLayerGet * Signature: (I)I */ JNIEXPORT jint JNICALL Java_gruenewa_opengl_GLUT_00024_glutLayerGet (JNIEnv * jenv, jobject jobj, jint arg1) { return glutLayerGet(arg1); }
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. */ }
void redrawOverlay(void) { if (help) { int i; glClear(GL_COLOR_BUFFER_BIT); glIndexi(white); for (i = 0; helpMsg[i]; i++) { output(15, 24 + i * 18, helpMsg[i]); } return; } if (glutLayerGet(GLUT_OVERLAY_DAMAGED) || clearHelp) { /* Opps, damage means we need a full clear. */ glClear(GL_COLOR_BUFFER_BIT); clearHelp = 0; wasFancy = 0; } else { /* Goody! No damage. Just erase last rubber-band. */ if (fancy || wasFancy) { glLineWidth(3.0); } glIndexi(transparent); glBegin(GL_LINE_LOOP); glVertex2i(anchorx, anchory); glVertex2i(anchorx, pstretchy); glVertex2i(pstretchx, pstretchy); glVertex2i(pstretchx, anchory); glEnd(); } if (wasFancy) { glLineWidth(1.0); wasFancy = 0; } if (fancy) glLineWidth(3.0); glIndexi(red); glBegin(GL_LINE_LOOP); glVertex2i(anchorx, anchory); glVertex2i(anchorx, stretchy); glVertex2i(stretchx, stretchy); glVertex2i(stretchx, anchory); glEnd(); if (fancy) { glLineWidth(1.0); glIndexi(white); glBegin(GL_LINE_LOOP); glVertex2i(anchorx, anchory); glVertex2i(anchorx, stretchy); glVertex2i(stretchx, stretchy); glVertex2i(stretchx, anchory); glEnd(); } glFlush(); /* Remember last place rubber-banded so the rubber-band can be erased next redisplay. */ pstretchx = stretchx; pstretchy = stretchy; }