GLFWmonitor* Screen::getMonitor(unsigned short monitorID) { int monitorCount; glfwGetMonitors(&monitorCount); vector<GLFWmonitor*> monitors = vector<GLFWmonitor*>(); GLFWmonitor** temp = glfwGetMonitors(&monitorCount); monitors.insert(monitors.begin(), temp, temp + monitorCount); if (monitorID < monitors.size() && monitorID > 0) return monitors.at(monitorID); else if (monitorID == 0) return glfwGetPrimaryMonitor(); //0 else return nullptr; //actually uses the default screen in Fullscreen mode }
///@brief Attempt to determine which of the connected monitors is the Oculus Rift and which /// are not. The only heuristic available for this purpose is resolution. void IdentifyMonitors() { int count; GLFWmonitor** monitors = glfwGetMonitors(&count); for (int i=0; i<count; ++i) { GLFWmonitor* pMonitor = monitors[i]; if (pMonitor == NULL) continue; const GLFWvidmode* mode = glfwGetVideoMode(pMonitor); /// Take a guess at which is the Oculus - 1280x800 is pretty distinctive if ( (mode->width == 1280) && (mode->height == 800) ) { g_pOculusMonitor = pMonitor; } else if (g_pPrimaryMonitor == NULL) { /// Guess that the first (probably)non-Oculus monitor is primary. ///@note The multi-monitor setup requires the two screens to be aligned along their top edge /// with the Oculus monitor to the right of the primary. g_pPrimaryMonitor = pMonitor; } } }
GLFWmonitor* RenderSystem::_getMonitor() { int count; GLFWmonitor** monitors = glfwGetMonitors(&count); return monitors[this->_monitor]; }
bool Window_GL::open(WindowParams p, std::string title) { // glfwWindowHint(GLFW_SAMPLES, p.samples); glfwWindowHint(GLFW_RESIZABLE, 1); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); int count; GLFWmonitor **ml = glfwGetMonitors(&count); GLFWmonitor *m = NULL; if (p.fullscreen) { m = glfwGetPrimaryMonitor(); if (p.fullscreen_monitor && p.fullscreen_monitor <= count) m = ml[p.fullscreen_monitor-1]; } handle = (void*)glfwCreateWindow(p.width, p.height, title.c_str(), m, NULL); glfwMakeContextCurrent((GLFWwindow*)handle); params = p; // Make sure we were able to create a rendering context. if (!handle) { LOG->Error("Unable to obtain an OpenGL 3.1 rendering context."); return false; } if (glxwInit() != 0) LOG->Error("Unable to load required OpenGL extensions."); return true; }
GLFWwindow * createWindow(void) { int count; GLFWmonitor ** monitors = glfwGetMonitors(&count); if (count == 1) return glfwCreateWindow(INIT_WIN_WIDTH, INIT_WIN_HEIGHT, WIN_TITLE, NULL, NULL); std::cout << "Available monitors:" << std::endl; for (int i = 0; i < count; i++) { const GLFWvidmode * mode = glfwGetVideoMode(monitors[i]); std::cout << "\t" << i + 1 << ":\t" << glfwGetMonitorName(monitors[i]) << "\t" << mode->width << "x" << mode->height << std::endl; } int selectedMonitor = -1; if (SELECT_MONITOR_MAN) { std::string data; do { std::cout << "\nPlease select a monitor:" << std::endl; std::getline(std::cin, data); if (data.length() > 3) continue; selectedMonitor = (unsigned int)atoi(data.c_str()); } while (selectedMonitor < 1 || selectedMonitor > count); } else selectedMonitor = SELECT_MONITOR_DEFAULT; std::cout << "Selected monitor " << selectedMonitor << "." << std::endl; selectedMonitor--; // the monitors display as starting from 1 instead of 0 const GLFWvidmode * mode = glfwGetVideoMode(monitors[selectedMonitor]); controller.m_state.winWidth = mode->width; controller.m_state.winHeight = mode->height; glfwWindowHint(GLFW_AUTO_ICONIFY, false); return glfwCreateWindow(controller.m_state.winWidth, controller.m_state.winHeight = mode->height, WIN_TITLE, monitors[selectedMonitor], NULL); }
int GLFW_App::get_num_monitors() const { int ret; /*GLFWmonitor** monitors = */ glfwGetMonitors(&ret); return ret; }
void GlfwApp::createSecondaryScreenWindow(const glm::uvec2 & size) { GLFWmonitor * primary = glfwGetPrimaryMonitor(); int monitorCount; GLFWmonitor ** monitors = glfwGetMonitors(&monitorCount); GLFWmonitor * best = nullptr; glm::uvec2 bestSize; for (int i = 0; i < monitorCount; ++i) { GLFWmonitor * cur = monitors[i]; if (cur == primary) { continue; } glm::uvec2 curSize = getSize(cur); if (best == nullptr || (bestSize.x < curSize.x && bestSize.y < curSize.y)) { best = cur; bestSize = curSize; } } if (nullptr == best) { best = primary; bestSize = getSize(best); } glm::ivec2 pos = getPosition(best); if (bestSize.x > size.x) { pos.x += (bestSize.x - size.x) / 2; } if (bestSize.y > size.y) { pos.y += (bestSize.y - size.y) / 2; } createWindow(size, pos); }
/// Dump a list of monitor info to Log and stdout. /// http://www.glfw.org/docs/3.0/monitor.html void PrintMonitorInfo() { int count; GLFWmonitor** monitors = glfwGetMonitors(&count); printf("Found %d monitors:\n", count); LOG_INFO("Found %d monitors:", count); for (int i=0; i<count; ++i) { GLFWmonitor* pMonitor = monitors[i]; if (pMonitor == NULL) continue; printf(" Monitor %d:\n", i); LOG_INFO(" Monitor %d:", i); /// Monitor name const char* pName = glfwGetMonitorName(pMonitor); printf(" Name: %s\n", pName); LOG_INFO(" Name: %s", pName); /// Monitor Physical Size int widthMM, heightMM; glfwGetMonitorPhysicalSize(pMonitor, &widthMM, &heightMM); //const double dpi = mode->width / (widthMM / 25.4); printf(" physical size: %d x %d mm\n"); LOG_INFO(" physical size: %d x %d mm"); /// Modes const GLFWvidmode* mode = glfwGetVideoMode(pMonitor); printf(" Current mode: %dx%d @ %dHz (RGB %d %d %d bits)\n", mode->width, mode->height, mode->refreshRate, mode->redBits, mode->greenBits, mode->blueBits); LOG_INFO(" Current mode: %dx%d @ %dHz (RGB %d %d %d bits)", mode->width, mode->height, mode->refreshRate, mode->redBits, mode->greenBits, mode->blueBits); #if 0 int modeCount; const GLFWvidmode* modes = glfwGetVideoModes(pMonitor, &modeCount); printf(" %d Modes:\n", modeCount); LOG_INFO(" %d Modes:", modeCount); for (int j=0; j<modeCount; ++j) { const GLFWvidmode& m = modes[j]; printf(" %dx%d @ %dHz (RGB %d %d %d bits)\n", m.width, m.height, m.refreshRate, m.redBits, m.greenBits, m.blueBits); LOG_INFO(" %dx%d @ %dHz (RGB %d %d %d bits)", m.width, m.height, m.refreshRate, m.redBits, m.greenBits, m.blueBits); } #endif } }
IntVector2 Graphics::GetDesktopResolution(int monitor) const { int monitor_count=0; GLFWmonitor** known_monitors = glfwGetMonitors(&monitor_count); if (monitor >= monitor_count || monitor < 0) monitor = 0; // this monitor is not present, use first monitor const GLFWvidmode * mode = glfwGetVideoMode(known_monitors[monitor]); return IntVector2(mode->width, mode->height); }
char* app_display_querymodes() { glfwSetErrorCallback(glfw_error_callback); if (!glfwInit()) return NULL; uint adapter_id = 0; size_t outsz; /* start json data (adapter array) */ json_t jroot = json_create_arr(); /* read adapters */ while (adapter_id == 0) { json_t jadapter = json_create_obj(); json_additem_toarr(jroot, jadapter); json_additem_toobj(jadapter, "name", json_create_str("Graphics Card #1")); json_additem_toobj(jadapter, "id", json_create_num(0)); /* enumerate monitors */ json_t joutputs = json_create_arr(); json_additem_toobj(jadapter, "monitors", joutputs); int output_cnt = 0; GLFWmonitor** monitors = glfwGetMonitors(&output_cnt); for (int i = 0; i < output_cnt; i++) { json_t joutput = json_create_obj(); json_additem_toarr(joutputs, joutput); json_additem_toobj(joutput, "id", json_create_num((fl64)i)); json_additem_toobj(joutput, "name", json_create_str(glfwGetMonitorName(monitors[i]))); /* enumerate modes */ json_t jmodes = json_create_arr(); json_additem_toobj(joutput, "modes", jmodes); int mode_cnt; const GLFWvidmode* modes = glfwGetVideoModes(monitors[i], &mode_cnt); for (int i = 0; i < mode_cnt; i++) { json_t jmode = json_create_obj(); json_additem_toobj(jmode, "width", json_create_num((fl64)modes[i].width)); json_additem_toobj(jmode, "height", json_create_num((fl64)modes[i].height)); json_additem_toobj(jmode, "refresh-rate", json_create_num((fl64)modes[i].refreshRate)); json_additem_toarr(jmodes, jmode); } } adapter_id ++; } char* r = json_savetobuffer(jroot, &outsz, FALSE); json_destroy(jroot); return r; }
int Graphics::GetCurrentMonitor() { GLFWmonitor *mon = glfwGetWindowMonitor(window2_); int moncount=0; GLFWmonitor **monitors = glfwGetMonitors(&moncount); while(--moncount>=0) if(monitors[moncount]==mon) return moncount; return 0; }
void Adviser::fetchMonitors(std::vector<Video::Monitor> *buffer) const { if(0 != buffer) { buffer->clear(); int monitorCount; GLFWmonitor **monitors = glfwGetMonitors(&monitorCount); for(int i = 0; i < monitorCount; ++i) { buffer->push_back(Video::Monitor(monitors[i])); } } }
int Init(bool a_bSetFullScreen, unsigned int a_uiWidth, unsigned int a_uiHeight, int a_uiPosX, int a_uiPosY) { Monitor = glfwGetMonitors(aiNumOfMonitors); Mode = glfwGetVideoMode(Monitor[0]); glfwWindowHint(GLFW_RED_BITS, Mode->redBits); glfwWindowHint(GLFW_GREEN_BITS, Mode->greenBits); glfwWindowHint(GLFW_BLUE_BITS, Mode->blueBits); glfwWindowHint(GLFW_REFRESH_RATE, Mode->refreshRate); if (a_bSetFullScreen) Window = glfwCreateWindow(Mode->width, Mode->height, "The Solar System", Monitor[0], nullptr); else { Window = glfwCreateWindow(a_uiWidth, a_uiHeight, "The Solar System", nullptr, nullptr); if (a_uiPosX == -1) a_uiPosX = (Mode->width - a_uiWidth) / 2; if (a_uiPosY == -1) a_uiPosY = (Mode->height - a_uiHeight) / 2; glfwSetWindowPos(Window, a_uiPosX, a_uiPosY); } if (Window == nullptr) { glfwTerminate(); return -2; } //make the glfw window glfwMakeContextCurrent(Window); if (ogl_LoadFunctions() == ogl_LOAD_FAILED) { glfwDestroyWindow(Window); glfwTerminate(); return -3; } // Parses the version of OpenGL and prints it auto major = ogl_GetMajorVersion(); auto minor = ogl_GetMinorVersion(); printf_s("GL: %i.%i\n", major, minor); //initialize all of our gizmos and set up the virtual camera Gizmos::create(); SetView({ 10, 0, 0 }, { 0, 0, 0 }, { 0, 1, 0 }); Projection = glm::perspective(glm::pi<float>() * 0.25f, 16 / 9.f, 0.001f, 1000.f); glClearColor(0.5f, 0.5f, 0.5f, 1);//set the clear color glEnable(GL_DEPTH_TEST); // enables the depth buffer return 0; }
void Monitor::getMonitorsList() { if(monitors.empty()) { int total = 0; GLFWmonitor** mons = glfwGetMonitors(&total); for(int i = 0; i < total; ++i) monitors.emplace_back(mons[i]); } }
// Get the 'monitor' at position specified by HMD Info // This should be the OVR GLFWmonitor* getMonitorAtPosition(glm::ivec2 & position) { int count; GLFWmonitor ** monitors = glfwGetMonitors(&count); for (int i = 0; i < count; ++i) { glm::ivec2 candidatePosition; glfwGetMonitorPos(monitors[i], &candidatePosition.x, &candidatePosition.y); if (candidatePosition == position) { return monitors[i]; } } return nullptr; }
static inline jint wrapped_Java_com_badlogic_jglfw_Glfw_glfwGetMonitorsJni (JNIEnv* env, jclass clazz, jlongArray obj_monitors, long long* monitors) { //@line:583 int count = 0; GLFWmonitor** mons = glfwGetMonitors(&count); if(!mons) return 0; for(int i = 0; i < count; i++) { monitors[i] = (jlong)mons[i]; } return count; }
GLFW_Window::GLFW_Window(int width, int height, const std::string &theName, bool fullscreen, int monitor_index, GLFWwindow* share) { int monitor_count = 0; GLFWmonitor **monitors = glfwGetMonitors(&monitor_count); monitor_index = clamp(monitor_index, 0, monitor_count - 1); // GLFWmonitor *monitor_handle = monitor_count > 1 ? monitors[monitor_index] : glfwGetPrimaryMonitor(); m_handle = glfwCreateWindow(width, height, theName.c_str(), fullscreen ? monitors[monitor_index] : NULL, share); if(!m_handle) throw CreateWindowException(); glfwMakeContextCurrent(m_handle); }
IntVector2 Graphics::GetMonitorResolution(int monitorId) const { IntVector2 res; int moncount=0; GLFWmonitor **monitors = glfwGetMonitors(&moncount); if(monitorId<moncount) { const GLFWvidmode * mode = glfwGetVideoMode(monitors[monitorId]); res = {mode->width,mode->height}; } else { const GLFWvidmode * mode = glfwGetVideoMode(glfwGetPrimaryMonitor()); res = {mode->width,mode->height}; } return res; }
bool Window::switchFullscreen(int screenId) { int count; GLFWmonitor** monitors = glfwGetMonitors(&count); if (screenId >= count) return false; if (_window.get() == nullptr) return false; if (screenId != -1) _screenId = screenId; else if (screenId == _screenId) return true; const GLFWvidmode* vidmode = glfwGetVideoMode(monitors[_screenId]); glfwWindowHint(GLFW_VISIBLE, true); GLFWwindow* window; if (glfwGetWindowMonitor(_window->get()) == NULL) { glfwWindowHint(GLFW_RED_BITS, vidmode->redBits); glfwWindowHint(GLFW_GREEN_BITS, vidmode->greenBits); glfwWindowHint(GLFW_BLUE_BITS, vidmode->blueBits); glfwWindowHint(GLFW_REFRESH_RATE, vidmode->refreshRate); window = glfwCreateWindow(vidmode->width, vidmode->height, ("Splash::" + _name).c_str(), monitors[_screenId], _window->getMainWindow()); } else window = glfwCreateWindow(vidmode->width, vidmode->height, ("Splash::" + _name).c_str(), 0, _window->getMainWindow()); if (!window) { Log::get() << Log::WARNING << "Window::" << __FUNCTION__ << " - Unable to create new fullscreen shared window" << Log::endl; return false; } _window = move(make_shared<GlWindow>(window, _window->getMainWindow())); updateSwapInterval(); setupReadFBO(); setEventsCallbacks(); showCursor(false); return true; }
Vector3 Graphics::GetDisplayDPI(int monitor) const { int moncount=0; GLFWmonitor **monitors = glfwGetMonitors(&moncount); Vector3 result; if(monitor<moncount) { int widthMM, heightMM; glfwGetMonitorPhysicalSize(monitors[monitor], &widthMM, &heightMM); int diagonalMM = std::sqrt(widthMM * widthMM + heightMM*heightMM); const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]); const float hdpi = mode->width / (widthMM / 25.4f); const float vdpi = mode->height / (heightMM / 25.4f); const float ddpi = std::sqrt(mode->width*mode->width + mode->height*mode->height) / (diagonalMM / 25.4f); result = {ddpi,hdpi,vdpi}; } return result; }
int main(int argc, char** argv) { int ch, i, count, mode = LIST_MODE; GLFWmonitor** monitors; while ((ch = getopt(argc, argv, "th")) != -1) { switch (ch) { case 'h': usage(); exit(EXIT_SUCCESS); case 't': mode = TEST_MODE; break; default: usage(); exit(EXIT_FAILURE); } } argc -= optind; argv += optind; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); monitors = glfwGetMonitors(&count); for (i = 0; i < count; i++) { if (mode == LIST_MODE) list_modes(monitors[i]); else if (mode == TEST_MODE) test_modes(monitors[i]); } glfwTerminate(); exit(EXIT_SUCCESS); }
std::vector<IntVector3> Graphics::GetResolutions(int monitor) const { std::vector<IntVector3> ret; int monitor_count=0; GLFWmonitor** known_monitors = glfwGetMonitors(&monitor_count); if (monitor >= monitor_count || monitor < 0) monitor = 0; // this monitor is not present, use first monitor GLFWmonitor* selected_monitor = known_monitors[monitor]; int numModes=0; const GLFWvidmode * modes = glfwGetVideoModes(selected_monitor,&numModes); if(!modes) return ret; for (int i = 0; i < numModes; ++i) { const GLFWvidmode &mode(modes[i]); int width = mode.width; int height = mode.height; int rate = mode.refreshRate; // Store mode if unique bool unique = true; for (unsigned j = 0; j < ret.size(); ++j) { if (ret[j].x_ == width && ret[j].y_ == height && ret[j].z_ == rate) { unique = false; break; } } if (unique) ret.emplace_back(width, height, rate); } return ret; }
//Method initializes OpenGL for rendering to a window/viewport bool glEngine::Init() { /// We need our GLFW function pointers to be assigned, if this process fails we cannot continue if ( !glfwInit() ) { return false; } /// Here we query how much sampling is possible and set that to be used if possible GLint samples = 8; glGetIntegerv( GL_SAMPLES, &samples ); if ( samples ) { glEnable( GL_MULTISAMPLE ); } glfwWindowHint( GLFW_SAMPLES, samples ); GLFWmonitor** monitors; int count; monitors = glfwGetMonitors( &count ); //TODO: Create Window Resizing method const GLFWvidmode* mode = glfwGetVideoMode( glfwGetPrimaryMonitor() ); ///Create a window of a particular type switch ( m_wMode ) { case GL_Engine::window::FULLSCREEN: { m_window = glfwCreateWindow( mode->width, mode->height, "Fullscreen", glfwGetPrimaryMonitor(), NULL ); m_Screen.m_Height = mode->height; m_Screen.m_Width = mode->width; break; } case GL_Engine::window::DECORATEDWINDOW: { m_window = glfwCreateWindow( m_Screen.Width(), m_Screen.Height(), "Decorated Window", NULL, NULL ); break; } case GL_Engine::window::BORDERLESSFULLSCREEN: { glfwWindowHint( GLFW_DECORATED, false ); glfwWindowHint( GLFW_RED_BITS, mode->redBits ); glfwWindowHint( GLFW_GREEN_BITS, mode->greenBits ); glfwWindowHint( GLFW_BLUE_BITS, mode->blueBits ); glfwWindowHint( GLFW_REFRESH_RATE, mode->refreshRate ); m_window = glfwCreateWindow( mode->width, mode->height, "Borderless Fullscreen", NULL, NULL ); m_Screen.m_Height = mode->height; m_Screen.m_Width = mode->width; break; } } /// If creating the window failed we need to terminate if ( !m_window ) { glfwTerminate(); return false; } /// Associates this window with OpenGL's rendering (I believe) glfwMakeContextCurrent( m_window ); /// Sets our input processing function, all input will be passed to this function //glfwSetScrollCallback( window, scroll_callback ); glfwSetKeyCallback( m_window, key_callback ); glfwSetCursorPosCallback( m_window, cursor_position_callback ); glfwSetMouseButtonCallback( m_window, mouse_button_callback ); glfwSetWindowSizeCallback( m_window, window_resize_callback ); /// start GLEW extension handler glewExperimental = GL_TRUE; ///Initialize OpenGL functions glewInit(); const GLubyte* renderer = glGetString( GL_RENDERER ); /// get renderer string const GLubyte* version = glGetString( GL_VERSION ); /// version as a string ///oLog( Level::Info ) << "Renderer: " << renderer; ///oLog( Level::Info ) << "OpenGL version supported: " << version; m_projectionMatrix = glm::mat4( 1.f ); m_viewMatrix = glm::mat4( 1.f ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); glFrontFace( GL_CCW ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); ///clear colour: r,g,b,a glfwSwapInterval( 1 ); ///cap FPS m_currentDC = wglGetCurrentDC(); m_currentContext = wglGetCurrentContext(); return true; }
void OGLApp::v_run() { app = std::make_shared<OGLApp>(*this); std::cout << "Starting GLFW context" << std::endl; if (!glfwInit()) { std::cerr << "Failed to initialize GLFW" << std::endl; return; } sw = WindowInfo::getInstance()->getWidth(); sh = WindowInfo::getInstance()->getHeight(); int MonitorCount; GLFWmonitor ** monitors = glfwGetMonitors(&MonitorCount); #ifdef _DEBUG glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true); #endif //glfwGetPrimaryMonitor(), pWindow = glfwCreateWindow(sw, sh, WindowInfo::getInstance()->getTitle().c_str(), nullptr, nullptr); glfwSetWindowPos(pWindow, WindowInfo::getInstance()->getPosX() - 100, WindowInfo::getInstance()->getPosY() - 100); glfwMakeContextCurrent(pWindow); glfwSetCursorPosCallback(pWindow, glfw_mouse); // - Directly redirect GLFW mouse position events to AntTweakBar glfwSetScrollCallback(pWindow, glfw_scroll); // - Directly redirect GLFW mouse wheel events to AntTweakBar glfwSetKeyCallback(pWindow, glfw_key); // - Directly redirect GLFW key events to AntTweakBar #ifdef USE_ANT glfwSetMouseButtonCallback(pWindow, glfw_mouseButton); // - Directly redirect GLFW mouse button events to AntTweakBar glfwSetCharCallback(pWindow, glfw_char); // - Directly redirect GLFW char events to AntTweakBar #endif glfwSetWindowSizeCallback(pWindow, glfw_resize); //glfwSetInputMode(pWindow, GLFW_STICKY_KEYS, GL_TRUE); // GLFW Options //glfwSetInputMode(pWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED); if (pWindow == NULL) { std::cerr << "Failed to create GLFW pWindow" << std::endl; glfwTerminate(); return; } glewExperimental = GL_TRUE; //Check the GLSL and OpenGL status if (glewInit() != GLEW_OK) { std::cerr << "Failed to initialize GLEW" << std::endl; return; } const GLubyte *renderer = glGetString(GL_RENDERER); const GLubyte *vendor = glGetString(GL_VENDOR); const GLubyte *version = glGetString(GL_VERSION); const GLubyte *glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION); m_GLRenderer = (const char *)renderer; m_GLVersion = (const char *)version; m_GLSLVersion = (const char *)glslVersion; GLint major, minor; glGetIntegerv(GL_MAJOR_VERSION, &major); glGetIntegerv(GL_MINOR_VERSION, &minor); std::cout << "GL Vendor :" << vendor << std::endl; std::cout << "GL Renderer : " << renderer << std::endl; std::cout << "GL Version (std::string) : " << version << std::endl; std::cout << "GL Version (integer) : " << major << "." << minor << std::endl; std::cout << "GLSL Version : " << glslVersion << std::endl; std::cout << "--------------------------------------------------------------------------------" << std::endl; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); #ifdef USE_FONT m_pFont.init(); #endif #ifdef USE_CEGUI OGLCEGUI::getInstance()->init(); OGLCEGUI::getInstance()->setupCallbacks(pWindow); #endif v_init(); while (!glfwWindowShouldClose(pWindow)) { glfwPollEvents(); v_movement(pWindow); countFps(); static GLfloat lastFrame = static_cast<float>(glfwGetTime()); GLfloat currentFrame = static_cast<float>(glfwGetTime()); GLfloat deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; v_update(); v_render(); #ifdef USE_FONT glDisable(GL_DEPTH_TEST); m_pFont.render("Graphics card: " + m_GLRenderer, 10, sh - 40); m_pFont.render("GL Version: " + m_GLVersion, 10, sh - 70); m_pFont.render("GLSL Version: " + m_GLSLVersion, 10, sh - 100); m_pFont.render("FPS: " + std::to_string(m_fps), 10, 30); //glEnable(GL_DEPTH_TEST); #endif #ifdef USE_CEGUI OGLCEGUI::getInstance()->render(); #endif glfwSwapBuffers(pWindow); } v_shutdown(); glfwTerminate(); }
//------------------------------------------------------------------------------ int main(int argc, char ** argv) { bool fullscreen = false; std::string str; for (int i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-d")) g_level = atoi(argv[++i]); else if (!strcmp(argv[i], "-c")) g_repeatCount = atoi(argv[++i]); else if (!strcmp(argv[i], "-f")) fullscreen = true; else { std::ifstream ifs(argv[1]); if (ifs) { std::stringstream ss; ss << ifs.rdbuf(); ifs.close(); str = ss.str(); g_defaultShapes.push_back(SimpleShape(str.c_str(), argv[1], kCatmark)); } } } initializeShapes(); OsdSetErrorCallback(callbackError); if (not glfwInit()) { printf("Failed to initialize GLFW\n"); return 1; } static const char windowTitle[] = "OpenSubdiv glBatchViewer"; #define CORE_PROFILE #ifdef CORE_PROFILE setGLCoreProfile(); #endif #if GLFW_VERSION_MAJOR>=3 if (fullscreen) { g_primary = glfwGetPrimaryMonitor(); // apparently glfwGetPrimaryMonitor fails under linux : if no primary, // settle for the first one in the list if (not g_primary) { int count=0; GLFWmonitor ** monitors = glfwGetMonitors(&count); if (count) g_primary = monitors[0]; } if (g_primary) { GLFWvidmode const * vidmode = glfwGetVideoMode(g_primary); g_width = vidmode->width; g_height = vidmode->height; } } if (not (g_window=glfwCreateWindow(g_width, g_height, windowTitle, fullscreen and g_primary ? g_primary : NULL, NULL))) { printf("Failed to open window.\n"); glfwTerminate(); return 1; } glfwMakeContextCurrent(g_window); glfwSetKeyCallback(g_window, keyboard); glfwSetCursorPosCallback(g_window, motion); glfwSetMouseButtonCallback(g_window, mouse); glfwSetWindowSizeCallback(g_window, reshape); #else if (glfwOpenWindow(g_width, g_height, 8, 8, 8, 8, 24, 8, fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW) == GL_FALSE) { printf("Failed to open window.\n"); glfwTerminate(); return 1; } glfwSetWindowTitle(windowTitle); glfwSetKeyCallback(keyboard); glfwSetMousePosCallback(motion); glfwSetMouseButtonCallback(mouse); glfwSetWindowSizeCallback(reshape); #endif #if defined(OSD_USES_GLEW) #ifdef CORE_PROFILE // this is the only way to initialize glew correctly under core profile context. glewExperimental = true; #endif if (GLenum r = glewInit() != GLEW_OK) { printf("Failed to initialize glew. Error = %s\n", glewGetErrorString(r)); exit(1); } #ifdef CORE_PROFILE // clear GL errors which was generated during glewInit() glGetError(); #endif #endif // activate feature adaptive tessellation if OSD supports it g_adaptive = OpenSubdiv::OsdGLDrawContext::SupportsAdaptiveTessellation(); initGL(); glfwSwapInterval(0); initHUD(); callbackModel(g_currentShape); g_fpsTimer.Start(); while (g_running) { idle(); display(); #if GLFW_VERSION_MAJOR>=3 glfwPollEvents(); glfwSwapBuffers(g_window); #else glfwSwapBuffers(); #endif } uninitGL(); glfwTerminate(); }
int main(int argc, char** argv) { int count = 0; GLFWwindow* window; srand((unsigned int) time(NULL)); glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); for (;;) { GLFWmonitor* monitor = NULL; if (count & 1) { int monitorCount; GLFWmonitor** monitors = glfwGetMonitors(&monitorCount); monitor = monitors[rand() % monitorCount]; } window = open_window(640, 480, monitor); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glMatrixMode(GL_PROJECTION); glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f); glMatrixMode(GL_MODELVIEW); glfwSetTime(0.0); while (glfwGetTime() < 5.0) { glClear(GL_COLOR_BUFFER_BIT); glPushMatrix(); glRotatef((GLfloat) glfwGetTime() * 100.f, 0.f, 0.f, 1.f); glRectf(-0.5f, -0.5f, 1.f, 1.f); glPopMatrix(); glfwSwapBuffers(window); glfwPollEvents(); if (glfwWindowShouldClose(window)) { close_window(window); printf("User closed window\n"); glfwTerminate(); exit(EXIT_SUCCESS); } } printf("Closing window\n"); close_window(window); count++; } glfwTerminate(); }
int main(int argc, char** argv) { int ch, i, window_count; int auto_iconify = GLFW_TRUE, fullscreen = GLFW_FALSE, all_monitors = GLFW_FALSE; GLFWwindow** windows; while ((ch = getopt(argc, argv, "afhn")) != -1) { switch (ch) { case 'a': all_monitors = GLFW_TRUE; break; case 'h': usage(); exit(EXIT_SUCCESS); case 'f': fullscreen = GLFW_TRUE; break; case 'n': auto_iconify = GLFW_FALSE; break; default: usage(); exit(EXIT_FAILURE); } } glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); glfwWindowHint(GLFW_AUTO_ICONIFY, auto_iconify); if (fullscreen && all_monitors) { int monitor_count; GLFWmonitor** monitors = glfwGetMonitors(&monitor_count); window_count = monitor_count; windows = calloc(window_count, sizeof(GLFWwindow*)); for (i = 0; i < monitor_count; i++) { windows[i] = create_window(monitors[i]); if (!windows[i]) break; } } else { GLFWmonitor* monitor = NULL; if (fullscreen) monitor = glfwGetPrimaryMonitor(); window_count = 1; windows = calloc(window_count, sizeof(GLFWwindow*)); windows[0] = create_window(monitor); } for (i = 0; i < window_count; i++) { glfwSetKeyCallback(windows[i], key_callback); glfwSetFramebufferSizeCallback(windows[i], framebuffer_size_callback); glfwSetWindowSizeCallback(windows[i], window_size_callback); glfwSetWindowFocusCallback(windows[i], window_focus_callback); glfwSetWindowIconifyCallback(windows[i], window_iconify_callback); glfwSetWindowRefreshCallback(windows[i], window_refresh_callback); window_refresh_callback(windows[i]); printf("Window is %s and %s\n", glfwGetWindowAttrib(windows[i], GLFW_ICONIFIED) ? "iconified" : "restored", glfwGetWindowAttrib(windows[i], GLFW_FOCUSED) ? "focused" : "defocused"); } for (;;) { glfwWaitEvents(); for (i = 0; i < window_count; i++) { if (glfwWindowShouldClose(windows[i])) break; } if (i < window_count) break; // Workaround for an issue with msvcrt and mintty fflush(stdout); } glfwTerminate(); exit(EXIT_SUCCESS); }
// APPLICATION ENTRY // ----------------- int main() { int width = 1024; int height = 768; sim_ptr = NULL; int c = 0; GLFWmonitor** m = glfwGetMonitors(&c); // init glfwSetErrorCallback(error_callback); if(!glfwInit()) { printf("ERROR: cannot initialize GLFW.\n"); exit(EXIT_FAILURE); } // glfwWindowHint(GLFW_DEPTH_BITS, 16); // glfwWindowHint(GLFW_FSAA_SAMPLES, 4); GLFWwindow* window = glfwCreateWindow(width, height, "Simulation", NULL, NULL); if(!window) { printf("ERROR: cannot open window.\n"); exit(EXIT_FAILURE); } glfwSetWindowSizeCallback(window, window_size_callback); glfwSetWindowCloseCallback(window, window_close_callback); glfwSetMouseButtonCallback(window, mouse_button_callback); glfwSetCursorPosCallback(window, cursor_callback); glfwSetScrollCallback(window, scroll_callback); glfwSetKeyCallback(window, key_callback); glfwSetCharCallback(window, char_callback); glfwMakeContextCurrent(window); #if defined(ROXLU_GL_CORE3) if(glxwInit() != 0) { printf("ERROR: cannot init glxw\n"); return EXIT_FAILURE; } #else glewExperimental = true; GLenum err = glewInit(); if (GLEW_OK != err) { fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err)); exit(EXIT_FAILURE); } #endif Simulation sim; sim_ptr = ∼ sim.window = window; sim.window_w = width; sim.window_h = height; sim.setup(); bool running = true; while(running) { glfwPollEvents(); sim.update(); sim.draw(); glfwSwapBuffers(window); running = !(glfwGetKey(window, GLFW_KEY_ESC)); } glfwTerminate(); return EXIT_SUCCESS; };
//------------------------------------------------------------------------------ int main(int argc, char ** argv) { bool fullscreen = false; std::string str; for (int i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-d")) g_level = atoi(argv[++i]); else if (!strcmp(argv[i], "-c")) g_repeatCount = atoi(argv[++i]); else if (!strcmp(argv[i], "-f")) fullscreen = true; else { std::ifstream ifs(argv[1]); if (ifs) { std::stringstream ss; ss << ifs.rdbuf(); ifs.close(); str = ss.str(); g_shapes.push_back(ShapeDesc(argv[1], str.c_str(), kCatmark)); } } } initShapes(); if (not glfwInit()) { printf("Failed to initialize GLFW\n"); return 1; } static const char windowTitle[] = "OpenSubdiv vtrViewer"; #define CORE_PROFILE #ifdef CORE_PROFILE setGLCoreProfile(); #endif if (fullscreen) { g_primary = glfwGetPrimaryMonitor(); // apparently glfwGetPrimaryMonitor fails under linux : if no primary, // settle for the first one in the list if (not g_primary) { int count=0; GLFWmonitor ** monitors = glfwGetMonitors(&count); if (count) g_primary = monitors[0]; } if (g_primary) { GLFWvidmode const * vidmode = glfwGetVideoMode(g_primary); g_width = vidmode->width; g_height = vidmode->height; } } if (not (g_window=glfwCreateWindow(g_width, g_height, windowTitle, fullscreen and g_primary ? g_primary : NULL, NULL))) { printf("Failed to open window.\n"); glfwTerminate(); return 1; } glfwMakeContextCurrent(g_window); // accommocate high DPI displays (e.g. mac retina displays) glfwGetFramebufferSize(g_window, &g_width, &g_height); glfwSetFramebufferSizeCallback(g_window, reshape); glfwSetKeyCallback(g_window, keyboard); glfwSetCursorPosCallback(g_window, motion); glfwSetMouseButtonCallback(g_window, mouse); glfwSetWindowCloseCallback(g_window, windowClose); #if defined(OSD_USES_GLEW) #ifdef CORE_PROFILE // this is the only way to initialize glew correctly under core profile context. glewExperimental = true; #endif if (GLenum r = glewInit() != GLEW_OK) { printf("Failed to initialize glew. Error = %s\n", glewGetErrorString(r)); exit(1); } #ifdef CORE_PROFILE // clear GL errors which was generated during glewInit() glGetError(); #endif #endif initGL(); glfwSwapInterval(0); initHUD(); rebuildOsdMeshes(); checkGLErrors("before loop"); while (g_running) { idle(); display(); glfwPollEvents(); glfwSwapBuffers(g_window); glFinish(); } uninitGL(); glfwTerminate(); }
void Window_Create(char *Title, int Width, int Height, int MoniterNum, struct Window **Window) { log_info("Creating Window"); if (*Window == NULL) (*Window) = malloc(sizeof(struct Window)); check_mem((*Window)); (*Window)->WINDOW_TITLE = Title; (*Window)->WINDOW_WIDTH = Width; (*Window)->WINDOW_HEIGHT = Height; Game_Width = Width; Game_Height = Height; /* Initialize GLFW for video output */ if (!glfwInit()) { log_info("Unable to initialize GLFW"); Application_Error(); } int count; GLFWmonitor** monitors = glfwGetMonitors(&count); int xpos, ypos; glfwGetMonitorPos(monitors[MoniterNum], &xpos, &ypos); const GLFWvidmode* mode = glfwGetVideoMode(monitors[0]); glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); /* Create a 640x480 OpenGL screen */ (*Window)->Window = glfwCreateWindow((*Window)->WINDOW_WIDTH, (*Window)->WINDOW_HEIGHT, (*Window)->WINDOW_TITLE, NULL, NULL); glfwSetWindowPos((*Window)->Window, xpos + mode->width / 2 - mode->width / 4 + mode->width / 8, ypos + mode->height / 2 - mode->height / 4); if (!(*Window)->Window) { log_err("Unable to create OpenGL window"); Application_Error(); } glfwMakeContextCurrent((*Window)->Window); if (gl3wInit()) { log_err("failed to initialize OpenGL"); Application_Error(); } if (!gl3wIsSupported(3, 3)) { log_err("OpenGL 3.3 not supported"); Application_Error(); } glGenVertexArrays(1, &(*Window)->DefaultVAO); glBindVertexArray((*Window)->DefaultVAO); (*Window)->Running = true; printOpenGLError(); log_info("Window has been created"); return; error: Window_Free(Window); Application_Error(); return; }