int main(int argc, char** argr) { glutInit(&argc, argr); glutInitWindowSize(800, 800); glutInitWindowPosition(150, 150); glutCreateWindow("King of theives"); glutDisplayFunc(Display); glutIdleFunc(anim); glutKeyboardFunc(Key); glutKeyboardUpFunc(KeyUp); // sets the KeyboardUp handler function; called when a key is released glutTimerFunc(0, Timer, 0); // sets the Timer handler function; which runs every `Threshold` milliseconds (1st argument) glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glClearColor(1, 1, 1, 0); gluOrtho2D(0, 800, 0, 800); glutMainLoop(); return 0; }
int main (int argc, char *argv[]) { // inicializar glut glutInit (&argc, argv); glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize (TAMANYOVENTANA, TAMANYOVENTANA); glutInitWindowPosition (200, 200); glutCreateWindow ("practica 02"); glutDisplayFunc (display); glutReshapeFunc (reshape); glEnable (GL_DEPTH_TEST); glLineWidth (1.4); glutWarpPointer (TAMANYOVENTANA / 2, TAMANYOVENTANA / 2); glutIdleFunc (idle); glutPassiveMotionFunc (motion); glutMotionFunc (motion); glutKeyboardFunc (keyboard); glutKeyboardUpFunc (keyboardUp); glutSpecialFunc (special); glutSpecialUpFunc (specialUp); glutMouseFunc (mouse); // inicializar sdl SDL_Init (SDL_INIT_AUDIO | SDL_INIT_TIMER); // inicializar alut alutInit (&argc, argv); cargarSonido(); inicializar(); imprimirInstrucciones(); atexit (salir); glutMainLoop(); return 0; }
void graphicsInit(int argc, char **argv) { glutInit(&argc, argv); // Initialize GLUT glutInitDisplayMode (GLUT_SINGLE); // Set up a basic display buffer (only single buffered for now) glutInitWindowSize (1000, 900); // Set the width and height of the window glutInitWindowPosition (100, 100); // Set the position of the window glutCreateWindow ("LP Simulation"); // Set the title for the window glutDisplayFunc(display); // Tell GLUT to use the method "display" for rendering glutReshapeFunc(reshape); // Tell GLUT to use the method "reshape" for reshaping glutKeyboardFunc(keyPressed); // Tell GLUT to use the method "keyPressed" for key presses glutKeyboardUpFunc(keyUp); // Tell GLUT to use the method "keyUp" for key up events glutMainLoop(); // Enter GLUT's main loop }
int main(int argc, char** argv) { glutInit(&argc, argv); // couches du framebuffer utilisees par l'application glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH ); // position et taille de la fenetre glutInitWindowPosition(20, 80); glutInitWindowSize(W_fen,H_fen); glutCreateWindow(argv[0]); // Windows only exposes OpenGL 1.1 functions. // To call more modern functions, we need to load GLEW. #if defined(_WIN32) GLenum err = glewInit(); (GLEW_OK != err) ? printf("GLEW init failed!\n") : printf("GLEW init complete\n"); #endif init( ); // Initialize viewpoint glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0,0,-4); tbInitTransform(); tbHelp(); // cablage des callback glutReshapeFunc(reshape); glutIgnoreKeyRepeat(1); glutKeyboardFunc(keyboard); //call *once* on keydown glutKeyboardUpFunc(keyboardUp); glutDisplayFunc(displayInternal); glutMouseFunc(mouse); glutMotionFunc(mouseMotion); // traqueboule utilise la souris glutPassiveMotionFunc(mousePassiveMotion); glutIdleFunc(animate); glutTimerFunc(firstEnemySpawnDelay, spawnEnemy, 0); glutTimerFunc(bossSpawnDelay, spawnBoss, 0); // lancement de la boucle principale glutMainLoop(); return 0; // instruction jamais exécutée }
void Engine::initGLUT() { int argc = 1; char *argv[] = {"Bin", NULL}; glutInit(&argc, argv); if(context->core) { glutInitContextVersion(context->majorVersion, context->minorVersion); glutInitContextProfile(GLUT_CORE_PROFILE); } else { glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE); } glutInitDisplayMode(framebuffer->flags); glutInitWindowPosition(window->positionX, window->positionY); glutInitWindowSize(window->width, window->height); // in case GL_DEBUG_OUTPUT doesn't work // glutInitContextFlags(GLUT_DEBUG); glutCreateWindow(window->name.c_str()); std::cout << "GLUT initialized\n"; glEnable(GL_DEBUG_OUTPUT); glutSetWindowData(static_cast<void *>(this)); glutIdleFunc(idleCallback); glutDisplayFunc(displayCallback); glutReshapeFunc(reshapeCallback); glutCloseFunc(closeCallback); glutKeyboardFunc(handleKeyboardCallback); glutKeyboardUpFunc(handleKeyboardUpCallback); glutSpecialFunc(handleKeyboardSpecialCallback); glutSpecialUpFunc(handleKeyboardSpecialUpCallback); glutMotionFunc(handleMouseMovement); glutPassiveMotionFunc(handleMouseMovement); initGLEW(); glDebugMessageCallback(DebugOutput::printDebugOutput, NULL); //GLenum severity = GL_DEBUG_SEVERITY_LOW | GL_DEBUG_SEVERITY_MEDIUM | GL_DEBUG_SEVERITY_HIGH | GL_DEBUG_SEVERITY_NOTIFICATION; glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); std::cout << "Info | Vendor: " << glGetString(GL_VENDOR) << " | Renderer: " << glGetString(GL_RENDERER) << " | OpenGl version: " << glGetString(GL_VERSION) << std::endl; }
void GlutInit() { glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF) ; glutKeyboardFunc(KeyboardDown); glutKeyboardUpFunc(KeyboardUp); glutSpecialFunc(SpecialDown); glutSpecialUpFunc(SpecialUp); glutMouseFunc(MouseButton); glutMotionFunc(MouseMotion); glutPassiveMotionFunc(MouseMotion); glutDisplayFunc(Display); glutIdleFunc(Display); glutReshapeFunc(Reshape); glutEntryFunc(MouseEntry); //glutVisibilityFunc(visible); }
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); glutKeyboardFunc(keyboard); glutKeyboardUpFunc(keyUp); glutTimerFunc(100, timer, 30); glutMainLoop(); return 0; }
/* Initializes GLUT context */ glutWidget::glutWidget(int argc, char** argv) { m_frame = 0; glutInitWindowSize(glutWidget::m_width, glutWidget::m_height); glutInit(&argc,argv); glutInitDisplayString("samples rgb double depth"); glutCreateWindow("Mandelbrot"); glutMouseFunc(mouseHandler); //what to call when user clicks or scrolls glutKeyboardFunc(keyDown); //what to call when user presses a key glutKeyboardUpFunc(keyUp); //what to call when user releases a key glutSpecialFunc(specialKeyDown); //what to call when user presses a special key glutSpecialFunc(specialKeyUp); //what to call when user releases a special key glutDisplayFunc(render); //what to call when window needs redrawing glutIdleFunc(update); //what to call when no user input given initOpenGL(); }
/** Deactivate the current screen. @ingroup gui */ void GfuiScreenDeactivate(void) { if (GfuiScreen->onDeactivate) GfuiScreen->onDeactivate(GfuiScreen->userDeactData); GfuiScreen = (tGfuiScreen*)NULL; glutKeyboardFunc((void(*)(unsigned char,int,int))NULL); glutSpecialFunc((void(*)(int,int,int))NULL); glutKeyboardUpFunc((void(*)(unsigned char,int,int))NULL); glutSpecialUpFunc((void(*)(int,int,int))NULL); glutMouseFunc((void(*)(int,int,int,int))NULL); glutMotionFunc((void(*)(int,int))NULL); glutPassiveMotionFunc((void(*)(int,int))NULL); glutIdleFunc((void(*)(void))NULL); glutDisplayFunc(GfuiDisplayNothing); }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitWindowSize(WINDOW_WIDTH,WINDOW_HEIGHT); glutInitWindowPosition(0,0); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutCreateWindow("OBJ Loader - GLM + GLMIMG + TGA TEXTURE"); C3DObject_Load("penguin.obj"); glutReshapeFunc(resize); glutDisplayFunc(display); glutKeyboardFunc(onKeyDown); glutKeyboardUpFunc(onKeyUp); glutIdleFunc(idle); glClearColor(1,1,1,1); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_LIGHT0); glEnable(GL_NORMALIZE); glEnable(GL_COLOR_MATERIAL); glEnable(GL_LIGHTING); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); initialize(); glutMainLoop(); return EXIT_SUCCESS; }
/* main program - setup window using GLUT */ int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Hidden surface removal renders the scene such that the nearest surface rendered to the viewer is seen as the closest visible surface. By using a depth buffer, each rendered pixel in the depth buffer stores the distance to the previously rendered surface. Depending on the depth mode used, i.e. LESS for instance, if the new surface is closer to the view then the value of thedepth pixel is replaced otherwise is discarded and not rendered. glutInitWindowSize(1000, 500); glutCreateWindow("3D Maze Game"); glutDisplayFunc(display); initgl(); glutKeyboardFunc(keyboard_interaction); glutKeyboardUpFunc(keyboard_up); glutMouseFunc(SpecialKeyStrokes); glutTimerFunc(17, timer, 0); //Add a timer glutMainLoop(); return 0; }
int main(int args, char **argv) { glutInit(&args,argv); //glut的初始化函数,负责处理命令行参数,在这里我们只需记住它是用glut搭建Opengl显示环境必须要第一个调用的函数 glutInitWindowPosition(500,500); //glut的窗口初始化函数,设定了绘图窗口左上角在整个屏幕上的坐标(以像素为单位,下同) glutInitWindowSize(500,500); //glut的窗口初始化函数,设定了绘图窗口的大小 glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH); //将窗口显示模式设定为双缓冲、RGBA颜色模式并且带深度缓存,在完成本次作业后,可以去掉或者修改这三个参数中的任意一个,看看显示结果会有什么不同,为什么会这样呢? glutCreateWindow("BNU CG Lab1_1 例程"); //创建一个名为"GLUT Framework(BNU CG Lab1)"的窗口,如果把这一行放在上面三个函数任意一个之前呢? GLInit(); //初始化OpenGL的函数 glutDisplayFunc(GLRender); //显示回调函数的设定,在这里我们将回调函数设定为之前已经定义的GLRender函数,注意这里对回调函数本身的参数和返回值的要求 glutReshapeFunc(GLReshape); //窗口大小调整回调函数的设定,在这里我们将回调函数设定为之前已经定义的GLReshape函数,注意这里对回调函数本身的参数和返回值的要求 glutIdleFunc(GLPostRedisplay); glutKeyboardFunc(GLKeyDown); glutKeyboardUpFunc(GLKeyUp); glutMouseFunc(GLMouse); glutMainLoop(); //只有调用了这个函数,才会出现绘图窗口 return 0; }
int main(int argc, char **argv) { /* Initialize GLUT state - glut will take any command line arguments that pertain to it or X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */ glutInit(&argc, argv); /* Select type of Display mode: Double buffer RGBA color Alpha components supported Depth buffer */ glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH); /* get a 640 x 480 window */ glutInitWindowSize(640, 480); /* the window starts at the upper left corner of the screen */ glutInitWindowPosition(0, 0); /* Open a window */ window = glutCreateWindow("Jeff Molofee's GL Code Tutorial ... NeHe '99"); /* Register the function to do all our OpenGL drawing. */ glutDisplayFunc(&DrawGLScene); /* Go fullscreen. This is as soon as possible. */ glutFullScreen(); /* Even if there are no events, redraw our gl scene. */ glutIdleFunc(&DrawGLScene); /* Register the function called when our window is resized. */ glutReshapeFunc(&ReSizeGLScene); /* Register the function called when the keyboard is pressed. */ glutKeyboardFunc(&keyPressed); glutKeyboardUpFunc(&keyup); /* Initialize our window. */ InitGL(640, 480); /* Start Event Processing Engine */ glutMainLoop(); return 1; }
App::App(int* argc, char** argv) : width(800), height(800), bullet(shadow), lightpos({ 0, -200, 0, 1} ),lightpos2({ 0, 50, 0, 1 }){ glutInit(argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(width, height); glutInitWindowPosition(0, 0); glutCreateWindow("Program OpenGL"); glutDisplayFunc(DisplayFrameCallback); glutIdleFunc(NextFrameCallback); glewInit(); glutKeyboardFunc(KeyDownCallback); glutKeyboardUpFunc(KeyUpCallback); glutSpecialFunc(KeySpecialDownCallback); glutSpecialUpFunc(KeySpecialUpCallback); glutMouseFunc(MouseFuncCallback); ResetPointer(); glutSetCursor(GLUT_CURSOR_NONE); glutPassiveMotionFunc(MotionFuncCallback); GLfloat ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; GLfloat diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f }; GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f }; glMaterialfv(GL_LIGHT0, GL_AMBIENT, ambient); glMaterialfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glMaterialfv(GL_LIGHT0, GL_SPECULAR, specular); glMateriali(GL_FRONT, GL_SHININESS, 50); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glEnable(GL_NORMALIZE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glShadeModel(GL_SMOOTH); glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glEnable(GL_COLOR_MATERIAL); bullet.AddLevel(); LoadTexture(0, "bricks.bmp"); LoadTexture(1, "ntex.bmp"); }
int main(int argc, char * argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(640, 480); glutCreateWindow("Load Wavefront Obj"); glutIdleFunc(&render); glutKeyboardFunc(&key_down); glutKeyboardUpFunc(&key_up); glMatrixMode(GL_PROJECTION); gluPerspective(45, 640.0 / 480.0, 1, 100); glMatrixMode(GL_MODELVIEW); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_CULL_FACE); /* lighting */ { float light_pos[] = { 0, 0, 0, 1 }; float white_light[] = { 1.1, 1.1, 1.1, 1 }; float ambient[] = { 0.4, 0.4, 0.4, 1 }; glLightfv(GL_LIGHT0, GL_POSITION, light_pos); glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light); glLightfv(GL_LIGHT0, GL_SPECULAR, white_light); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); } glClearColor(0, 0, 0, 0); glEnable(GL_DEPTH_TEST); glClearDepth(1.0); camInit(); FILE * fp = fopen("xxx.obj", "r"); go = load_obj(fp); fclose(fp); glutMainLoop(); return 0; }
int main( int argc, char* argv[] ) { glutInit( &argc, argv ); glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB ); // implementation in a class so we can observer events // means we need this painful GLUT <--> class shim... theApp = new testGL; if ( theApp ) { glutInitWindowPosition( 80, 0 ); glutInitWindowSize( theApp->getAppWindowWidth(), theApp->getAppWindowHeight() ); glutCreateWindow( theApp->getAppWindowName().c_str() ); std::string url = ""; if ( 2 == argc ) url = std::string( argv[ 1 ] ); theApp->init( std::string( argv[ 0 ] ), url ); glutKeyboardFunc( glutKeyboard ); glutKeyboardUpFunc( glutKeyboardUp ); glutSpecialFunc( glutSpecial ); glutSpecialUpFunc( glutSpecialUp ); glutMouseFunc( glutMouseButton ); glutPassiveMotionFunc( glutMouseMove ); glutMotionFunc( glutMouseMove ); glutDisplayFunc( glutDisplay ); glutReshapeFunc( glutReshape ); glutIdleFunc( glutIdle ); glutMainLoop(); std::cout << "glutMainLoop returned" << std::endl; delete theApp; }; return 0; }
void GraphicsEngine::initialize(int argc, char **argv) { // Initialize the window. glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(WIDTH, HEIGHT); // Create the window. this->mainWindow = glutCreateWindow(TITLE); // Set keyboard methods. glutKeyboardFunc(&onKeyDownCallback); glutKeyboardUpFunc(&onKeyUpCallback); glutSpecialFunc(&onSpecialKeyDownCallback); glutSpecialUpFunc(&onSpecialKeyUpCallback); // Set mouse callbacks. glutMouseFunc(&onMouseButtonCallback); #ifdef FREEGLUT glutMouseWheelFunc(&onMouseWheelCallback); #endif glutMotionFunc(&onMouseMotionCallback); glutPassiveMotionFunc(&onMousePassiveMotionCallback); // Set display callbacks. glutDisplayFunc(&onDrawCallback); glutReshapeFunc(&onReshapeCallback); // Set a timer to control the frame rate. glutTimerFunc(FRAME_PERIOD, onTimerTickCallback, 0); // Set clear color. glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glDepthFunc(GL_ALWAYS); // Set shading model. glShadeModel(GL_SMOOTH); // Initialize texture loader. TextureLoader::initialize(); // Subscribe to camera to change viewport ortho. Camera::getInstance()->subscribe(this); }
void Game::setupOpenGLDisplay() { // setup gl functions glutDisplayFunc(Display::displayCallback); glutReshapeFunc(Display::reshapeCallback); glutMouseFunc(Display::mousePressedCallback); glutMotionFunc(Display::mouseMovedCallback); glutKeyboardFunc(Display::keyPressedCallback); glutKeyboardUpFunc(Display::keyReleasedCallback); glutSpecialFunc(Display::specKeyPressedCallback); glutSpecialUpFunc(Display::specKeyReleasedCallback); if (Display::display->dynamic) { Display::display->timer.resetClock(); glutTimerFunc( 1000 / Display::desired_fps, Display::timerCallback, Display::display->timer.checkClock(MICRO)); } }
int main(int argc,char **argv) { glutInit(&argc,argv); glutInitWindowSize(640,480); glutInitWindowPosition(1,1); glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE); glutCreateWindow("PC"); glutDisplayFunc(draw); glutIdleFunc(draw); glutKeyboardUpFunc(keyup); glutKeyboardFunc(keyboard); // glutSetKeyCallback(handleKeypress); // glutSetKeyCallback(handleKeypress); // glutFullScreen(); initialize(); glutMainLoop(); return 0; }
int main(int argc, char *argv[]) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH); glutInitWindowSize(1024,576); glutCreateWindow("Shooter"); glutDisplayFunc(display); glutIdleFunc(idle); glutKeyboardFunc(keyboarddown); glutKeyboardUpFunc(keyboardup); setup(); glutMainLoop(); return 0; }
int main(int argc, char **argv){ forceField = FALSE; initShip(); initCenario(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(900, 900); glutCreateWindow("Nave"); init(); glutDisplayFunc(draw); glutTimerFunc(100, timeStep, 1); glutIgnoreKeyRepeat(TRUE); glutKeyboardFunc(keydown); glutKeyboardUpFunc(keyup); glutMainLoop(); return 0; }
int main (int argc, char **argv) { glutInit(&argc, argv); // Initialize GLUT glutInitDisplayMode (GLUT_DOUBLE); // Set up a basic display buffer (now double buffered) glutInitWindowSize (500, 500); // Set the width and height of the window glutInitWindowPosition (100, 100); // Set the position of the window glutCreateWindow ("Your first OpenGL Window"); // Set the title for the window glutDisplayFunc(display); // Tell GLUT to use the method "display" for rendering glutIdleFunc(display); // Tell GLUT to use the method "display" as our idle method as well glutReshapeFunc(reshape); // Tell GLUT to use the method "reshape" for reshaping glutKeyboardFunc(keyPressed); // Tell GLUT to use the method "keyPressed" for key presses glutKeyboardUpFunc(keyUp); // Tell GLUT to use the method "keyUp" for key up events glutMainLoop(); // Enter GLUT's main loop }
int setupGLUT(int *argc, char *argv[]) { // setup the GLUT library which handles the windows for us glutInit(argc, argv); glutInitDisplayMode(GLUT_RGB| GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("inVRs Tutorial: Medieval Town"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboard); glutKeyboardUpFunc(keyboardUp); glutPassiveMotionFunc(motion); glutIdleFunc(display); return winid; } // setupGLUT
//-------------------------------------------------------- // The entry point of the application //-------------------------------------------------------- int main(int argc, char *argv[]) { glutInit(&argc, argv); // GLUT initialization glutInitWindowSize(640, 480); // Initial resolution of the MsWindows Window is 600x600 pixels glutInitWindowPosition(100, 100); // Initial location of the MsWindows window glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // Image = 8 bit R,G,B + double buffer + depth buffer glutCreateWindow("Curves Editor"); // Window is born glutKeyboardFunc(onKeyboard); glutKeyboardUpFunc(onKeyboardUp); //glutReshapeFunc(onReshape); glutMouseFunc(onMouse); glutDisplayFunc(onDisplay); // Register event handlers glutMotionFunc(onMouseMotionFunc); // glutIdleFunc(onIdle); glutMainLoop(); // Event loop return 0; }
/* This function sets up the windowing related glut calls */ void glut_setup (){ glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH); glutInitWindowSize(700,700); glutInitWindowPosition(20,20); glutCreateWindow("Transformer"); /* set up callback functions */ glutDisplayFunc(my_display); glutReshapeFunc(my_reshape); glutMouseFunc(my_mouse); glutKeyboardFunc(my_keyboard); glutKeyboardUpFunc( my_keyboard_up ); glutTimerFunc( 20, my_TimeOut, 0 );/* schedule a my_TimeOut call with the ID 0 in 20 seconds from now */ return; }
void initWindow(int argc, char** argv){ glutInit(&argc, argv); //glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE); glutInitDisplayString("rgba double depth=>12 samples>=8"); glutInitWindowPosition(565, 0); glutInitWindowSize(500, 500); glutCreateWindow("HUniplacer 3D"); // register callbacks glutSpecialFunc(specialHandler); glutSpecialUpFunc(specialUpHandler); glutKeyboardFunc(keyHandler); glutKeyboardUpFunc(keyUpHandler); glutDisplayFunc(render); glutReshapeFunc(resize); glutIdleFunc(render); }
void GameProcess::Init(int argc, char **argv) { snake[0].x = 6; snake[0].y = 6; snake[1].x = 6; snake[1].y = 5; snake[2].x = 6; snake[2].y = 4; snake[3].x = 6; snake[3].y = 3; placeEat(); camera = new Camera((float) N / 2.0, 15, 22); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(w, h); glutInitWindowPosition(100, 100); glutCreateWindow("Game_Snake"); cout << "Sozdano" << endl; //glViewport(0, 0, w, h); //glMatrixMode(GL_PROJECTION); //glLoadIdentity(); //gluPerspective(45.0f, (float) w / (float) h, 0.1, 1000); vector3 campos = camera->getPosition(); //gluLookAt(campos.x, campos.y, campos.z, (float) N / 2.0, 0, // -(float) M / 2.0, 0, 1, 0); //glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glutDisplayFunc(Draw); glutReshapeFunc(Reshape); glutTimerFunc(60, Timer, 0); glutTimerFunc(60, TimerUpdate, 0); glEnable(GL_DEPTH_TEST); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glutKeyboardFunc(KeyboardWrapper); glutKeyboardUpFunc(KeyboardUpWrapper); glutMainLoop(); }
void WindowsManager::createWindows(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_MULTISAMPLE | GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH ); if(m_subWindow) glutInitWindowSize(IntialSize*2,IntialSize); else glutInitWindowSize(IntialSize,IntialSize); m_window1 = glutCreateWindow("Haptic launch"); glutPositionWindow(IntialPosition,IntialPosition); m_dt.init1(); glutReshapeFunc(m_reshape1); glutDisplayFunc(m_display1); glutKeyboardFunc(m_keyboard1); glutKeyboardUpFunc(m_keyboardUp1); glutMouseFunc(m_mouse1); glutMotionFunc(m_motion1); glutEntryFunc(m_entry1); /*glutInitWindowSize(IntialSize,IntialSize); m_window2 = glutCreateWindow("Dual Touch 2"); glutPositionWindow(IntialPosition+IntialSize+IntialMargin,IntialPosition); m_dt.init2(); glutReshapeFunc(m_reshape2); glutDisplayFunc(m_display2); glutKeyboardFunc(m_keyboard2); glutKeyboardUpFunc(m_keyboardUp2); glutMouseFunc(m_mouse2); glutMotionFunc(m_motion2); glutEntryFunc(m_entry2);*/ //setFullScreen(m_fullScreen); //glutTimerFunc(0,m_idle2,0); glutIdleFunc(m_idle); glutMainLoop(); }
int main(int argc, char **argv) { glutInit(&argc, argv); int display_mode = GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE; #ifdef OSX_CORE3 display_mode |= GLUT_3_2_CORE_PROFILE; #endif glutInitDisplayMode(display_mode); glutInitWindowSize(width, height); glutInitWindowPosition(0, 0); window_id = glutCreateWindow("Assignment"); #ifdef __GLEW_H__ GLenum err = glewInit(); if (GLEW_OK != err) { cerr << "Error: " << glewGetErrorString(err) << endl; exit(1); } cout << "Status: Using GLEW " << glewGetString(GLEW_VERSION) << endl; #endif cout << "Status: Using OpenGL " << glGetString(GL_VERSION) << endl; cout << "Status: Using GLSL " << glGetString(GL_SHADING_LANGUAGE_VERSION) << endl; working_directory = string(argv[0]).substr(0, string(argv[0]).find_last_of("/\\")) + "/"; init(); create_menu(); glutReshapeFunc(reshapefunc); glutDisplayFunc(displayfunc); glutIdleFunc(idlefunc); glutPassiveMotionFunc(pmotionfunc); glutMotionFunc(motionfunc); glutMouseFunc(mousefunc); glutKeyboardFunc(keydownfunc); glutKeyboardUpFunc(keyupfunc); glutMainLoop(); }
int glutmain(int argc, char **argv,int width,int height,const char* title,DemoApplication* demoApp, int posX, int posY, bool showWindow) { gDemoApplication = demoApp; glutInit(&argc, argv); //glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL); glutInitWindowPosition(posX, posY); glutInitWindowSize(width, height); glutCreateWindow(title); #ifdef BT_USE_FREEGLUT glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); #endif gDemoApplication->myinit(); glutKeyboardFunc(glutKeyboardCallback); glutKeyboardUpFunc(glutKeyboardUpCallback); glutSpecialFunc(glutSpecialKeyboardCallback); glutSpecialUpFunc(glutSpecialKeyboardUpCallback); glutReshapeFunc(glutReshapeCallback); //createMenu(); glutIdleFunc(glutMoveAndDisplayCallback); glutMouseFunc(glutMouseFuncCallback); glutPassiveMotionFunc(glutMotionFuncCallback); glutMotionFunc(glutMotionFuncCallback); glutDisplayFunc( glutDisplayCallback ); glutMoveAndDisplayCallback(); //enable vsync to avoid tearing on Apple (todo: for Windows) #if defined(__APPLE__) && !defined (VMDMESA) int swap_interval = 1; CGLContextObj cgl_context = CGLGetCurrentContext(); CGLSetParameter(cgl_context, kCGLCPSwapInterval, &swap_interval); #endif if (!showWindow) glutHideWindow(); glutMainLoop(); return 0; }