int ogl_subwin_main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB); glutInitWindowSize(210, 210); main_w = glutCreateWindow("4 subwindows"); glutDisplayFunc(ogl_subwin_display); glutVisibilityFunc(ogl_subwin_vis); glutReshapeFunc(ogl_subwin_reshape); glClearColor(1.0, 1.0, 1.0, 1.0); w1 = glutCreateSubWindow(main_w, 10, 10, 90, 90); glutDisplayFunc(ogl_subwin_display); glutVisibilityFunc(ogl_subwin_vis); glClearColor(1.0, 0.0, 0.0, 1.0); w2 = glutCreateSubWindow(main_w, 110, 10, 90, 90); glutDisplayFunc(ogl_subwin_display); glutVisibilityFunc(ogl_subwin_vis); glClearColor(0.0, 1.0, 0.0, 1.0); w3 = glutCreateSubWindow(main_w, 10, 110, 90, 90); glutDisplayFunc(ogl_subwin_display); glutVisibilityFunc(ogl_subwin_vis); glClearColor(0.0, 0.0, 1.0, 1.0); w4 = glutCreateSubWindow(main_w, 110, 110, 90, 90); glutDisplayFunc(ogl_subwin_display); glutVisibilityFunc(ogl_subwin_vis); glClearColor(1.0, 1.0, 0.0, 1.0); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char** argv) { char glutGamemode[32]; glutInit(&argc, argv); setup_camera(); setup_marker(); init_voxels_hp(); // Set up GL context(s) for OpenGL to draw into. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(prefWidth, prefHeight); camera_win_id = glutCreateWindow("Camera"); glutTimerFunc(10, TimeEvent, 1); ARGL_CONTEXT_SETTINGS_REF argl_context_ref = NULL; // Setup argl library for current context. if ((argl_context_ref = arglSetupForCurrentContext()) == NULL) { std::cout << "main(): arglSetupForCurrentContext() returned error." << std::endl; exit(-1); } arUtilTimerReset(); glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glClearColor(0.0, 0.0, 0.0, 1.0); glutVisibilityFunc(visibility_camera); glutIdleFunc(idle_camera); glutDisplayFunc(display_camera); glutReshapeFunc(reshape); glutKeyboardFunc(debug_only); setup_voxels(); camera_set_context(argl_context_ref); viewer_win_id = glutCreateWindow("Viewer"); glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glClearColor(0.0,0.0,0.0,1.0); glutVisibilityFunc(visibility_viewer); glutIdleFunc(idle_viewer); glutDisplayFunc(display_viewer); glutReshapeFunc(reshape_viewer); auto voxel_t = std::thread(voxel_carving_routine); auto capture_t = std::thread(image_capturing_routine); auto should_capture_t = std::thread(should_capture_routine); auto a_cam_buffer_t = std::thread(transfer); voxel_t.detach(); capture_t.detach(); should_capture_t.detach(); a_cam_buffer_t.detach(); glutMainLoop(); return 0; }
//--------------------------------------------------------- int main(int argc, char** argv) { glutInit(&argc, argv); Game.m_screenW = INITIAL_WORLD_SIZE; Game.m_screenH = INITIAL_WORLD_SIZE; glutInitWindowSize(Game.m_screenW,Game.m_screenH); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH ); glutCreateWindow("AIsteroids"); glutReshapeFunc(Reshape); glutDisplayFunc(Display); glutIdleFunc(Idle); glutVisibilityFunc(Visible); //sets up the keyboard functions glutKeyboardFunc(Key); glutKeyboardUpFunc(KeyUp); glutSpecialFunc(SpecialKey); glutSpecialUpFunc(SpecialKeyUp); glInitColorArray(); srand(time(NULL)); Game.StartGame(); glutMainLoop(); return 0; }
void init(int &argc, char* argv[], float width, float height) { glutInit(&argc, argv); int DISPLAY_TYPE = GLUT_RGBA | GLUT_DOUBLE; if(ALLOW_BLUR) { DISPLAY_TYPE = DISPLAY_TYPE | GLUT_ACCUM; } glutInitDisplayMode(DISPLAY_TYPE); glutInitWindowSize(width, height); glutCreateWindow("Newtonia"); //glEnable(GL_DEPTH_TEST); //glDepthFunc(GL_LESS); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glEnable(GL_LINE_SMOOTH); glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); glEnable(GL_POINT_SMOOTH); if(ALLOW_BLUR) { glEnable(GL_ACCUM); glClear(GL_ACCUM_BUFFER_BIT); } glutDisplayFunc(draw); glutKeyboardFunc(keyboard); glutKeyboardUpFunc(keyboard_up); glutSpecialFunc(special); glutSpecialUpFunc(special_up); glutReshapeFunc(resize); glutVisibilityFunc(isVisible); }
void isVisible(int state) { if(state == GLUT_VISIBLE) { last_render_time = last_tick_time = glutGet(GLUT_ELAPSED_TIME); glutVisibilityFunc(NULL); glutIdleFunc(tick); } }
int main(int argc, char** argv){ glutInit(&argc,argv); //Init OpenGL With Double Buffer in RGB Mode glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(800,600); glutCreateWindow("3D Model"); //Set Display Handler glutDisplayFunc(Display); //Set Keyboard Handler glutKeyboardFunc(KeyboardHandler); glutSpecialFunc(SpecialKeyboardHandler); glutReshapeFunc(ReshapeWindow); glutVisibilityFunc(Visible); Init(); //OpenGL Main Loop glutMainLoop(); return 0; }
int main(int argc, char **argv) { GLenum type; glutInitWindowSize(400, 300); glutInit(&argc, argv); if (Args(argc, argv) == GL_FALSE) { exit(1); } type = (rgb) ? GLUT_RGB : GLUT_INDEX; type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; glutInitDisplayMode(type); glutCreateWindow("Olympic"); Init(); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutDisplayFunc(DrawScene); glutVisibilityFunc(visible); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
GlutViewer:: GlutViewer(const char* _title, int _width, int _height) : width_(_width), height_(_height), draw_mode_(SOLID_SMOOTH), fullscreen_(false), bak_left_(0), bak_top_(0), bak_width_(0), bak_height_(0), menuID_(0) { // create window glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA | GLUT_MULTISAMPLE ); //glutInitDisplayString("rgb double alpha depth>=16 samples>=16"); glutInitWindowSize(_width, _height); windowID_ = glutCreateWindow(_title); windows__[windowID_] = this; // register callbacks glutDisplayFunc(display__); glutKeyboardFunc(keyboard__); glutSpecialFunc(special__); glutMouseFunc(mouse__); glutMotionFunc(motion__); glutPassiveMotionFunc(passivemotion__); glutReshapeFunc(reshape__); glutVisibilityFunc(visibility__); glutIdleFunc(idle__); //Init glew for windows //#ifdef _WIN32 glewInit(); //#endif }
int main(int argc, char **argv) { int fillmenu = 0; glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(INITW, INITH); glutCreateWindow("Worms"); myinit(); glutDisplayFunc(mydisplay); glutVisibilityFunc(visibility); glutReshapeFunc(myreshape); glutMouseFunc(handleMouse); /* popup menu, courtsey of GLUT */ fillmenu = glutCreateMenu(menuSelect); glutAddMenuEntry("Filled", MENU_FILLED); glutAddMenuEntry("Unfilled", MENU_UNFILLED); glutCreateMenu(menuSelect); glutAddMenuEntry(" WORMS", MENU_NULL); glutAddSubMenu("Drawing Mode", fillmenu); glutAddMenuEntry("Quit", MENU_QUIT); glutAttachMenu(GLUT_RIGHT_BUTTON); glutMainLoop(); return 0; }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutCreateWindow("Spin"); Object = make_object(); glCullFace(GL_BACK); glDisable(GL_DITHER); glShadeModel(GL_FLAT); glColor3f(1.0, 1.0, 1.0); Xrot = Yrot = Zrot = 0.0; Xstep = Step; Ystep = Zstep = 0.0; glutReshapeFunc(reshape); glutKeyboardFunc(key); glutVisibilityFunc(visible); glutDisplayFunc(draw); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int CWindow::SetupWindow(void) { glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA | GLUT_DEPTH); glutInitWindowSize(width * scale, height * scale); glutInitWindowPosition(10, 20); if(glutCreateWindow("ARDeskTop") < 1) { exit(-1); } // glewInit(); glutDisplayFunc(::Display); glutReshapeFunc(::Reshape); glutVisibilityFunc(::Visibility); glutKeyboardFunc(::Keyboard); glutMouseFunc(::Mouse); if((arglSettings = arglSetupForCurrentContext()) == 0) { exit(-1); } // if(FUTL_LoadShader("simple.vert", "simple.frag", &shdProg) < 0) return(-1); // glUseProgram(shdProg); return(1); }
static void registerCallbacks () { glutIdleFunc(gst_glut_IdleFunc); glutKeyboardFunc(gst_glut_KeyboardFunc); glutSpecialFunc(gst_glut_SpecialFunc); glutReshapeFunc(gst_glut_ReshapeFunc); glutVisibilityFunc(gst_glut_VisibilityFunc); glutDisplayFunc(gst_glut_DisplayFunc); glutMouseFunc(gst_glut_MouseFunc); glutMotionFunc(gst_glut_MotionFunc); glutPassiveMotionFunc(gst_glut_PassiveMotionFunc); glutEntryFunc(gst_glut_EntryFunc); glutKeyboardUpFunc(gst_glut_KeyboardUpFunc); glutSpecialUpFunc(gst_glut_SpecialUpFunc); glutMenuStateFunc(gst_glut_MenuStateFunc); glutMenuStatusFunc(gst_glut_MenuStatusFunc); glutOverlayDisplayFunc(gst_glut_OverlayDisplayFunc); glutWindowStatusFunc(gst_glut_WindowStatusFunc); glutSpaceballMotionFunc(gst_glut_SpaceballMotionFunc); glutSpaceballRotateFunc(gst_glut_SpaceballRotateFunc); glutSpaceballButtonFunc(gst_glut_SpaceballButtonFunc); glutButtonBoxFunc(gst_glut_ButtonBoxFunc); glutDialsFunc(gst_glut_DialsFunc); glutTabletMotionFunc(gst_glut_TabletMotionFunc); glutTabletButtonFunc(gst_glut_TabletButtonFunc); glutWMCloseFunc(gst_glut_WMCloseFunc); #if 0 glutJoystickFunc(gst_glut_JoystickFunc); glutMouseWheelFunc(gst_glut_MouseWheelFunc); glutCloseFunc(gst_glut_CloseFunc); glutMenuDestroyFunc(gst_glut_MenuDestroyFunc); #endif }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(400, 400); glutCreateWindow("NURBS Surface"); glutDisplayFunc(expose); glutReshapeFunc(resize); glutKeyboardFunc(Key); glutMouseFunc(Button); glutCreateMenu(Menu); glutAddMenuEntry("Trim", 1); glutAddMenuEntry("Fill", 2); glutAddMenuEntry("Hull", 3); glutAddMenuEntry("Exit", 4); glutAttachMenu(GLUT_RIGHT_BUTTON); glutVisibilityFunc(visibility); initialize(); glutMainLoop(); return 0; }
void runGame() { glDeleteTextures(1,&ThirteenTexture); DelayCompensation=1; glutIgnoreKeyRepeat(1); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_NORMALIZE); glEnable(GL_BLEND); glShadeModel(GL_SMOOTH); glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //Callbacks setzen: Reaktion auf Mausklicks und -bewegungen, Tastaturaktivit鋞en glutMouseFunc(MouseClick); glutMotionFunc(MouseMove); glutKeyboardFunc(KeyPress); glutKeyboardUpFunc(KeyRelease); glutSpecialFunc(SpecialKeyPress); glutSpecialUpFunc(SpecialKeyRelease); glutVisibilityFunc(Visible); glutIdleFunc(timerEvent); glutDisplayFunc(updateGL); }
static void initialize(void) { int attr; attr = doublebuffer ? RGBA_DB_attributes : RGBA_SB_attributes; glutInitDisplayMode(attr); glutInitWindowSize(300, 240); glutCreateWindow("Ideas"); if (multisample) glEnable(GL_POLYGON_SMOOTH); init_lights(); init_materials(); build_table(); view_from_spline = calc_spline_params(view_from_ctl, TIME); view_to_spline = calc_spline_params(view_to_ctl, TIME); light_pos_spline = calc_spline_params(light_pos_ctl, TIME); logo_pos_spline = calc_spline_params(logo_pos_ctl, TIME); logo_rot_spline = calc_spline_params(logo_rot_ctl, TIME); glutReshapeFunc(resize_window); glutDisplayFunc(display); glutMouseFunc(mouse); glutKeyboardFunc(keyboard); glutVisibilityFunc(vis); glMatrixMode(GL_MODELVIEW); }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitWindowPosition(0, 0); glutInitWindowSize(600, 450); IndexMode = argc > 1 && strcmp(argv[1], "-ci") == 0; if (IndexMode) glutInitDisplayMode(GLUT_INDEX | GLUT_DOUBLE); else glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutCreateWindow("Bounce"); Ball = make_ball(); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glDisable(GL_DITHER); glShadeModel(GL_FLAT); glutDisplayFunc(draw); glutReshapeFunc(reshape); glutVisibilityFunc(visible); glutKeyboardFunc(key); if (IndexMode) { glutSetColor(RED, 1.0, 0.0, 0.0); glutSetColor(WHITE, 1.0, 1.0, 1.0); glutSetColor(CYAN, 0.0, 1.0, 1.0); } glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char** argv) { glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(512, 512); glutInit(&argc, argv); glutCreateWindow(argv[0]); init(argc > 1 ? argv[1] : "../../data/spheremap.rgb"); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(key); glutSpecialFunc(special); glutIdleFunc(animate); glutMouseFunc(mouse); glutMotionFunc(motion); glutVisibilityFunc(visible); printf("c - toggle backface culling\n"); printf("l - toggle lighting\n"); printf("t - toggle texturing\n"); printf("u/U - increase/decrease tesselation\n"); printf("w - toggle wireframe/filled polygons\n"); printf("y - toggle background color\n\n"); printf("Use the left/right arrows to adjust the frequency of the motion.\n"); printf("Use the up/down arrows to adjust the scale of the motion.\n\n"); glutMainLoop(); return 0; }
int main(int argc, char **argv) { glutInit(&argc, argv); if (argc > 1 && !strcmp(argv[1], "-f")) fullscreen = GL_TRUE; glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); if (fullscreen) { glutGameModeString("640x480:16@60"); glutEnterGameMode(); } else { glutInitWindowSize(400, 400); glutCreateWindow("GLUT-based OpenGL skyfly"); } glutDisplayFunc(draw); glutReshapeFunc(reshape); glutVisibilityFunc(visible); glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(motion); glutPassiveMotionFunc(motion); glutSpecialFunc(special); init_misc(); if (!rgbmode) init_cmap(); init_skyfly(); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE); glutInitWindowPosition(0, 0); glutInitWindowSize(640, 480); glutInit(&argc, argv); glutCreateWindow("Marbles falling from a box"); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMotionFunc(motion); glutMouseFunc(mouse); glutKeyboardFunc(keyboard); glutCreateMenu(menu); // glutAddMenuEntry("Particle", 0); //glutAddMenuEntry("", 0); glutAddMenuEntry(" Less Marbles or -", '-'); glutAddMenuEntry(" More flow or +", '+'); glutAddMenuEntry(" Smaller points or p", 'p'); glutAddMenuEntry(" Larger points or P", 'P'); glutAddMenuEntry("[Esc] Quit", 27); glutAttachMenu(GLUT_RIGHT_BUTTON); // dynamically allocating memory for the number of particles initially particles = (PSparticle*)malloc(sizeof(PSparticle) * num_particles); glutVisibilityFunc(visible); glutMainLoop(); return 0; }
int main(int argc, char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowPosition(MY_WIND_X_POS, MY_WIND_Y_POS); glutInitWindowSize(MY_WIND_X_SIZE, MY_WIND_Y_SIZE); glutCreateWindow("B581 template code with 3D lighting"); glutDisplayFunc (myDisplay); glutReshapeFunc (myReshape); glutMouseFunc (myButton); glutMotionFunc (myMotion); glutPassiveMotionFunc (NULL); glutIdleFunc (NULL); glutKeyboardFunc (myKeyboard); glutVisibilityFunc (myVisibility); fprintf(stderr,"Press ESC or 'q' to Exit.\n"); myInitGL(); myInitData(&argc,argv); /* pass command line arguments for texture */ /* initialize GLUT menu handler as last one, to take over access to GLUT_RIGHT_BUTTON, regardles to what other handlers did to it: */ myInitMenus(); glutTimerFunc(0,timer,0); glutMainLoop(); return(EXIT_SUCCESS); } /* main() */
void GlutMaster::CallGlutCreateWindow(char * setTitle, GlutWindow * glutWindow){ // Open new window, record its windowID , int windowID = glutCreateWindow(setTitle); glutWindow->SetWindowID(windowID); // Store the address of new window in global array // so GlutMaster can send events to propoer callback functions. viewPorts[windowID] = glutWindow; // Hand address of universal static callback functions to Glut. // This must be for each new window, even though the address are constant. glutDisplayFunc(CallBackDisplayFunc); glutIdleFunc(CallBackIdleFunc); glutKeyboardFunc(CallBackKeyboardFunc); glutSpecialFunc(CallBackSpecialFunc); glutMouseFunc(CallBackMouseFunc); glutMotionFunc(CallBackMotionFunc); glutPassiveMotionFunc(CallBackPassiveMotionFunc); glutReshapeFunc(CallBackReshapeFunc); glutVisibilityFunc(CallBackVisibilityFunc); }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA ); ps.w = 512; ps.h = 512; glutInitWindowSize(ps.w, ps.h); glutInitWindowPosition(100,100); glutCreateWindow(argv[0]); init(); glutVisibilityFunc(VisibilityFunc); glutDisplayFunc(DisplayFunc); glutReshapeFunc(ReshapeFunc); glutKeyboardFunc(KeyboardFunc); glutCreateMenu(MenuFunc); glutAddMenuEntry("Stereo", 's'); glutAddMenuEntry("Mono", 'm'); glutAddMenuEntry("Dodecahedron", '1'); glutAddMenuEntry("Icosahedron", '2'); glutAddMenuEntry("Teapot", '3'); glutAddMenuEntry("Solar system", '4'); glutAttachMenu(GLUT_RIGHT_BUTTON); glutMainLoop(); return 0; }
void blender() { glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutCreateWindow("blender"); glutDisplayFunc(displaycc); glutVisibilityFunc(visible); glNewList(1, GL_COMPILE); glutSolidIcosahedron(); glEndList(); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glLightfv(GL_LIGHT1, GL_POSITION, light1_position); glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_diffuse); glLightfv(GL_LIGHT2, GL_POSITION, light2_position); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_LINE_SMOOTH); glLineWidth(2.0); glMatrixMode(GL_PROJECTION); gluPerspective( /* field of view in degree */ 40.0,/* aspect ratio */ 1.0,/* Z near */ 1.0, /* Z far */ 10.0); glMatrixMode(GL_MODELVIEW); gluLookAt(0.0, 0.0, 5.0,/* eye is at (0,0,5) */0.0, 0.0, 0.0, /* center is at (0,0,0) */0.0, 1.0, 0.); /* up is in positive Y direction */ glTranslatef(0.0, 0.6, -1.0); glutMouseFunc(clickx); glutMainLoop(); }
int main(int argc, char **argv) { glutInitWindowSize(500,500); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); (void) glutCreateWindow("projtex"); glewInit(); if (argc > 1) { NumTextures = atoi(argv[1]); } assert(NumTextures <= MAX_TEX); loadTexture = loadImageTextures; drawObject = drawCube; initialize(); glutDisplayFunc(display); glutKeyboardFunc(key); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(trackMotion); glutVisibilityFunc(vis); glutCreateMenu(menu); glutAddMenuEntry("Toggle showing projection", 's'); glutAddMenuEntry("Switch texture", 't'); glutAddMenuEntry("Switch object", 'o'); glutAddMenuEntry("Toggle filtering", 'l'); glutAddMenuEntry("Quit", 666); glutAttachMenu(GLUT_RIGHT_BUTTON); texture(); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char **argv) { int mode = GLUT_DOUBLE; glutInit(&argc, argv); #ifdef STEREO if (argc > 1) if (stricmp(argv[1],"-stereo") == 0) bStereoRequested = GL_TRUE; /* use GLUT to request GL_STEREO quad-buffered display visual */ if (bStereoRequested) mode |= GLUT_STEREO; #endif glutInitDisplayMode(mode | GLUT_RGB | GLUT_DEPTH); glutInitWindowPosition(100, 100); glutInitWindowSize(640, 480); glutCreateWindow(argv[0]); myinit(); glutReshapeFunc(myReshape); glutDisplayFunc(display); glutKeyboardFunc(keys); glutVisibilityFunc(visibility); glutPostRedisplay(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char** argv) { glutInit(&argc, argv); glutInitWindowSize(512, 512); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutCreateWindow("AGV example"); glutVisibilityFunc(visible); if (Rotating) glutIdleFunc(rotatethering); /* * let AGV know if it can mess with the idle function (if we've * just installed an idle function, we tell AGV it can't touch it) */ agvInit(!Rotating); /* * agvInit() installs mouse, motion, and keyboard handles, but * we don't care for this example cause we only use right button menu */ agvMakeAxesList(AXES); /* create AGV axes */ myGLInit(); MakeDisplayLists(); MenuInit(); glutDisplayFunc(display); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char *argv[]) { glutInit(&argc, argv); /* use multisampling if available */ glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE); glutCreateWindow("glutplane"); glutDisplayFunc(draw); glutKeyboardFunc(keyboard); glutVisibilityFunc(visible); glutCreateMenu(menu); glutAddMenuEntry("Add plane", ADD_PLANE); glutAddMenuEntry("Remove plane", REMOVE_PLANE); glutAddMenuEntry("Motion", MOTION_ON); glutAddMenuEntry("Quit", QUIT); glutAttachMenu(GLUT_RIGHT_BUTTON); /* setup OpenGL state */ glClearDepth(1.0); glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20); glMatrixMode(GL_MODELVIEW); /* add three initial random planes */ srandom(getpid()); add_plane(); add_plane(); add_plane(); /* start event processing */ glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
GlutViewer::GlutViewer(const char *wtitle, int width, int height) :m_Width(width) ,m_Height(height) { // create window glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA); glutInitWindowSize(width, height); m_WindowID = glutCreateWindow(wtitle); m_Windows[m_WindowID] = this; // register callbacks; glutDisplayFunc(SDisplay); glutKeyboardFunc(SKeyBoard); glutSpecialFunc(SSpecial); glutMouseFunc(SMouse); glutMotionFunc(SMotion); glutPassiveMotionFunc(SPassiveMotion); glutReshapeFunc(SReshape); glutVisibilityFunc(SVisibility); // create menu m_NDrawModes = 0; m_MenuID = glutCreateMenu(SProcessMenu); glutAttachMenu(GLUT_RIGHT_BUTTON); }
int ogl_mjksift_main(int argc, char **argv) { int minify_menu, rate_menu; glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutCreateWindow("mjksift"); glutDisplayFunc(ogl_mjksift_redraw); glMatrixMode(GL_PROJECTION); gluPerspective( /* field of view in degree */ 40.0, /* aspect ratio */ 1.0, /* Z near */ 1.0, /* Z far */ 70.0); glMatrixMode(GL_MODELVIEW); gluLookAt(0.0, 0.0, 5.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 positive Y direction */ depth = mjk_depth; width = mjk_width; height = mjk_height; bits = mjk_image; glPixelStorei(GL_UNPACK_ALIGNMENT, 1); gluBuild2DMipmaps(GL_TEXTURE_2D, depth, width, height, GL_RGB, GL_UNSIGNED_BYTE, bits); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glEnable(GL_TEXTURE_2D); glutVisibilityFunc(ogl_mjksift_visibility); minify_menu = glutCreateMenu(minify_select); glutAddMenuEntry("Nearest", GL_NEAREST); glutAddMenuEntry("Linear", GL_LINEAR); glutAddMenuEntry("Nearest mipmap nearest", GL_NEAREST_MIPMAP_NEAREST); glutAddMenuEntry("Linear mipmap nearest", GL_LINEAR_MIPMAP_NEAREST); glutAddMenuEntry("Nearest mipmap linear", GL_NEAREST_MIPMAP_LINEAR); glutAddMenuEntry("Linear mipmap linear", GL_LINEAR_MIPMAP_LINEAR); rate_menu = glutCreateMenu(rate_select); glutAddMenuEntry(" 2/sec", 500); glutAddMenuEntry(" 6/sec", 166); glutAddMenuEntry("10/sec", 100); glutAddMenuEntry("20/sec", 50); glutAddMenuEntry("30/sec", 33); glutAddMenuEntry("60/sec", 16); glutCreateMenu(menu_select); glutAddMenuEntry("Toggle sifting", 1); glutAddMenuEntry("Toggle scaling", 2); glutAddSubMenu("Minimum frame rate", rate_menu); glutAddSubMenu("Minify modes", minify_menu); glutAddMenuEntry("Quit", 666); glutAttachMenu(GLUT_RIGHT_BUTTON); menu_select(3); generateTexturedSurface(); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main(int argc, char **argv) { long i; glutInit(&argc, argv); for (i = 1; i < argc; i++) { if (argv[i][0] == '-') { switch (argv[i][1]) { case 's': doubleBuffer = 0; break; default: Usage(); } } else { Usage(); } } glutInitWindowSize(W, H); if (doubleBuffer) { glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE | GLUT_MULTISAMPLE); } else { glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_SINGLE | GLUT_MULTISAMPLE); } glutCreateWindow("glpuzzle"); init(); glGetIntegerv(GL_VIEWPORT, viewport); printf("\n"); printf("r Reset puzzle\n"); printf("s Solve puzzle (may take a few seconds to compute)\n"); printf("d Destroy a piece - makes the puzzle easier\n"); printf("b Toggles the depth buffer on and off\n"); printf("\n"); printf("Left mouse moves pieces\n"); printf("Middle mouse spins the puzzle\n"); printf("Right mouse has menu\n"); glutReshapeFunc(Reshape); glutDisplayFunc(redraw); glutKeyboardFunc(keyboard); glutMotionFunc(motion); glutMouseFunc(mouse); glutVisibilityFunc(visibility); glutCreateMenu(menu); glutAddMenuEntry("Solve", 1); glutAddMenuEntry("Reset", 2); glutAddMenuEntry("Quit", 3); glutAttachMenu(GLUT_RIGHT_BUTTON); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }