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); }
int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize (500, 500); glutInitWindowPosition (100, 100); glutCreateWindow (argv[0]); init (); glutDisplayFunc(display); glutReshapeFunc(reshape); //keyboard inputs glutKeyboardFunc(keyboard); //30 frames per second glutTimerFunc(30, timerFunc, 0); //special keyboard inputs like the up, down, left, right arrow keys glutSpecialFunc(control); glutSpecialUpFunc(letgo); glutMainLoop(); return 0; }
static void glutStuff(int argc, const char *argv[]) { glutInit(&argc, (char**)argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(640, 480); glutCreateWindow(demoTitle(demoIndex)); initGL(); glutReshapeFunc(reshape); glutDisplayFunc(display); // glutIdleFunc(idle); glutTimerFunc(SLEEP_TICKS, timercall, 0); glutIgnoreKeyRepeat(1); glutKeyboardFunc(keyboard); glutSpecialFunc(arrowKeyDownFunc); glutSpecialUpFunc(arrowKeyUpFunc); glutMotionFunc(mouse); glutPassiveMotionFunc(mouse); glutMouseFunc(click); }
int main( int argc, char **argv ) { glutInit( &argc, argv ); glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA ); glutInitWindowSize( 640, 480 ); glutCreateWindow( "Origami Simulation C++" ); glClearColor( 0.0, 0.0, 0.0, 1.0 ); glutReshapeFunc( reshape ); glutDisplayFunc( display ); glutTimerFunc(1000/State.fps , timer , 0); glutMouseFunc( mouse ); glutMotionFunc( motion ); glutKeyboardFunc( keyboard ); glutKeyboardUpFunc( keyboardUp ); glutSpecialFunc( special ); glutSpecialUpFunc( specialUp ); glutCreateMenu( menu ); glutAddMenuEntry( "Quit (Q)", 1 ); glutAddMenuEntry( "Rotation On/Off (R)", 2 ); glutAddMenuEntry( "Coordinates Axis On/Off (A)", 3 ); glutAddMenuEntry( "Save Folding", 4 ); glutAddMenuEntry( "Load Folding", 5 ); glutAddMenuEntry("Animation On/Off", 6); glutAddMenuEntry("Undo a Fold (Z)", 7); glutAddMenuEntry("Initialize Folds (I)", 8); glutAttachMenu( GLUT_RIGHT_BUTTON ); glutMainLoop(); return 0; }
int main(int argc, char **argv) { // Initialize the window with depth, double buffering and RGBA colors glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100,100); glutInitWindowSize(320,320); glutCreateWindow("The Middle of Nowhere"); // Enable depth calculations glEnable(GL_DEPTH_TEST); // renderScene will be our main drawing routine invoked everytime glutDisplayFunc(renderScene); glutIdleFunc(renderScene); // If the window is resized glutReshapeFunc(changeSize); // Keyboard event processing glutIgnoreKeyRepeat(1); glutKeyboardFunc(processNormalKeys); glutSpecialFunc(pressKey); glutSpecialUpFunc(releaseKey); // Mouse event processing glutMouseFunc(mouseButton); glutMotionFunc(mouseMove); // Start the scene glutMainLoop(); return 0; }
/** Activate a screen and make it current. @ingroup gui @param screen Screen to activate @warning The current screen at the call time is deactivated. */ void GfuiScreenActivate(void *screen) { if ((GfuiScreen) && (GfuiScreen->onDeactivate)) GfuiScreen->onDeactivate(GfuiScreen->userDeactData); GfuiScreen = (tGfuiScreen*)screen; glutKeyboardFunc(gfuiKeyboard); glutSpecialFunc(gfuiSpecial); glutKeyboardUpFunc(gfuiKeyboardUp); glutSpecialUpFunc(gfuiSpecialUp); glutMouseFunc(gfuiMouse); glutMotionFunc(gfuiMotion); glutPassiveMotionFunc(gfuiPassiveMotion); glutIdleFunc((void(*)(void))NULL); if (GfuiScreen->onlyCallback == 0) { if (GfuiScreen->hasFocus == NULL) { gfuiSelectNext(NULL); } glutDisplayFunc(GfuiDisplay); } else { glutDisplayFunc(GfuiDisplayNothing); } if (GfuiScreen->onActivate) GfuiScreen->onActivate(GfuiScreen->userActData); if (GfuiScreen->onlyCallback == 0) { GfuiDisplay(); glutPostRedisplay(); } }
void MainWindow::initGlut() { // Create dummy arguments for command line options int dummy_argc = 1; char *dummy_argv[1]; dummy_argv[0] = new char[255]; dummy_argv[0] = (char*)"Main Window"; // Initialize glut toolkit glutInit(&dummy_argc, dummy_argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100,100); glutInitWindowSize(762, 576); glutCreateWindow("3D-Viewer"); glutSetKeyRepeat(1); //Register callback functions glutDisplayFunc(MainWindow::callback_render); glutReshapeFunc(MainWindow::callback_reshape); glutMouseFunc(MainWindow::callback_mouse); glutMotionFunc(MainWindow::callback_motion); glutKeyboardFunc(MainWindow::callback_key); glutKeyboardUpFunc(MainWindow::callback_keyUp); glutSpecialFunc(MainWindow::callback_specialkey); glutSpecialUpFunc(MainWindow::callback_specialkeyUp); glutTimerFunc(15, MainWindow::callback_timer, 0); // glutIdleFunc(MainWindow::callback_render); // Init OpenGL stuff initGL(); // Call glut main loop to hold window at top glutMainLoop(); }
//--------------------------------------------------------- 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; }
int main (int argc, char **argv) { //Configure initial window state glutInit(&argc, argv); glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowPosition (5, 5); glutInitWindowSize (640, 640); int win = glutCreateWindow ("Imgui demo"); printGlInfo(); //Register callback functions with glut. glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutSpecialFunc(special); glutKeyboardUpFunc(keyboard_up); glutSpecialUpFunc(special_up); glutMouseFunc(mouse); glutMotionFunc(motion); glutPassiveMotionFunc(motion); glutIdleFunc(idle); initOpenGl(); ImGui_ImplGlut_Init(); // initialize the imgui system //Enter the glut event loop. glutMainLoop(); glutDestroyWindow(win); return 0; }
int main(int argc, char **argv) { // set window values win1.width = 640*1.5; win1.height = 480*1.5; win1.title = "Tutorial 4"; win1.fovAngle = 45; win1.zNear = 0.1f; win1.zFar = 500.0f; //initialize and run program glutInit(&argc, argv); // GLUT initialization glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); // Display Mode glutInitWindowSize(win1.width, win1.height); // set window size win1.id = glutCreateWindow(win1.title); // create Window glutDisplayFunc(display); // register Display Function glutKeyboardUpFunc(keyboardUp); // register Keyboard Handler glutKeyboardFunc(keyboardDown); // register Keyboard Handler glutSpecialUpFunc(specialUp); glutSpecialFunc(specialDown); glutCloseFunc(close); GLenum res = glewInit(); if (res != GLEW_OK) { fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res)); return 1; } initShaders(); initialize(); glutMainLoop(); // run GLUT mainloop return 0; }
void GlutRenderer::initGraphics(int width, int height) { m_glutScreenWidth = width; m_glutScreenHeight = height; glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(m_glutScreenWidth, m_glutScreenHeight); glutCreateWindow("GPU rigid body pipeline2"); glutKeyboardFunc(glutKeyboardCallback); glutKeyboardUpFunc(glutKeyboardUpCallback); glutSpecialFunc(glutSpecialKeyboardCallback); glutSpecialUpFunc(glutSpecialKeyboardUpCallback); glutReshapeFunc(glutReshapeCallback); glutIdleFunc(glutIdleCallback); glutMouseFunc(glutMouseFuncCallback); glutPassiveMotionFunc(glutMotionFuncCallback); glutMotionFunc(glutMotionFuncCallback); glutDisplayFunc( glutDisplayCallback ); GLenum err = glewInit(); if (GLEW_OK != err) { printf("Error: %s\n", glewGetErrorString(err)); } glClearColor(0.6f,0.6f,1.f,1.f); }
void glutStuff(int argc, const char *argv[]) { glutInitWindowSize(900,600); glutInitWindowPosition(100,100); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE ); glutInit(&argc, const_cast<char**>(argv)); glutCreateWindow("J7"); glutDisplayFunc(display); glutIdleFunc(idle); glutReshapeFunc(reshape); glutKeyboardFunc(keyDown); // key down glutKeyboardUpFunc(keyUp); // key up glutSpecialFunc(keySpecialDown); // special key down glutSpecialUpFunc(keySpecialUp); // special key up glutPassiveMotionFunc(mouseMove); // for moving the mouse glutMouseFunc(mouse); // for scroll wheel glutSetCursor(GLUT_CURSOR_NONE); // hide cursor glutWarpPointer((w/2), (h/2)); }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100,100); // seta a posição da janela glutInitWindowSize(600,400); // seta o tamanho da janela glutCreateWindow("Trabalho CG"); // título da janela glutDisplayFunc(renderScene); // função de dispĺay glutReshapeFunc(changeSize); // redesenho glutIdleFunc(renderScene); glutIgnoreKeyRepeat(1); glutKeyboardFunc(processNormalKeys); glutSpecialFunc(pressKey); glutSpecialUpFunc(releaseKey); glutMouseFunc(mouseButton); glutMotionFunc(mouseMove); glEnable(GL_DEPTH_TEST); glutMainLoop(); // deixa o app em loop return 1; }
int main(int argc, char** argv){ glutInit(&argc, argv); glutInitDisplayMode (GLUT_DOUBLE | GLUT_ALPHA ); glutInitContextVersion (3, 3); glutInitContextProfile(GLUT_CORE_PROFILE); glutInitWindowSize (windowWidth, windowHeight); glutInitWindowPosition (300, 200); glutCreateWindow ("My window GL"); if(gl3wInit()<0) return 1; glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); init(); glutDisplayFunc(display); glutReshapeFunc(reshape); glutSpecialFunc(keyboardS); glutSpecialUpFunc(keyboardSpecialUpFunc); glutMouseFunc(mouseFcn); glutMotionFunc(mouseMoveFnc); glutMouseWheelFunc(mouseWheelFnc); glutMainLoop(); finalizeProgram(gouraudShading); return(0); }
int main(int argc, char **argv) { // init GLUT and create window glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(200, 100); glutInitWindowSize(800, 600); glutCreateWindow("Lighthouse3D - GLUT Tutorial"); // register callbacks glutDisplayFunc(renderScene); glutReshapeFunc(changeSize); glutIdleFunc(renderScene); glutSpecialFunc(pressKey); // here are the new entries glutIgnoreKeyRepeat(1); glutSpecialUpFunc(releaseKey); // OpenGL init glEnable(GL_DEPTH_TEST); // enter GLUT event processing cycle glutMainLoop(); return 1; }
int main( int argc, char** argv ) { // initialize glutInit( &argc, argv ); glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); glutInitWindowSize( windowW, windowH ); glutCreateWindow( "CSE 40166 Midterm Project" ); // set callbacks glutDisplayFunc( display ); glutReshapeFunc( resize ); glutKeyboardFunc( keyboard ); glutSpecialFunc( keyboardSpecials ); glutKeyboardUpFunc( keyboardUp ); glutSpecialUpFunc( keyboardSpecialsUp ); glutTimerFunc( mspf, move, 0 ); // setup data if( !init() ) { exit( EXIT_FAILURE ); } // run glutMainLoop(); return EXIT_SUCCESS; }
void GraphicalEngine::Init(int argc, char * argv[]) //inicjacja parametrow OpenGl i tworzenie okna { for (int i = 0; i < 255; i++) { Instance->keyboard[i] = false; } glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL); glutInitWindowSize(Instance->resolution.Width, Instance->resolution.Height); glutCreateWindow(WINDOW_TITLE); //glutFullScreen(); glutKeyboardFunc(GraphicalEngine::KeyboardFunc); glutKeyboardUpFunc(GraphicalEngine::KeyboardUpFunc); glutSpecialFunc(GraphicalEngine::SpecialFunc); glutSpecialUpFunc(GraphicalEngine::SpecialUpFunc); glutDisplayFunc(GraphicalEngine::DisplayFunc); glutPassiveMotionFunc(GraphicalEngine::PassiveMotionFunc); glutReshapeFunc(GraphicalEngine::ReshapeFunc); glutIdleFunc(GraphicalEngine::DisplayFunc); GLenum err = glewInit(); if (GLEW_OK != err) { fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); } int major = 0, minor = 0; const char * version = (char *)glGetString(GL_VERSION); if (sscanf(version, "%d.%d", &major, &minor) != 2) { printf("Bledny format wersji OpenGL\n"); } }
//------------------------------------------------------------ void ofAppGlutWindow::initializeWindow(){ //---------------------- // setup the callbacks glutMouseFunc(mouse_cb); glutMotionFunc(motion_cb); glutPassiveMotionFunc(passive_motion_cb); glutIdleFunc(idle_cb); glutDisplayFunc(display); glutKeyboardFunc(keyboard_cb); glutKeyboardUpFunc(keyboard_up_cb); glutSpecialFunc(special_key_cb); glutSpecialUpFunc(special_key_up_cb); glutReshapeFunc(resize_cb); #ifdef TARGET_OSX //glutDragEventFunc(dragEvent); #endif nFramesSinceWindowResized = 0; #ifdef TARGET_WIN32 //---------------------- // this is specific to windows (respond properly to close / destroy) fixCloseWindowOnWin32(); #endif }
void CG1Helper::initApplication(CGContext* &_context, int width, int height, int windowScale) { init_timer(); _context = new CGContext(width,height); smContext = _context; //smContext.cgViewport(100,100); int argc = 1; char** argv = new char*[1]; argv[0] = new char[2]; argv[0][0] = 'a'; argv[0][1] = 0; glutInit(&argc, argv); glutInitDisplayMode (GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA | GLUT_MULTISAMPLE); int scale = windowScale>0?windowScale:1; glutInitWindowSize(width*scale, height*scale); glutCreateWindow("CG1 Template"); glGenTextures(1, &FBTexture); glBindTexture(GL_TEXTURE_2D,FBTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height,0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D,0); glutDisplayFunc(m_displayFunc); glutReshapeFunc(m_reshapeFunc); glutIdleFunc(m_idleFunc); glutKeyboardFunc(m_keyboardFunc); glutKeyboardUpFunc(m_keyboardUpFunc); glutSpecialFunc(m_specialKeyboardFunc); glutSpecialUpFunc(m_specialKeyboardUpFunc); delete [] argv[0]; delete [] argv; }
//////////////////////////////////////////////////// //メイン関数 //////////////////////////////////////////////////// int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitWindowSize(1200, 840); glutCreateWindow("game"); glutDisplayFunc(display); glutTimerFunc(0, timer, 0); //マウス操作 glutMouseFunc(mouse); glutMotionFunc(motion); glutPassiveMotionFunc(passiveMotion); //キーボード操作 glutKeyboardFunc(keyboard); glutKeyboardUpFunc(keyboardUp); glutSpecialFunc(special); glutSpecialUpFunc(specialUp); glutIgnoreKeyRepeat(GL_TRUE); init(); glutMainLoop(); }
void GlutFramework::startFramework( int argc, char *argv[], std::string title, int width, int height, int posx, int posy, double fps) { // Sets the instance to this, used in the callback wrapper functions setInstance(); this->frameTime = 1.0 / fps * 1000.0; // Initialize GLUT glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize(width, height); glutInitWindowPosition(0, 100); this->window = glutCreateWindow(title.c_str()); init(); // Initialize // Function callbacks with wrapper functions glutDisplayFunc(displayWrapper); glutReshapeFunc(reshapeWrapper); glutIdleFunc(runWrapper); glutMouseFunc(mouseButtonPressWrapper); glutMotionFunc(mouseMoveWrapper); glutKeyboardFunc(keyboardDownWrapper); glutKeyboardUpFunc(keyboardUpWrapper); glutSpecialFunc(specialKeyboardDownWrapper); glutSpecialUpFunc(specialKeyboardUpWrapper); glutMainLoop(); }
int main(int argc, char *argv[]){ // OpenGL initialization glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA); // glutInitWindowSize(640,480); // glutCreateWindow("OpenGL"); // initOpenGL(); GLenum err = glewInit(); if(GLEW_OK != err){ printf("Error: %s", glewGetErrorString(err)); } // display scene glutDisplayFunc(drawScene); // choose function when window reshape glutReshapeFunc( reshapeScreen ); glutKeyboardFunc(keyDown); glutKeyboardUpFunc(keyUp); glutSpecialFunc(specialKeyDown); glutSpecialUpFunc(specialKeyUp); //Mouse glutMouseFunc(mouseFunction); glutMainLoop(); return 0; }
int main(int argc, char** argv) { if (argc != 2) { printf("usage: luaplayer script.lua\n"); return 1; } g_vram_base = fb; memset(fb, 0, WIDTH * HEIGHT * 2); initMikmod(); initGraphics(); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowPosition(50, 50); glutInitWindowSize(WIDTH, HEIGHT); glutCreateWindow("Lua Player by klozz"); glutDisplayFunc(display); glutReshapeFunc(reshape); glutIgnoreKeyRepeat(1); glutKeyboardFunc(keyboard); glutKeyboardUpFunc(keyboardUp); glutSpecialFunc(special); glutSpecialUpFunc(specialUp); glutIdleFunc(idle); DWORD threadID; HANDLE luaThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) LuaThread, argv[1], 0, &threadID); glutMainLoop(); return 0; }
/////////////////////////////////////////////////////////////////////////////// // initialize GLUT for windowing /////////////////////////////////////////////////////////////////////////////// int initGLUT(int argc, char **argv) { // GLUT stuff for windowing // initialization openGL window. // it is called before any other GLUT routine glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_ALPHA); // display mode glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT); // window size glutInitWindowPosition(100, 100); // window location // finally, create a window with openGL context // Window will not displayed until glutMainLoop() is called // it returns a unique ID int handle = glutCreateWindow(argv[0]); // param is the title of window // register GLUT callback functions glutDisplayFunc(displayCB); glutTimerFunc(INPUT_UPDATE_TIME, KeyboardTimerCB, INPUT_UPDATE_TIME); // set up timer callback for updating input state glutTimerFunc(NETWORK_UPDATE_TIME, NetworkTimerCB, NETWORK_UPDATE_TIME); // set up timer callback for Sending info to server glutIdleFunc(idleCB); // redraw only every given millisec glutReshapeFunc(reshapeCB); glutKeyboardFunc(keyboardCB); glutKeyboardUpFunc(keyboardUpCB); glutSpecialFunc(specialKeyCB); // used for the arrow keys etc. glutSpecialUpFunc(specialKeyUpCB); glutMouseFunc(mouseCB); glutMotionFunc(mouseMotionCB); // used when the mouse moves and a mouse-button is held glutPassiveMotionFunc(mousePassiveMotionCB); // used when the mouse moves and NO mouse-buttons are held //glutSetCursor(GLUT_CURSOR_NONE); // used to hide the cursor return handle; }
void startGlutApplication(std::string windowName, int windowWidth, int windowHeight) { int argc = 0; char** argv = {}; glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE); glutInitWindowPosition(0, 0); glutInitWindowSize(windowWidth, windowHeight); glutCreateWindow(windowName.c_str()); glutDisplayFunc(::display); glutReshapeFunc(::reshape); glutKeyboardFunc(::keyboard); glutKeyboardUpFunc(::keyboardUp); glutMouseFunc(::mouse); glutMotionFunc(::mouseMotion); glutSpecialFunc(::special); glutSpecialUpFunc(::specialUp); glEnable(GL_MULTISAMPLE); glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, windowWidth, windowHeight, 0, -1.0, 1.0); glutTimerFunc(updatePeriod, ::update, 0); glutMainLoop(); }
int main(int argc, char **argv) { srand(get_tick_count()); memset(&kb, 0, sizeof(kb)); set_keys(); player_init(&p1); smp_alloc((void*)&p1); graphics_init(); physics_init(); glutInit(&argc, argv); glutInitWindowPosition(200, 100); glutInitWindowSize(window_x, window_y); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutCreateWindow(PROGRAM_NAME); glutDisplayFunc(graphics_loop); glutIdleFunc(graphics_loop); glutReshapeFunc(reshape); glutKeyboardFunc(kb_controller_dn_char); glutKeyboardUpFunc(kb_controller_up_char); glutSpecialFunc(kb_controller_dn); glutSpecialUpFunc(kb_controller_up); glutMouseFunc(mouse_handler); glutMotionFunc(mouse_motion_handler); glutPassiveMotionFunc(mouse_motion_handler); threads.phys_main = thread_create(physics_loop, NULL); glutMainLoop(); return EXIT_SUCCESS; }
void Sim::init(int* argc, char* argv[], const string& title) { glutInit(argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(800, 800); glutInitContextVersion(3, 1); glutInitContextProfile(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutCreateWindow(title.c_str()); glewExperimental = true; glewInit(); glutKeyboardFunc(keyboard_down); glutKeyboardUpFunc(keyboard_up); glutSpecialFunc(keyboard_special_down); glutSpecialUpFunc(keyboard_special_up); glutReshapeFunc(reshape); glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF); glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glClearColor(0.0, 0.0, 0.0, 1.0); glShadeModel(GL_SMOOTH); }
int main(int argc, char** argv) { // init GLUT glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(640, 480); glutInitWindowPosition(300, 200); // create window glutCreateWindow("Arkanoid"); // bind callbacks glutDisplayFunc(Director::display); glutReshapeFunc(Director::reshape); glutTimerFunc(0, Director::timer, 0); glutSpecialFunc(Director::keyDown); glutSpecialUpFunc(Director::keyUp); glutKeyboardFunc(Director::keyDown); glutKeyboardUpFunc(Director::keyUp); // run game scene Game game; Director::getInstance().run(&game); // start main loop glutMainLoop(); return 0; }
//----------------------------------------------------------------------------- // Name: initialize_glut( ) // Desc: Initializes Glut with the global vars //----------------------------------------------------------------------------- void initialize_glut(int argc, char *argv[]) { // initialize GLUT glutInit( &argc, argv ); // double buffer, use rgb color, enable depth buffer glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ); // initialize the window size glutInitWindowSize( g_width, g_height ); // set the window postion glutInitWindowPosition( 400, 100 ); // create the window glutCreateWindow( "Vinyl Visualizer"); // full screen if( g_fullscreen ) glutFullScreen(); // set the idle function - called when idle glutIdleFunc( idleFunc ); // set the display function - called when redrawing glutDisplayFunc( displayFunc ); // set the reshape function - called when client area changes glutReshapeFunc( reshapeFunc ); // set the keyboard function - called on keyboard events glutKeyboardFunc( keyboardFunc ); // set window's to specialKey callback glutSpecialFunc( specialKey ); // set window's to specialUpKey callback (when the key is up is called) glutSpecialUpFunc( specialUpKey ); // do our own initialization initialize_graphics( ); }
// main int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitWindowSize(800, 800); glutInitWindowPosition(300, 300); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); glutCreateWindow("Cottages"); init_menu(); init_objects(); init_lights(); glutReshapeFunc(reshape); glutDisplayFunc(draw); glutIdleFunc(idle); glutSpecialFunc(pressSpecialKeys); glutSpecialUpFunc(releaseSpecialKeys); glutKeyboardUpFunc(releaseKeys); glutMotionFunc(motion); glutMouseFunc(mouse); glutMainLoop(); delete cottage; delete diamond; delete lamp; delete ground; return 0; }