int main(int argc, char** argv) { glutInit(&argc, argv); int width = 500; int height = 500; unsigned int displayMode = GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL; displayMode = defaults(displayMode, width, height); glutInitDisplayMode (displayMode); glutInitContextVersion (3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); #ifdef DEBUG glutInitContextFlags(GLUT_DEBUG); #endif glutInitWindowSize (width, height); glutInitWindowPosition (300, 200); int window = glutCreateWindow (argv[0]); glload::LoadFunctions(); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); if(!glload::IsVersionGEQ(3, 3)) { printf("Your OpenGL version is %i, %i. You must have at least OpenGL 3.3 to run this tutorial.\n", glload::GetMajorVersion(), glload::GetMinorVersion()); glutDestroyWindow(window); return 0; } if(glext_ARB_debug_output) { glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); glDebugMessageCallbackARB(DebugFunc, (void*)15); } init(); UserListener listener; Leap::Controller controller; controller.addListener(listener); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutMainLoop(); controller.removeListener(listener); return 0; }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(640, 480); glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE); glutCreateWindow("OpenGL basic"); glewExperimental = GL_TRUE; GLenum err = glewInit(); if (err != GLEW_OK) { std::cerr << "GLEW init error!"; return -1; } glutReshapeFunc(reshape); glutDisplayFunc(draw); glutKeyboardFunc(keyboard); initGL(); glutMainLoop(); return 0; }
void DarkenManager::setupGL(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowPosition(20, 20); glutInitWindowSize(WINDOW_SIZE_WIDTH, WINDOW_SIZE_HEIGHT); glutInitContextVersion (3, 2); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); glutCreateWindow( argv[0] ); glewInit(); glewExperimental = GL_TRUE; // Required in openGL 3.1 forward compatible contexts because // GL_EXTENSIONS is deprecated argument for glGetString GLenum glewErr = glewInit(); if(glewErr != GLEW_OK) { std::stringstream err; err << "Error initializing GLEW: " << glewGetErrorString(glewErr); throw std::runtime_error(err.str()); } glGetError(); // glewInit finner ikke extension stringen // men setter funksjonspekere for core funksjoner }
uint GraphicsCore::Initialize(int argc, char** argv) { // initialise freeGLUT glutInit(&argc, argv); // create Window on O/S using freeGLUT glutInitWindowSize(windowWidth, windowHeight); // specify size of window glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); // create window with freeGLUT int windowHandle = glutCreateWindow(windowTitle); if (windowHandle < 1) { printf("ERROR: creating window\n"); exit(1); } // get version info and print it to the console (have a look to see what version you can support) const GLubyte* renderer = glGetString(GL_RENDERER); // get renderer string const GLubyte* vendor = glGetString(GL_VENDOR); // vendor const GLubyte* version = glGetString(GL_VERSION); // version as a string const GLubyte* glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION); // glsl version string GLint major, minor; glGetIntegerv(GL_MAJOR_VERSION, &major); // get integer (only if gl version > 3) glGetIntegerv(GL_MINOR_VERSION, &minor); // get dot integer (only if gl version > 3) printf("OpenGL on %s %s\n", vendor, renderer); printf("OpenGL version supported %s\n", version); printf("GLSL version supported %s\n", glslVersion); printf("Will now set GL to version %i.%i\n", major, minor); // force GL to use a specific version glutInitContextVersion(major, minor); // set version of gl to 4.1 glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); // do not allow deprecated glutInitContextProfile(GLUT_CORE_PROFILE); // force current version of spec glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); // start GLEW (that's it! - we could also use GLEW to check for driver support of all GL extensions) GLenum glErr = glGetError(); while (glErr != GL_NO_ERROR) { printf("glError: %s\n", gluErrorString(glErr)); } // set-up callbacks. we can also do a keyboard and mouse input callback, and various others (see freeGLUT website) //glutDisplayFunc(renderCallback); // register rendering callback glutReshapeFunc(resizeCallback); // register callback for reshape // set colour to clear screen buffer to glClearColor(0.1f, 0.1f, 0.1f, 1.0f); // enable some useful GL behaviours glEnable(GL_DEPTH_TEST); // enable depth-testing glDepthFunc(GL_LESS); // set depth-testing function type glEnable(GL_CULL_FACE); // enable culling of back-faces glCullFace(GL_BACK); // enable culling of back-faces glFrontFace(GL_CCW); // use clock-wise 'winding' to define order used to make fronts of polygons // start GLEW (that's it! - we could also use GLEW to check for driver support of all GL extensions) GLenum err = glewInit(); if (GLEW_OK != err) { printf("ERROR starting GLEW: %s\n", glewGetErrorString(err)); } return 1; }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitContextVersion(4, 0); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutInitWindowSize(winw, winh); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); if (glutCreateWindow("Waiting for framerate data...") < 1) { fprintf(stderr, "ERROR: Could not create a window.\n"); return EXIT_FAILURE; } GLenum result = glewInit(); if (result != GLEW_OK) { fprintf(stderr, "ERROR: %s\n", glewGetErrorString(result)); return EXIT_FAILURE; } createshaders(); createvbo(); glClearColor(0.0f, 0.0f, 1.0f, 1.0f); glutDisplayFunc(display); glutIdleFunc(idle); glutReshapeFunc(resize); glutTimerFunc(0, timer, 0); fprintf(stdout, "INFO: OpenGL Version: %s\n", glGetString(GL_VERSION)); glutMainLoop(); return EXIT_SUCCESS; }
int main(int argc, char** argv) { // msgpr::initialize(print); glutInit(&argc, argv); glutInitWindowSize(WIN_WIDTH, WIN_HEIGHT); #ifdef __APPLE__ glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_3_2_CORE_PROFILE); glutCreateWindow(argv[0]); #else //glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); glutInitContextVersion(3,3); glutInitContextFlags (GLUT_CORE_PROFILE | GLUT_DEBUG); glutInitContextProfile(GLUT_FORWARD_COMPATIBLE); glutCreateWindow(argv[0]); if (glewInit()) { std::cerr << "Unable to initialize GLEW ... exiting" << std::endl; exit(EXIT_FAILURE); } #endif init(); glutDisplayFunc(display); #ifdef __FREEGLUT_H__ glutMouseWheelFunc(mouse_wheel); #endif glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboard); glutSpecialFunc(special); glutTimerFunc(30, timer, 1); glutMainLoop(); }
int main(int argc, char **argv) { // Initialization of GLUT glutInit(&argc, argv); glutInitContextVersion(3, 1); glutInitContextFlags(GLUT_DEBUG); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(512, 512); glutCreateWindow( __FILE__ ); // Init GLEW GLenum err = glewInit(); if (GLEW_OK != err) { std::cerr << "Error: " << glewGetErrorString(err) << std::endl; return 1; } if(!GLEW_VERSION_3_1) { std::cerr << "Driver does not support OpenGL 3.1" << std::endl; return 1; } // Attach handlers glutDisplayFunc(myDisplay); glutReshapeFunc(myReshape); // A nasty trick to get a shutdown handler atexit(myShutdown); // Application specific initialization myInit(); // Run the GLUT main loop glutMainLoop(); return 0; }
int main(int argc, char** argv) { glutInit(&argc, argv); glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(800, 600); glutInitWindowPosition(100, 100); glutCreateWindow(argv[0]); init(); glutDisplayFunc(display); glutReshapeFunc(reshape); glutSpecialFunc(keybs); glutKeyboardFunc(keyPress); glutKeyboardUpFunc(keyRel); glutTimerFunc(50, animate, 0); glutMainLoop(); delete [] Vertices; delete [] Colors; delete [] Indices; return 0; }
int main(int argc, char** argv) { int menuA; glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* add command line argument "classic" for a pre-3.x context */ if ((argc != 2) || (strcmp (argv[1], "classic") != 0)) { glutInitContextVersion (3, 1); glutInitContextFlags (GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); } glutInitWindowSize (500, 500); glutInitWindowPosition (100, 100); glutCreateWindow (argv[0]); dumpInfo (); init (); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc (keyboard); /* Add a menu. They have their own context and should thus work with forward compatible main windows too. */ menuA = glutCreateMenu(samplemenu); glutAddMenuEntry("Sub menu A1 (01)",1); glutAddMenuEntry("Sub menu A2 (02)",2); glutAddMenuEntry("Sub menu A3 (03)",3); glutSetMenu(menuA); glutAttachMenu(GLUT_RIGHT_BUTTON); glutMainLoop(); return 0; }
void InitWindow(int argc, char* argv[]) { glutInit(&argc, argv); glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutSetOption( GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS ); glutInitWindowSize(CurrentWidth, CurrentHeight); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX); if(WindowHandle < 1) { fprintf( stderr, "ERROR: Could not create a new rendering window.\n" ); exit(EXIT_FAILURE); } glutReshapeFunc(ResizeFunction); glutDisplayFunc(RenderFunction); glutIdleFunc(IdleFunction); glutTimerFunc(0, TimerFunction, 0); glutCloseFunc(Cleanup); }
Application::Application(const std::string& title, int width, int height) { static int argc = 1; static const char* argv[] = { "AVT" }; glutInit(&argc, (char**)argv); glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); mMouseX = mMouseY = 0; mNow = mDelta = 0.0f; mLastTime = timestamp(); mWindow = new Window(title, width, height); mRenderer = new Renderer; gCurrentInstance = this; // glutCloseFunc(cleanupCallBack); glutDisplayFunc(displayCallback); glutIdleFunc(idleCallback); glutMouseFunc(mouseCallback); glutMotionFunc(motionCallback); glutReshapeFunc(reshapeCallback); glutKeyboardFunc(keyboardCallback); }
static int InitContextFlags(lua_State *L) { int i, n, rc; int opt, val, arg = 1; if(!lua_isnoneornil(L, 1)) /* set */ { val = 0; while(!lua_isnoneornil(L, arg)) { opt = checkoption(L, arg, NULL, FlagsStrings); val |= FlagsCodes[opt]; arg++; } glutInitContextFlags(val); } /* get */ n = sizeof(FlagsCodes)/sizeof(FlagsCodes[0]); rc = 0; val = glutGet(GLUT_INIT_FLAGS); for(i = 0; i <n; i ++) { if(val & FlagsCodes[i]) { lua_pushstring(L, FlagsStrings[i]); rc++; } } return rc; }
void create_window(int argc, char* argv[]) { glutInit(&argc, argv); glutInitContextVersion(DOBO_MAJOR_VERSION, DOBO_MINOR_VERSION); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutSetOption( GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS ); glutInitWindowSize(window_width, window_height); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); window_handle = glutCreateWindow(WINDOW_TITLE_PREFIX); if(window_handle < 1) { fprintf( stderr, "ERROR: Could not create a rendering window.\n" ); exit(EXIT_FAILURE); } glutReshapeFunc(window_resize_func); glutDisplayFunc(window_render_func); glutIdleFunc(idle_func); glutTimerFunc(0, timer_func, 0); glutCloseFunc(shutdown); glutKeyboardFunc(keyboard_func); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); /* add command line argument "classic" for a pre-3.x context */ if ((argc != 2) || (strcmp(argv[1], "classic") != 0)) { glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); } glutInitWindowSize(500, 500); glutInitWindowPosition(100, 100); int windowID = glutCreateWindow("Stenciltest"); if (ogl_LoadFunctions() == ogl_LOAD_FAILED) { glutDestroyWindow(windowID); return 1; } init(); readback_buffer(); writeback_buffer(); readback_buffer(); glutDisplayFunc(draw); glutKeyboardFunc(keyboard); glutMainLoop(); return 0; }
//Initialization functions void initWindow(int argc, _TCHAR* argv[], const BratsGLUtilities::WindowData& winData) { //Initialize glut and pass "command-line" parameters to it. glutInit(&argc, (char**) argv); //TODO: Find out the correct type of C++ //cast to use //Initialize an OpenGL context. //Get an OpenGL 4.1 compatible context - glutInitContextVersion(4, 1); #ifndef REQUEST_DEBUG_PROFILE //which is forward compatible (General) - glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); #else //which is forward compatible and a debug context (For debug builds) - glutInitContextFlags(GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); #endif //and is a core profile context without Fixed Function Pipeline stuff. glutInitContextProfile(GLUT_CORE_PROFILE); //Tell GLUT to return to the main program on window close. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); //Initialize OpenGL for double buffering, RGBA colour and depth buffering. glutInitDisplayMode(GLUT_DEPTH | GLUT_RGBA | GLUT_DOUBLE); //Initialize a GLUT window from the winData struct passed in. glutInitWindowSize(winData.width, winData.height); //Try creating a GLUT window. int windowHandle = glutCreateWindow(winData.windowTitle.c_str()); //See if that worked //If window creation failed, report an error and exit with a fail status. if(windowHandle < 1) { std::cerr << "Failed to create rendering window." << std::endl; exit(EXIT_FAILURE); } //Register callbacks. glutDisplayFunc(draw); glutReshapeFunc(resize); //Initialize OpenGL state (and GLEW). initGL(); }
int main(int argc, char **argv) { // GLUT initialization glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA|GLUT_MULTISAMPLE); glutInitContextVersion (4, 2); glutInitContextProfile (GLUT_CORE_PROFILE ); glutInitContextFlags(GLUT_DEBUG); glutInitWindowPosition(100,100); glutInitWindowSize(640,360); glutCreateWindow("Lighthouse3D - Simplest Demo"); // Callback Registration glutDisplayFunc(renderScene); glutReshapeFunc(changeSize); glutIdleFunc(renderScene); // return from main loop glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); // Init GLEW glewExperimental = GL_TRUE; glewInit(); if (glewIsSupported("GL_VERSION_4_2")) printf("Ready for OpenGL 4.2\n"); else { printf("OpenGL 4.2 not supported\n"); exit(1); } printf ("Vendor: %s\n", glGetString (GL_VENDOR)); printf ("Renderer: %s\n", glGetString (GL_RENDERER)); printf ("Version: %s\n", glGetString (GL_VERSION)); printf ("GLSL: %s\n", glGetString (GL_SHADING_LANGUAGE_VERSION)); int param; glGetIntegerv(GL_CONTEXT_PROFILE_MASK, ¶m); if (param == GL_CONTEXT_CORE_PROFILE_BIT) printf("Context Profile: Core\n"); else printf("Context Profile: Compatibility\n"); glGetIntegerv(GL_CONTEXT_FLAGS, ¶m); setupShaders(); initGL(); // GLUT main loop glutMainLoop(); return(1); }
void initGlut(int argc, char ** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA ); glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_CORE_PROFILE | GLUT_DEBUG); glutInitContextProfile(GLUT_FORWARD_COMPATIBLE); glutInitWindowSize(WIDTH, HEIGHT); windowHandler = glutCreateWindow("Graphic Engine 0.001"); }
/*----------------------------------------------------------------------------------------------- Description: Program start and end. Parameters: argc The number of strings in argv. argv A pointer to an array of null-terminated, C-style strings. Returns: 0 if program ended well, which it always does or it crashes outright, so returning 0 is fine Exception: Safe Creator: John Cox (2-13-2016) -----------------------------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { glutInit(&argc, argv); int width = 500; int height = 500; unsigned int displayMode = GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL; displayMode = Defaults(displayMode, width, height); glutInitDisplayMode(displayMode); glutInitContextVersion(4, 4); glutInitContextProfile(GLUT_CORE_PROFILE); // enable this for automatic message reporting (see OpenGlErrorHandling.cpp) #define DEBUG #ifdef DEBUG glutInitContextFlags(GLUT_DEBUG); #endif glutInitWindowSize(width, height); glutInitWindowPosition(300, 200); int window = glutCreateWindow(argv[0]); glload::LoadTest glLoadGood = glload::LoadFunctions(); // ??check return value?? glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); if (!glload::IsVersionGEQ(3, 3)) { printf("Your OpenGL version is %i, %i. You must have at least OpenGL 3.3 to run this tutorial.\n", glload::GetMajorVersion(), glload::GetMinorVersion()); glutDestroyWindow(window); return 0; } if (glext_ARB_debug_output) { glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); glDebugMessageCallbackARB(DebugFunc, (void*)15); } Init(); glutDisplayFunc(Display); glutReshapeFunc(Reshape); glutKeyboardFunc(Keyboard); glutMainLoop(); CleanupAll(); return 0; }
//////////////////////////////////////////////////////////////////////////////// // Main // //////////////////////////////////////////////////////////////////////////////// int main(int argc, char** argv) { const GLuint CONTEXT_MAJOR = 4; const GLuint CONTEXT_MINOR = 2; // init glut glutInit(&argc, argv); glutInitContextVersion(CONTEXT_MAJOR ,CONTEXT_MINOR); glutInitContextFlags(GLUT_DEBUG); glutInitContextProfile(GLUT_CORE_PROFILE); // glutInitContextFlags(GLUT_DEBUG | GLUT_FORWARD_COMPATIBLE); // glutInitContextProfile(GLUT_CORE_PROFILE); // build window glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(800, 600); glutInitWindowPosition(0, 0); glutCreateWindow("OpenGL"); // init glew glewExperimental = GL_TRUE; GLenum err = glewInit(); if(GLEW_OK != err) { std::stringstream ss; ss << err; std::cerr << "glewInit() gave error " << ss.str() << std::endl; return 1; } // glewInit generates an INVALID_ENUM error for some reason... glGetError(); // set callbacks glutCloseFunc(&on_clean); glutReshapeFunc(&on_resize); glutDisplayFunc(&on_update); glutKeyboardFunc(&on_key_down); glutMouseFunc(&on_mouse_button); glutPassiveMotionFunc(&on_mouse_motion); glutMotionFunc(&on_mouse_motion); glutMouseWheelFunc(&on_mouse_wheel); // run on_init(); // glutMainLoop(); return 0; }
int main(int argc, char **argv) { // GLUT initialization glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA|GLUT_MULTISAMPLE); glutInitContextVersion (3, 3); glutInitContextProfile (GLUT_CORE_PROFILE ); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); glutInitWindowPosition(100,100); glutInitWindowSize(WinX, WinY); WindowHandle = glutCreateWindow(CAPTION); // Callback Registration glutDisplayFunc(renderScene); glutReshapeFunc(changeSize); glutIdleFunc(idle); // Mouse and Keyboard Callbacks glutKeyboardFunc(keyPressed); //Funcao a ser chamada ao pressionar uma tecla glutIgnoreKeyRepeat(1); //Impedir que, ao pressionar uma tecla continuamente, seja chamada a funcao keyPressed repetidamente glutKeyboardUpFunc(keyReleased); //Funcao a ser chamada ao libertar uma tecla glutMouseFunc(processMouseButtons); glutMotionFunc(processMouseMotion); glutMouseWheelFunc ( mouseWheel ) ; glutTimerFunc(0,timer,0); glutTimerFunc(0, refresh, 0); glutTimerFunc(0, iterate, 0); // return from main loop glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); // Init GLEW glewExperimental = GL_TRUE; glewInit(); printf ("Vendor: %s\n", glGetString (GL_VENDOR)); printf ("Renderer: %s\n", glGetString (GL_RENDERER)); printf ("Version: %s\n", glGetString (GL_VERSION)); printf ("GLSL: %s\n", glGetString (GL_SHADING_LANGUAGE_VERSION)); if (!setupShaders()) return(1); init(); // GLUT main loop glutMainLoop(); return(0); }
/** main function */ int main(int argc, char* argv[]) { std::cout << "Starting ex0..." << std::endl; // Initialize GLUT glutInit(&argc, argv) ; #ifdef __APPLE__ glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_3_2_CORE_PROFILE) ; #else glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); glutInitContextProfile(GLUT_CORE_PROFILE); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); #endif glutInitWindowSize(WINDOW_SIZE, WINDOW_SIZE); glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y); glutCreateWindow("CG Ex0"); // Initialize GLEW glewExperimental = GL_TRUE; int glewStatus = glewInit(); if (glewStatus != GLEW_OK) { std::cerr << "Unable to initialize GLEW ... exiting" << std::endl; exit(1); } #ifdef __APPLE__ GLint sync = 1; CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &sync); #endif // Set callback functions: glutDisplayFunc(display) ; glutReshapeFunc(windowResize) ; glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(motion); glutTimerFunc(100, timer, 0); // uint millis int value // Init anything that can be done once and for all: _model.init(); // Set clear color to black: glClearColor(0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); // Start events/drawing loop glutMainLoop(); return 0; }
gl_window init_gl_context(int w, int h, const char* name){ glutInit(0,0);//might need to pass a non-null pontier as first arg glutInitContextVersion(3,3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutSetOption(GLUT_MULTISAMPLE, 4);//4xAA glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_MULTISAMPLE); glutInitWindowSize(w,h); glutCreateWindow(name); atexit(glutExit); glutCloseFunc(glut_set_window_should_close); }
GLUTwrapper::GLUTwrapper ( EventHandlerBase *h ) { if (handler) { std::cerr << "Only one instance of the GLUTwrapper class allowed!" << std::endl; std::exit(1); } int a = h->getArgc(); glutInit(&a,h->getArgv()); glutInitContextVersion (3, 3); glutInitContextFlags (GLUT_CORE_PROFILE | GLUT_DEBUG); glutInitWindowSize(h->getWindowWidth(),h->getWindowHeight()); glutInitWindowPosition(10,10); glutInitDisplayMode(h->getWindowMode()); windowID = glutCreateWindow("A window"); glewExperimental=GL_TRUE; GLenum err=glewInit(); if(err!=GLEW_OK) { //Problem: glewInit failed, something is seriously wrong. cout<<"glewInit failed, aborting."<<endl; exit(1); } //if (glewIsSupported("GL_VERSION_3_1")) // cout << "Ready for OpenGL 3.1" << endl; //else // { // cerr << "OpenGL 3.1 not supported" << endl; // exit(1); // } handler = h; glutMouseFunc(mouseButton); glutMotionFunc(activeMotion); glutPassiveMotionFunc(passiveMotion); glutIdleFunc(idleFunction); glutDisplayFunc(draw); glutVisibilityFunc(visibilityFunction); glutSpecialFunc(specialFunction); glutEntryFunc(entryFunction); glutKeyboardFunc(keyPressed); glutReshapeFunc(resize); h->initializeGL(); }
// Make a window for doing OpenGL void makeWindow(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitContextVersion(4, 2); #ifdef DEBUG glutInitContextFlags(GLUT_CORE_PROFILE | GLUT_DEBUG); #else glutInitContextFlags(GLUT_COMPATIBILITY_PROFILE); #endif // Open window / full screen #ifdef FULLSCREEN char modeString[255] = ""; sprintf(modeString, "%dx%d:24", WINDOW_WIDTH, WINDOW_HEIGHT); glutGameModeString(modeString); glutEnterGameMode(); #else glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT); glutCreateWindow(WINDOW_TITLE); #endif // Use GLEW, and make sure it imports EVERYTHING glewExperimental = GL_TRUE; glewInit(); #ifdef DEBUG registerGlDebugLogger(GL_DEBUG_SEVERITY_MEDIUM); #endif // Set up OpenGL features glEnable(GL_DEPTH_TEST); glClearDepth(1.0f); glDepthFunc(GL_LEQUAL); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); }
//Ruft alle FreeGLUT Funktionen um ein Window zu öffnen auf void InitWindow(int argc, char* argv[]) { //Initialisiert die FreeGLUT lib (ist die erste FreeGLUT Funktion, die aufgerufen werden sollte) glutInit(&argc, argv); //*************Angabe des OpenGL Kontextes************* glutInitContextVersion(3, 3);//OpenGL Version 3.3 glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);//Setzt die Kompatibilität so, dass es auch mit späteren OpenGL Versionen funktioniert glutInitContextProfile(GLUT_CORE_PROFILE);//nutzt OpenGL nur mit den neuesten Funktionen (compatibility mode = um ältere Versionen zu nutzen) //***************************************************** //GLUT_ACTION_ON_WINDOW_CLOSE und GLUT_ACTION_GLUTMAINLOOP_RETURNS bewirkt, dass die mainLoop Funktion das Programm nicht beendet sondern zum Programm zurückkehrt glutSetOption( GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS ); //setzt die Größe des render-Fensters glutInitWindowSize(CurrentWidth, CurrentHeight); //Displaymode gibt an, wie das Gerät die Szene rendern soll //GLUT_DEPTH = enthält die Tiefeninformation von Z für jeden Pixel (verhindert, dass neue Objekte nicht Objekte näher an der Kamera überlappen) //GLUT_DOUBLE = Flag um doppelbuffering zu aktivieren (reduziert flackern - 2 Buffer werden immer wieder Ausgewechselt - einer zum anzeigen, der andere zum rendern) //GLUT_RGBA = Flag um Farbkompositionen anzugeben (RGBA = Rot, Grün, Blau, Alpha) //es sind mehrere zusätzliche Optionen möglich glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); //erstellt ein Window und speichert das Handle dazu in WindowHandle (Parameter ist Window Title String) WindowHandle = glutCreateWindow("Test"); //Handle checken, ob er kleiner als 1 ist, wenn ja wird Error geworfen und Programm beendet if(WindowHandle < 1) { fprintf( stderr, "ERROR: Could not create a new rendering window.\n" ); glutExit(); } //Glut function callbacks //TODO: add keyboard and mouse functions glutTimerFunc(0, TimerFunction, 0); //startet direkt die Funktion TimerFunction und übergibt 0 (damit der Titel am anfang nicht geändert wird) glutReshapeFunc(ResizeFunction); //wird jedes mal aufgerufen, wenn das Window verkleinert oder vergrößert wird glutDisplayFunc(RenderFunction); //wird jedes mal ausgeführt, wenn die szene auf den Bildschirm gezeichnet werden soll glutIdleFunc(IdleFunction); //macht die Idle Funktion bekannt glutKeyboardFunc(KeyEventProcessing); }
int main (int argc, char **argv) { glutInit(&argc, argv); // Done TODO: activate stencil buffer // glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL); glutInitContextVersion(3,3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); windowWidth = 512; windowHeight = 512; glutInitWindowSize(windowWidth, windowHeight); glutInitWindowPosition(100, 100); glutCreateWindow("Exercise 10 - Shadow Volumes"); glutDisplayFunc(updateGL); glutIdleFunc(idle); glutKeyboardFunc(keyboardEvent); glutMouseFunc(mouseEvent); glutMotionFunc(mouseMoveEvent); glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { std::cout << "(glewInit) - Error: " << glewGetErrorString(err) << std::endl; } std::cout << "(glewInit) - Using GLEW " << glewGetString(GLEW_VERSION) << std::endl; // init stuff // initGL(); // init matrix stacks with identity // glm_ProjectionMatrix.push(glm::mat4(1)); glm_ModelViewMatrix.push(glm::mat4(1)); initShader(); initScene(); // start render loop // if (enableShader()) { glutMainLoop(); disableShader(); // clean up allocated data // deleteShader(); } return 0; }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitContextVersion(3, 0); glutInitContextFlags(GLUT_CORE_PROFILE | GLUT_DEBUG); glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA); glutInitWindowSize(windowWidth, windowHeight); glutCreateWindow("GPGPU 3. labor: glsl"); init(); glutDisplayFunc(draw); glutMouseFunc(mouse); glutMainLoop(); return (0); }
void setupGLUT(int argc, char* argv[]) { glutInit(&argc, argv); glutInitContextVersion(3, 3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutInitWindowSize(WinX, WinY); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); WindowHandle = glutCreateWindow(CAPTION); if(WindowHandle < 1) { std::cerr << "ERROR: Could not create a new rendering window." << std::endl; exit(EXIT_FAILURE); } }
void init_graphics(int nargs, char** args, const char* title_bar, int x, int y) { /*KKCODEBLOCKSSUCKS*/#define SKMK_GLUT #ifdef SKMK_GLUT glutInit(&nargs, args); glutInitDisplayMode(GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL); //kk glutInitContextVersion(3, 3); glutInitContextVersion(3, 1); glutInitContextProfile(GLUT_CORE_PROFILE); #ifdef SKMK_DEBUG glutInitContextFlags(GLUT_DEBUG); #endif glutInitWindowSize(x, y); glutInitWindowPosition(300, 300); int window = glutCreateWindow(title_bar); ogl_load_funcs(); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); skmk.ogl_state = malloc(sizeof(struct ogl_state)); init_ogl(skmk.ogl_state); //!! glutDisplayFunc(ogl_draw); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutMainLoop(); #elif SKMK_SDL2 //SDL_GLContext glcontext = SDL_GL_CreateContext(SDL_WINDOW); { SDL_Init(SDL_INIT_EVERYTHING); //TODO: Check errors K_SDL_WINDOW = SDL_CreateWindow(title_bar, 0, 0, x, y, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); K_GL_CONTEXT = SDL_GL_CreateContext(K_SDL_WINDOW); ogl_init(); } #else #error You have to either use GLUT or SDL. #endif }
int main (int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitContextVersion(3,3); glutInitContextFlags(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutInitWindowSize (512, 512); glutInitWindowPosition (100, 100); glutCreateWindow("Exercise 03 - More Bunnies!"); glutDisplayFunc(updateGL); glutIdleFunc(idle); glutKeyboardFunc(keyboardEvent); glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { std::cout << "(glewInit) - Error: " << glewGetErrorString(err) << std::endl; } std::cout << "(glewInit) - Using GLEW " << glewGetString(GLEW_VERSION) << std::endl; // init stuff // initGL(); // init matrix stacks // glm_ProjectionMatrix.push(glm::mat4(2.414214, 0.000000, 0.000000, 0.000000, 0.000000, 2.414214, 0.000000, 0.000000, 0.000000, 0.000000, -1.002002, -1.000000, 0.000000, 0.000000, -0.020020, 0.000000)); glm_ModelViewMatrix.push(glm::mat4(0.707107, -0.408248, 0.577350, 0.000000, 0.000000, 0.816497, 0.577350, 0.000000, -0.707107, -0.408248, 0.577350, 0.000000, 0.000000, 0.000000, -1.732051, 1.000000)); initShader(); initScene(); // start render loop // if (enableShader()) { glutMainLoop(); disableShader(); // clean up allocated data // deleteScene(); deleteShader(); } return 0; }