void initGL(int *argc, char **argv) { glutInit(argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize(width, height); glutCreateWindow(sSDKsample); glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutReshapeFunc(reshape); glutIdleFunc(idle); #if defined (__APPLE__) || defined(MACOSX) atexit(cleanup); #else glutCloseFunc(cleanup); #endif printf("Press '+' and '-' to change filter width\n"); printf("0, 1, 2 - change filter order\n"); glewInit(); if (!glewIsSupported("GL_VERSION_2_0 GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object")) { fprintf(stderr, "Required OpenGL extensions missing."); exit(EXIT_FAILURE); } }
void register_callbacks(void) { glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutReshapeFunc(reshape); glutTimerFunc(100, timer_scene, 0); glutCloseFunc(cleanup); }
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 initGL(int *argc, char **argv) { printf("Initializing GLUT...\n"); glutInit(argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(imageW, imageH); glutInitWindowPosition(512 - imageW / 2, 384 - imageH / 2); glutCreateWindow(argv[0]); glutDisplayFunc(displayFunc); glutKeyboardFunc(keyboard); glutTimerFunc(REFRESH_DELAY, timerEvent,0); printf("OpenGL window created.\n"); #if defined (__APPLE__) || defined(MACOSX) atexit(cleanup); #else glutCloseFunc(cleanup); #endif glewInit(); printf("Loading extensions: %s\n", glewGetErrorString(glewInit())); if (!glewIsSupported("GL_VERSION_1_5 GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object")) { fprintf(stderr, "Error: failed to get minimal extensions for demo\n"); fprintf(stderr, "This sample requires:\n"); fprintf(stderr, " OpenGL version 1.5\n"); fprintf(stderr, " GL_ARB_vertex_buffer_object\n"); fprintf(stderr, " GL_ARB_pixel_buffer_object\n"); fflush(stderr); return false; } return 0; }
bool CameraCalib::InitGlutUI(int argc, WCHAR* argvW[]) { srand(unsigned int(time(NULL))); const size_t len = wcsnlen(argvW[0], 1024); std::unique_ptr<char[]> argvuq(new char[len + 1]); char *pStr = (argvuq.get()); size_t lastChar = 0; wcstombs_s(&lastChar, pStr, len, argvW[0], len - 1); pStr[lastChar] = '\0'; char **argv = &pStr; argc = 1; glutInit(&argc, argv); glutInitWindowSize(windowRect[0], windowRect[1]); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // mainWnd = glutCreateWindow("CameraCalib"); GLenum err = glewInit(); if (GLEW_OK != err) { std::wcout << L"Camera Calib" << glewGetErrorString(err) << std::endl; return false; } glutDisplayFunc(clbDisplay); glutKeyboardFunc(clbKeys); glutReshapeFunc(clbReshape); glutMouseFunc(clbMouse); glutCloseFunc(clbExitFunc); glEnable(GL_DEPTH_TEST); return true; }
void game_init(int* argc, char** argv, const char* title) { glutInit(argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(800, 600); glutInitContextVersion(3, 1); glutInitContextProfile(GLUT_FORWARD_COMPATIBLE); glutInitContextProfile(GLUT_CORE_PROFILE); glutCreateWindow(title); glewExperimental = true; glewInit(); glutKeyboardFunc(keyboard_down); glutKeyboardUpFunc(keyboard_up); glutSpecialFunc(keyboard_special_down); glutSpecialUpFunc(keyboard_special_up); glutCloseFunc(window_close); glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); bodies = list_new(); body_program = pipeline_new( shader_new(SHADER_VERTEX, "body.vert"), shader_new(SHADER_FRAGMENT, "body.frag")); glGenVertexArrays(1, &body_vao); glBindVertexArray(body_vao); pipeline_attribute(body_program, "coord", 0); pipeline_attribute(body_program, "color", 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 }
inline Int flua_createGLUTWindow(char* title, int width, int height, bool fullscreen = false) { glutInitWindowPosition((flua_getScreenWidth() - width) / 2, (flua_getScreenHeight() - height) / 2); glutInitWindowSize(width, height); glutInitDisplayMode(GLUT_DOUBLE | GLUT_ALPHA | GLUT_RGB | GLUT_DEPTH); int winId = glutCreateWindow(title); //flua_setVSync(true); // Force first call (not called automatically on Windows) #ifdef _WIN32 flua_onReshape(width, height); #endif // Mouse glutMotionFunc(flua_onMouseMove); glutPassiveMotionFunc(flua_onMouseMove); glutReshapeFunc(flua_onReshape); // Keyboard glutKeyboardFunc(flua_onKeyDown); glutKeyboardUpFunc(flua_onKeyUp); glutSpecialFunc(flua_onSpecialKeyDown); glutSpecialUpFunc(flua_onSpecialKeyUp); glutCloseFunc(flua_onClose); flua_glutRunFlag = true; return winId; }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(400, 350); glutInitContextVersion(3, 3); glutInitContextProfile(GLUT_CORE_PROFILE); glutCreateWindow("465 Raw Texture {b, f, t} : front view"); // initialize and verify glew glewExperimental = GL_TRUE; // needed my home system GLenum err = glewInit(); if (GLEW_OK != err) printf("GLEW Error: %s \n", glewGetErrorString(err)); else { printf("Using GLEW %s \n", glewGetString(GLEW_VERSION)); printf("OpenGL %s, GLSL %s\n", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION)); } // initialize scene init(); // set glut callback functions glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutTimerFunc(40, spin, 1); glutCloseFunc(cleanUp); // freeglut only // Note: glutSetOption is only available with freeglut glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutMainLoop(); printf("exit main() \n"); return 0; }
/// Adds a new view. Function has to be called just from the inside of view thread with a locked sync_view. int add_view_in_thread(void* view_pars_ptr) { error_if(need_safe_call(), "Calling add_view_in_thread from other thread."); ViewParams& view_params = *((ViewParams*)view_pars_ptr); //create GLUT window glutInitWindowPosition(view_params.x, view_params.y); glutInitWindowSize(view_params.width, view_params.height); int view_id = glutCreateWindow(view_params.title); glutSetWindowData(view_params.view); //initialize GLEW GLenum err = glewInit(); error_if(err != GLEW_OK, "GLEW error: %s", glewGetErrorString(err)); glew_initialized = true; //register callbacks glutDisplayFunc(on_display_stub); glutReshapeFunc(on_reshape_stub); glutMotionFunc(on_mouse_move_stub); glutPassiveMotionFunc(on_mouse_move_stub); glutMouseFunc(on_mouse_click_stub); glutKeyboardFunc(on_key_down_stub); glutSpecialFunc(on_special_key_stub); glutEntryFunc(on_entry_stub); glutCloseFunc(on_close_stub); //add to structures view_instances[view_id] = view_params.view; //call handlers view_params.view->on_create(view_id); return view_id; }
// ----------------------------------------------- Window::Window() : mId(0), mKeys(), mMouseButtons(), mMousePos(), mPreviousMousePos(), mMouseForce(), mMouseMoved(false), mClosed(false) { if (!mInitialised) { mInitialised = true; int argc = 0; glutInit(&argc, nullptr); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); } glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(defaultSize.x(), defaultSize.y()); mId = glutCreateWindow("wzy::Window"); if (!mId) throw Exception("Unable to create wzy::Window."); glutDisplayFunc(displayFunc); glutReshapeFunc(reshapeFunc); glutKeyboardFunc(keyboardFunc); glutKeyboardUpFunc(keyboardUpFunc); glutMouseFunc(mouseFunc); glutMotionFunc(motionFunc); glutPassiveMotionFunc(passiveMotionFunc); glutCloseFunc(closeFunc); mWindows.insert(std::make_pair(mId, this)); }
//-----------------implementation of windows class------------------------------- Window::Window (int *argc, char *argv[], int window_width, int window_height, const char *window_title) { //init camera camera.width = window_width; camera.height = window_height; is_close = false; camera.center = vector2d (0, 2.0); camera.scale = 5.0; //init keyboard for (int i = 0; i < 256; i++) keys[i] = false; //start logging InitLog (); //create window glutInit (argc, argv); glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize (camera.width, camera.height); handle = glutCreateWindow (window_title); //set callbacks glutDisplayFunc (display); glutReshapeFunc (reshape); glutCloseFunc (close); glutKeyboardFunc (key_down); glutKeyboardUpFunc (key_up); glutMotionFunc (mouse_move); glutPassiveMotionFunc (mouse_move); glutMouseFunc (mouse_press); glutMouseWheelFunc (mouse_wheel); log (LOG_INFO, "Window \"%s\" created succesfully", window_title); }
int main(int argc, char *argv[]) { signal(SIGTERM, &writeToDisk); signal(SIGINT, &writeToDisk); if(argc < 2) { std::cout << "no IP address specified, defaulting to loopback..." << std::endl; openGLSocket = setupSocket("127.0.0.1", 8999); } else { std::cout << "using provided address: " << argv[1] << std::endl; openGLSocket = setupSocket(argv[1], 8999); } init(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize((int) width, (int) height); wd = glutCreateWindow("Client Buffer" /* title */ ); glutDisplayFunc(display); glutKeyboardFunc(keyboardHandler); glutSpecialFunc(specialKeyHandler); glutReshapeFunc(reshape); glutIdleFunc(socketHandler); glutCloseFunc(glutWriteToDisk); #ifndef __APPLE__ glewInit(); #endif /* start the GLUT main loop */ 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); }
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; }
int main(int argc, char *argv[]) { /* Start logging */ hvLogInit(HV_LOG_DEBUG, stdout); hvPrint("Krzysztof Abramowicz (http://abramowicz.info/, [email protected])"); hvPrint("HyperVision Design Stage One (ISO C '99 + OpenGL 3.3 + GLUT 2.6)"); hvLogTabWidth(4); /*d hvLogLimits(); hvLogFloats(); */ /* Initialise window and canvas */ hvAppInitWindow(curWidth, curHeight, PROGRAM_NAME); hvAppInitCanvas(); /* Register callbacks */ hvAppEvent(HV_RESHAPE, hvaReshape); hvAppEvent(HV_DISPLAY, hvaDisplay); hvAppEvent(HV_SPECIAL, hvaSpecial); hvAppEvent(HV_KEYBOARD, hvaKeyboard); hvAppEvent(HV_IDLE, hvaIdle); /* Build shaders */ shaderProgram = hvCreateProgram(HV_VSHADER_PHONG, HV_FSHADER_PHONG); hvInfo("Shader program built (phong lighting model)"); /*d hvProgramInfo(&shaderProgram); */ /* Construct models */ letterH = hvCreateStockModel(HV_MODEL_H); hvModelColor(&letterH, rgb(.1f, .8f, .1f)); hvInfo("model \"", hvModelName(&letterH), "\" created (", hvNum(hvModelFaces(&letterH)), " triangles)"); letterV = hvCreateStockModel(HV_MODEL_V); hvModelColor(&letterV, rgb(.1f, .1f, .8f)); hvInfo("model \"", hvModelName(&letterV), "\" created (", hvNum(hvModelFaces(&letterV)), " triangles)"); /*e cube = hvCreateStockModel(HV_MODEL_CUBE); hvModelColor(&cube, rgb(1.0f, .5f, .0f)); */ /* Calculate the view matrix */ hvMatrixViewCamera(&viewMatrix, vec(camX, 0, camZ), vec(0, 0, 0), vec(0, 1, 0)); hvDebug("View matrix preview:"); hvMatrixPrintFC(&viewMatrix); /* Playing ground :-) */ glProvokingVertex(GL_FIRST_VERTEX_CONVENTION); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glPointSize(4.0f); if (argc > 0 && argv[0][0] != '\0') hvDebug("Prgram name: ", argv[0]); /* enter the main loop */ glutCloseFunc(hvaClean); glutTimerFunc(0, hvaTimer, 0); hvInfo("Entering main rendering loop..."); glutMainLoop(); hvInfo("Exited successfully"); hvLogTerm(); }
int main( int argc, char ** argv ) { // Размеры окна по-умолчанию size_t const default_width = 800; size_t const default_height = 800; glutInit (&argc, argv); glutInitWindowSize (default_width, default_height); // Указание формата буфера экрана: // - GLUT_DOUBLE - двойная буферизация // - GLUT_RGB - 3-ёх компонентный цвет // - GLUT_DEPTH - будет использоваться буфер глубины glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // Создаем контекст версии 3.2 glutInitContextVersion (3, 0); // Контекст будет поддерживать отладку и "устаревшую" функциональность, которой, например, может пользоваться библиотека AntTweakBar // glutInitContextFlags (GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG); // Указание либо на core либо на compatibility профил //glutInitContextProfile (GLUT_COMPATIBILITY_PROFILE ); int window_handle = glutCreateWindow("OpenGL basic sample"); // Инициализация указателей на функции OpenGL if (glewInit() != GLEW_OK) { cerr << "GLEW init failed" << endl; return 1; } // Проверка созданности контекста той версии, какой мы запрашивали if (!GLEW_VERSION_3_0) { cerr << "OpenGL 3.0 not supported" << endl; return 1; } // подписываемся на оконные события glutReshapeFunc(reshape_func); glutDisplayFunc(display_func); glutIdleFunc (idle_func ); glutCloseFunc (close_func ); glutKeyboardFunc(keyboard_func); // подписываемся на события для AntTweakBar'а glutMouseFunc ((GLUTmousebuttonfun)TwEventMouseButtonGLUT); glutMotionFunc ((GLUTmousemotionfun)TwEventMouseMotionGLUT); glutPassiveMotionFunc((GLUTmousemotionfun)TwEventMouseMotionGLUT); glutSpecialFunc ((GLUTspecialfun )TwEventSpecialGLUT ); TwGLUTModifiersFunc (glutGetModifiers); try { // Создание класса-примера prog_state_ptr.reset(new prog_state()); // Вход в главный цикл приложения glutMainLoop(); } catch( std::exception const & except ) { std::cout << except.what() << endl; return 1; } return 0; }
void setupCallbacks() { glutCloseFunc(cleanup); glutDisplayFunc(display); glutIdleFunc(idle); glutReshapeFunc(reshape); glutTimerFunc(0,timer,0); }
// // Function: lcdGlutClose // // Callback for glut window close event // static void lcdGlutClose(void) { // Attempt to shutdown gracefully glutCloseFunc(NULL); glutDestroyWindow(winGlutWin); deviceActive = GLCD_FALSE; lcdGlutInitArgs.winClose(); }
//////////////////////////////////////////////////////////////////////////////// // Program main //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { pArgc = &argc; pArgv = argv; char *ref_file = NULL; printf("%s Starting...\n\n", sSDKsample); if (checkCmdLineFlag(argc, (const char **)argv, "file")) { fpsLimit = frameCheckNumber; getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file); } if (ref_file) { chooseCudaDevice(argc, argv, false); loadVolumeData(argv[0]); runAutoTest(ref_file, argv[0]); } else { // First initialize OpenGL context, so we can properly set the GL for CUDA. // This is necessary in order to achieve optimal performance with OpenGL/CUDA interop. initGL(&argc, argv); // use command-line specified CUDA device, otherwise use device with highest Gflops/s chooseCudaDevice(argc, argv, true); // OpenGL buffers initGLBuffers(); loadVolumeData(argv[0]); } printf("Press space to toggle animation\n" "Press '+' and '-' to change displayed slice\n"); #if defined (__APPLE__) || defined(MACOSX) atexit(cleanup); #else glutCloseFunc(cleanup); #endif glutMainLoop(); exit(EXIT_SUCCESS); }
//////////////////////////////////////////////////////////////////////////////// // 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; }
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); }
void AssignFunctions(){ glutReshapeFunc(ResizeFunction); glutDisplayFunc(RenderFunction); glutIdleFunc(IdleFunction); glutTimerFunc(0, TimerFunction, 0); glutKeyboardFunc(KeyboardFunction); glutSpecialFunc(SpecialKeyFunction); glutKeyboardUpFunc(KeyboardReleasedFunction); glutSpecialUpFunc(SpecialKeyReleasedFunction); glutMotionFunc(MouseMovementFunction); glutPassiveMotionFunc(MouseMovementFunction); glutMouseFunc(MouseClickedFunction); glutCloseFunc(Cleanup); }
void CView::InitializeCallbacks(void) { // register callbacks //glutIgnoreKeyRepeat(1); glutDisplayFunc(CGlutCallbacks::DisplayCallback); glutReshapeFunc(CGlutCallbacks::ReshapeCallback); glutKeyboardFunc(CGlutCallbacks::KeyboardPressedCallback); glutKeyboardUpFunc(CGlutCallbacks::KeyboardReleasedCallback); glutSpecialFunc(CGlutCallbacks::KeyboardPressedCallback); glutSpecialUpFunc(CGlutCallbacks::KeyboardReleasedCallback); glutMouseFunc(CGlutCallbacks::MouseKeyCallback); glutMotionFunc(CGlutCallbacks::MouseMoveCallback); glutPassiveMotionFunc(CGlutCallbacks::MousePassiveMoveCallback); glutCloseFunc(CGlutCallbacks::FinalizeCallback); }
void gemglutwindow :: destroyMess(void) { if(makeCurrent()) { s_windowmap.erase(m_window); int window=m_window; m_window=0; // so that we no longer receive any event glutCloseFunc (NULL); glutDestroyWindow(window); glutMainLoopEvent(); glutMainLoopEvent(); } destroy(); }
void gemglutwindow :: destroyMess(void) { if(makeCurrent()) { int window=m_window; m_window=0; // so that we no longer receive any event glutCloseFunc (NULL); glutDestroyWindow(window); glutMainLoopEvent(); glutMainLoopEvent(); /* now that the window is destroyed, remove it from the list of available windows */ s_windowmap.erase(window); } destroy(); }
void initGL(int *argc, char **argv) { // initialize GLUT callback functions glutInit(argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(width, height); glutCreateWindow("CUDA bicubic texture filtering"); glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(motion); glutReshapeFunc(reshape); glutTimerFunc(REFRESH_DELAY, timerEvent, 0); #if defined (__APPLE__) || defined(MACOSX) atexit(cleanup); #else glutCloseFunc(cleanup); #endif initMenus(); glewInit(); if (!glewIsSupported("GL_VERSION_2_0 " "GL_ARB_pixel_buffer_object " )) { fprintf(stderr, "Required OpenGL extensions are missing."); exit(EXIT_FAILURE); } #if USE_BUFFER_TEX if (!glewIsSupported("GL_EXT_texture_buffer_object")) { fprintf(stderr, "OpenGL extension: GL_EXT_texture_buffer_object missing.\n"); exit(EXIT_FAILURE); } if (!glewIsSupported("GL_NV_gpu_program4")) { fprintf(stderr, "OpenGL extension: GL_NV_gpu_program4 missing.\n"); exit(EXIT_FAILURE); } #endif }
int main(int argc, char ** argv) { //init OpenGL context initGlut(argc, argv); initGlew(); OnInit(); glutCloseFunc(OnShutDown); glutDisplayFunc(OnRender); glutReshapeFunc(OnResize); glutMouseFunc(OnMouseDown); glutMotionFunc(OnMouseMove); glutKeyboardFunc(OnKeyDown); glutIdleFunc(OnIdle); glutMainLoop(); return 0; }
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; }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(WIDTH, HEIGHT); glutCreateWindow("aGPhys - 5) (Einfache Stoffsimulation)"); glutDisplayFunc(display); glutReshapeFunc(resize); glutIdleFunc(idle); glutKeyboardFunc(key); glutMouseFunc(mouseButton); glutMotionFunc(mouseMove); glutCloseFunc(shutdown); init(); glutMainLoop(); return 0; }