static inline jlong wrapped_Java_com_badlogic_jglfw_Glfw_glfwCreateWindowJni
(JNIEnv* env, jclass clazz, jint width, jint height, jstring obj_title, jlong monitor, jlong share, char* title) {
//@line:704
GLFWwindow* window = glfwCreateWindow(width, height, title, (GLFWmonitor*)monitor, (GLFWwindow*)share);
if (window) {
glfwSetWindowPosCallback(window, windowPos);
glfwSetWindowSizeCallback(window, windowSize);
glfwSetWindowCloseCallback(window, windowClose);
glfwSetWindowRefreshCallback(window, windowRefresh);
glfwSetWindowFocusCallback(window, windowFocus);
glfwSetWindowIconifyCallback(window, windowIconify);
glfwSetKeyCallback(window, key);
glfwSetCharCallback(window, character);
glfwSetMouseButtonCallback(window, mouseButton);
glfwSetCursorPosCallback(window, cursorPos);
glfwSetCursorEnterCallback(window, cursorEnter);
glfwSetScrollCallback(window, scroll);
glfwSetDropCallback(window, drop);
}
return (jlong)window;
}
void WindowEventDispatcher::registerWindow(Window* window)
{
assert(window != nullptr);
GLFWwindow * glfwWindow = window->internalWindow();
if (!glfwWindow)
return;
glfwSetWindowUserPointer(glfwWindow, window);
glfwSetWindowRefreshCallback(glfwWindow, handleRefresh);
glfwSetKeyCallback(glfwWindow, handleKey);
glfwSetCharCallback(glfwWindow, handleChar);
glfwSetMouseButtonCallback(glfwWindow, handleMouse);
glfwSetCursorPosCallback(glfwWindow, handleCursorPos);
glfwSetCursorEnterCallback(glfwWindow, handleCursorEnter);
glfwSetScrollCallback(glfwWindow, handleScroll);
glfwSetWindowSizeCallback(glfwWindow, handleResize);
glfwSetFramebufferSizeCallback(glfwWindow, handleFramebufferResize);
glfwSetWindowFocusCallback(glfwWindow, handleFocus);
glfwSetWindowPosCallback(glfwWindow, handleMove);
glfwSetWindowIconifyCallback(glfwWindow, handleIconify);
glfwSetWindowCloseCallback(glfwWindow, handleClose);
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_FALSE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, argv[0], NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
init();
glfwSetWindowSize( window, 850, 200 );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
glDeleteTextures( 1, &atlas->id );
atlas->id = 0;
texture_atlas_delete( atlas );
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
void Init()
{
const int window_width = 800,
window_height = 600;
if (glfwInit() != GL_TRUE)
Shut_Down(1);
// 800 x 600, 16 bit color, no depth, alpha or stencil buffers, windowed
if (glfwOpenWindow(window_width, window_height, 5, 6, 5,
0, 0, 0, GLFW_WINDOW) != GL_TRUE)
Shut_Down(1);
glfwSetWindowTitle("The GLFW Window");
glfwSetKeyCallback( OnKeyPressed );
glfwSetCharCallback( OnCharPressed );
glfwSetWindowCloseCallback(OnClose);
glfwSetWindowSizeCallback(OnResize);
glfwSetWindowRefreshCallback(OnRefresh);
glfwSetMouseWheelCallback(OnMouseWheel);
glfwSetMousePosCallback(OnMouseMove);
glfwSetMouseButtonCallback(OnMouseClick);
// set the projection matrix to a normal frustum with a max depth of 50
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float aspect_ratio = ((float)window_height) / window_width;
glFrustum(.5, -.5, -.5 * aspect_ratio, .5 * aspect_ratio, 1, 50);
glMatrixMode(GL_MODELVIEW);
PullInfo();
}
void WindowEventDispatcher::deregisterWindow(Window* window)
{
assert(window != nullptr);
GLFWwindow* glfwWindow = window->internalWindow();
if (!glfwWindow)
return;
glfwSetWindowRefreshCallback(glfwWindow, nullptr);
glfwSetKeyCallback(glfwWindow, nullptr);
glfwSetCharCallback(glfwWindow, nullptr);
glfwSetMouseButtonCallback(glfwWindow, nullptr);
glfwSetCursorPosCallback(glfwWindow, nullptr);
glfwSetCursorEnterCallback(glfwWindow, nullptr);
glfwSetScrollCallback(glfwWindow, nullptr);
glfwSetWindowSizeCallback(glfwWindow, nullptr);
glfwSetFramebufferSizeCallback(glfwWindow, nullptr);
glfwSetWindowFocusCallback(glfwWindow, nullptr);
glfwSetWindowPosCallback(glfwWindow, nullptr);
glfwSetWindowIconifyCallback(glfwWindow, nullptr);
glfwSetWindowCloseCallback(glfwWindow, nullptr);
removeTimers(window);
}
bool WindowGL33::removeRefreshCallback(RefreshEventType::DelegatePtr const& callback)
{
bool ret = m_refreshCallbacks.removeListener(callback);
if (!m_refreshCallbacks.hasListener())
glfwSetWindowRefreshCallback(m_pWndHandle, NULL);
return ret;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, "Freetype OpenGL benchmark", NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 0 ); // disable V-SYNC
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
init();
glfwSetWindowSize( window, 800, 600 );
glfwShowWindow( window );
glfwSetTime(0.0);
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
int main(int argc, char** argv) {
int running = GL_TRUE;
// Initialize GLFW
if (!glfwInit()) {
exit(EXIT_FAILURE);
}
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
// glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
// glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1);
// glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL
// Open an OpenGL window
if (!glfwOpenWindow(1280, 720, 0, 0, 0, 0, 32, 0, GLFW_WINDOW)) {
glfwTerminate();
return EXIT_FAILURE;
}
glfwSetWindowTitle("Capivara-GL Test");
// glEnable(GL_LINE_SMOOTH);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
// glLineWidth(1.5f);
glfwEnable(GLFW_KEY_REPEAT);
glfwEnable(GLFW_STICKY_KEYS);
glEnable(GL_MULTISAMPLE);
glDisable(GL_DEPTH_TEST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
initComponents();
glfwSetKeyCallback(keyCallback);
glfwSetCharCallback(charCallback);
glfwSetWindowRefreshCallback(display);
glfwSetWindowSizeCallback(reshape);
glfwSetMousePosCallback(mousePosition);
glfwSetMouseButtonCallback(mouseButton);
//-------------------------------------------------------------------------
// Main loop
while (running) {
display();
glfwSwapBuffers();
running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
}
deleteComponents();
// Close window and terminate GLFW
glfwTerminate();
return EXIT_SUCCESS;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
glfwSetErrorCallback( error_callback );
if (!glfwInit( )) { exit( EXIT_FAILURE ); }
glfwWindowHint( GLFW_VISIBLE, GL_FALSE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
auto window = glfwCreateWindow( 1, 1, argv[0], nullptr, nullptr);
if (!window) {
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
init();
fprintf(stderr, "Total time to generate distance map: %fs\n", total_time);
glfwSetWindowSize( window, 800, 600 );
glfwShowWindow( window );
glfwSetTime(0.0);
while(!glfwWindowShouldClose( window )) {
display( window );
glfwPollEvents( );
}
glDeleteTextures( 1, &atlas->id );
atlas->id = 0;
texture_atlas_delete( atlas );
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
int main(void)
{
GLFWwindow* window;
int width, height;
setlocale(LC_ALL, "");
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
printf("Library initialized\n");
window = glfwCreateWindow(640, 480, "Event Linter", NULL, NULL);
if (!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
printf("Window opened\n");
glfwSetMonitorCallback(monitor_callback);
glfwSetWindowPosCallback(window, window_pos_callback);
glfwSetWindowSizeCallback(window, window_size_callback);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwSetWindowCloseCallback(window, window_close_callback);
glfwSetWindowRefreshCallback(window, window_refresh_callback);
glfwSetWindowFocusCallback(window, window_focus_callback);
glfwSetWindowIconifyCallback(window, window_iconify_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetCursorPosCallback(window, cursor_position_callback);
glfwSetCursorEnterCallback(window, cursor_enter_callback);
glfwSetScrollCallback(window, scroll_callback);
glfwSetKeyCallback(window, key_callback);
glfwSetCharCallback(window, char_callback);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwGetWindowSize(window, &width, &height);
printf("Window size should be %ix%i\n", width, height);
printf("Main loop starting\n");
while (!glfwWindowShouldClose(window))
{
glfwWaitEvents();
// Workaround for an issue with msvcrt and mintty
fflush(stdout);
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
void setupCallbacks(){
glfwSetWindowSizeCallback( GLFWWindowSizeCb );
glfwSetWindowCloseCallback( GLFWWindowCloseCb );
glfwSetWindowRefreshCallback( GLFWWindowRefreshCb );
glfwSetKeyCallback( GLFWKeyCb );
glfwSetCharCallback( GLFWMousePosCb );
glfwSetMouseButtonCallback( GLFWMouseButtonCb );
glfwSetMousePosCallback( GLFWMousePosCb );
glfwSetMouseWheelCallback( GLFWMouseWheelCb );
};
int main(void)
{
GLFWwindow window;
int width, height;
setlocale(LC_ALL, "");
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
printf("Library initialized\n");
glfwSetWindowSizeCallback(window_size_callback);
glfwSetWindowCloseCallback(window_close_callback);
glfwSetWindowRefreshCallback(window_refresh_callback);
glfwSetWindowFocusCallback(window_focus_callback);
glfwSetWindowIconifyCallback(window_iconify_callback);
glfwSetMouseButtonCallback(mouse_button_callback);
glfwSetCursorPosCallback(cursor_position_callback);
glfwSetCursorEnterCallback(cursor_enter_callback);
glfwSetScrollCallback(scroll_callback);
glfwSetKeyCallback(key_callback);
glfwSetCharCallback(char_callback);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL);
if (!window)
{
glfwTerminate();
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
printf("Window opened\n");
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwGetWindowSize(window, &width, &height);
printf("Window size should be %ix%i\n", width, height);
printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled");
printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled");
printf("Main loop starting\n");
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
glfwWaitEvents();
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main(void)
{
GLFWwindow* window;
// Initialise GLFW
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW\n");
exit(EXIT_FAILURE);
}
// Open OpenGL window
window = glfwCreateWindow(500, 500, "Split view demo", NULL, NULL);
if (!window)
{
fprintf(stderr, "Failed to open GLFW window\n");
glfwTerminate();
exit(EXIT_FAILURE);
}
// Set callback functions
glfwSetFramebufferSizeCallback(window, framebufferSizeFun);
glfwSetWindowRefreshCallback(window, windowRefreshFun);
glfwSetCursorPosCallback(window, cursorPosFun);
glfwSetMouseButtonCallback(window, mouseButtonFun);
glfwSetKeyCallback(window, key_callback);
// Enable vsync
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwGetFramebufferSize(window, &width, &height);
framebufferSizeFun(window, width, height);
// Main loop
for (;;)
{
// Only redraw if we need to
if (do_redraw)
windowRefreshFun(window);
// Wait for new events
glfwWaitEvents();
// Check if the window should be closed
if (glfwWindowShouldClose(window))
break;
}
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit(EXIT_SUCCESS);
}
// uiloop
void ui_loop(const ym_string& filename, const ym_string& imfilename,
yo_scene* scene, ysr_scene* rigid_scene, float dt, int w, int h,
bool camera_lights, float amb, bool no_ui) {
// view data
view_params* view = init_view_params(
filename, imfilename, scene, rigid_scene, dt, w, h, camera_lights, amb);
// glfw
if (!glfwInit()) exit(EXIT_FAILURE);
GLFWwindow* window = glfwCreateWindow(view->w, view->h, "yshade", 0, 0);
glfwMakeContextCurrent(window);
glfwSetWindowUserPointer(window, view);
// callbacks
glfwSetCharCallback(window, text_callback);
glfwSetWindowSizeCallback(window, window_size_callback);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetCursorPosCallback(window, mouse_pos_callback);
glfwSetWindowRefreshCallback(window, window_refresh_callback);
// init gl extensions
#ifndef __APPLE__
if (glewInit() != GLEW_OK) exit(EXIT_FAILURE);
#endif
// init shade state
view->shade_prog = yg_stdshader_make_program();
view->shade_txt.resize(scene->textures.size());
for (int i = 0; i < scene->textures.size(); i++) {
yo_texture* txt = &scene->textures[i];
view->shade_txt[i] =
yg_make_texture(txt->pixels.data(), txt->width, txt->height,
txt->ncomp, false, true);
}
// ui loop
while (!glfwWindowShouldClose(window)) {
window_refresh_callback(window);
if (view->simulating) {
simulate_step(view);
glfwPollEvents();
} else {
glfwWaitEvents();
}
}
glfwDestroyWindow(window);
glfwTerminate();
delete view;
}
/////////////////////////////////////////////////////////
// createMess
//
/////////////////////////////////////////////////////////
bool gemglfw2window :: create(void)
{
int mode = GLFW_WINDOW;
if(0!=s_window) {
error("window already made!");
return false;
}
if(m_fullscreen)
mode=GLFW_FULLSCREEN;
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, m_fsaa);
if(m_profile_major) {
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, m_profile_major); // We want OpenGL 3.3
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, m_profile_minor);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL
}
if (!glfwOpenWindow(m_width, m_height,
8, 8, 8, 8, /* RGBA bits */
24, 8, /* depth/stencil bits */
mode)) {
error("glfw couldn't create window");
return false;
}
// FIXXME: single/double buffering
if(!createGemWindow()) {
destroyMess();
return false;
}
s_window=this;
titleMess(m_title);
offsetMess(m_xoffset, m_yoffset);
cursorMess(m_cursor);
glfwSetWindowSizeCallback (windowsizeCb);
glfwSetWindowCloseCallback (windowcloseCb);
glfwSetWindowRefreshCallback(windowrefreshCb);
glfwSetKeyCallback (keyCb);
glfwSetCharCallback (charCb);
glfwSetMouseButtonCallback (mousebuttonCb);
glfwSetMousePosCallback (mouseposCb);
glfwSetMouseWheelCallback (mousewheelCb);
dispatch();
return (0!=s_window);
}
int main(void)
{
setlocale(LC_ALL, "");
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW\n");
exit(1);
}
printf("Library initialized\n");
if (!glfwOpenWindow(0, 0, 0, 0, 0, 0, 0, 0, GLFW_WINDOW))
{
glfwTerminate();
fprintf(stderr, "Failed to create GLFW window");
exit(1);
}
printf("Window opened\n");
glfwSetWindowTitle("Event Linter");
glfwSwapInterval(1);
glfwSetWindowSizeCallback(window_size_callback);
glfwSetWindowCloseCallback(window_close_callback);
glfwSetWindowRefreshCallback(window_refresh_callback);
glfwSetMouseButtonCallback(mouse_button_callback);
glfwSetMousePosCallback(mouse_position_callback);
glfwSetMouseWheelCallback(mouse_wheel_callback);
glfwSetKeyCallback(key_callback);
glfwSetCharCallback(char_callback);
printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled");
printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled");
printf("Main loop starting\n");
while (glfwGetWindowParam(GLFW_OPENED) == GL_TRUE)
{
glfwWaitEvents();
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
}
glfwTerminate();
exit(0);
}
DuiHWND CWindowWnd::Create(DuiHWND hwndParent, const char* pstrName,int x, int y, int cx , int cy)
{
m_hWnd = glfwCreateWindow(cx, cy, pstrName, NULL, NULL);
glfwMakeContextCurrent(m_hWnd);
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
glfwSetWindowUserPointer(m_hWnd, this);
// bind callback for wnd.
{
glfwSetWindowRefreshCallback(m_hWnd, window_refresh_callback);
glfwSetFramebufferSizeCallback(m_hWnd, framebuffer_size_callback);
}
HandleMessage(UI_WM_CREATE, cx, cy);
return m_hWnd;
}
void Window::initialize() {
// set ALL the callbacks
glfwSetWindowPosCallback(m_handle, callbackWindowPos);
glfwSetWindowSizeCallback(m_handle, callbackWindowSize);
glfwSetWindowCloseCallback(m_handle, callbackWindowClose);
glfwSetWindowRefreshCallback(m_handle, callbackWindowRefresh);
glfwSetWindowFocusCallback(m_handle, callbackWindowFocus);
glfwSetWindowIconifyCallback(m_handle, callbackWindowIconify);
glfwSetFramebufferSizeCallback(m_handle, callbackFramebufferSize);
glfwSetMouseButtonCallback(m_handle, callbackMouseButton);
glfwSetCursorPosCallback(m_handle, callbackCursorPos);
glfwSetCursorEnterCallback(m_handle, callbackCursorEnter);
glfwSetScrollCallback(m_handle, callbackScroll);
glfwSetKeyCallback(m_handle, callbackKey);
glfwSetCharCallback(m_handle, callbackChar);
// create a windowdata object
glfwSetWindowUserPointer(m_handle, new WindowData(this));
}
// uiloop
void
ui_loop(int nimgs, view_img* imgs) {
// view params
view_params* view = init_view_params(nimgs, imgs);
// window
if (!glfwInit()) exit(EXIT_FAILURE);
GLFWwindow* window = glfwCreateWindow(view->w, view->h, "imview", 0, 0);
glfwMakeContextCurrent(window);
glfwSetWindowUserPointer(window, view);
// callbacks
glfwSetCharCallback(window, text_callback);
glfwSetWindowSizeCallback(window, window_size_callback);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetCursorPosCallback(window, mouse_pos_callback);
glfwSetWindowRefreshCallback(window, window_refresh_callback);
// init gl extensions
#ifdef YG_USING_GLEW
if (glewInit() != GLEW_OK) exit(EXIT_FAILURE);
#endif
// load textures
for (int i = 0; i < nimgs; i++) {
imgs[i].tex_glid = yg_make_texture(imgs[i].pixels, imgs[i].w, imgs[i].h,
imgs[i].nc, true, false);
}
// ui loop
while (!glfwWindowShouldClose(window)) {
window_refresh_callback(window);
glfwWaitEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
free(view);
}
Window::Window(int width, int height, std::string title, bool fullScreen) :
_inputManagerUPtr(std::unique_ptr<InputManager>(new InputManager())) {
glfwSetErrorCallback(OnError);
glfwInit();
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);
if (!fullScreen)
_glfwWindowPtr = glfwCreateWindow(width, height, title.c_str(), NULL, NULL);
else
_glfwWindowPtr = glfwCreateWindow(width, height, title.c_str(), glfwGetPrimaryMonitor(), NULL);
glfwMakeContextCurrent(_glfwWindowPtr);
glewExperimental = GL_TRUE;
glewInit();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glfwSetWindowUserPointer(_glfwWindowPtr, this);
glfwSetWindowCloseCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowClosed);
glfwSetWindowFocusCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowFocused);
glfwSetWindowSizeCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowResized);
glfwSetWindowIconifyCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowIconify);
glfwSetWindowPosCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowPositionChanged);
glfwSetFramebufferSizeCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowFramebufferResized);
glfwSetWindowRefreshCallback(_glfwWindowPtr, _inputManagerUPtr->OnWindowRefreshed);
glfwSetKeyCallback(_glfwWindowPtr, _inputManagerUPtr->OnKeyPressed);
glfwSetMouseButtonCallback(_glfwWindowPtr, _inputManagerUPtr->OnMouseButton);
glfwSetScrollCallback(_glfwWindowPtr, _inputManagerUPtr->OnScroll);
glfwSetCursorEnterCallback(_glfwWindowPtr, _inputManagerUPtr->OnCursorEnter);
glfwSetCursorPosCallback(_glfwWindowPtr, _inputManagerUPtr->OnCursorPositionChanged);
_inputManagerUPtr->OnWindowResized(_glfwWindowPtr, width, height);
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
GLFWwindow* window;
char* screenshot_path = NULL;
if (argc > 1)
{
if (argc == 3 && 0 == strcmp( "--screenshot", argv[1] ))
screenshot_path = argv[2];
else
{
fprintf( stderr, "Unknown or incomplete parameters given\n" );
exit( EXIT_FAILURE );
}
}
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 512, 512, argv[0], NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
init();
glfwShowWindow( window );
reshape( window, 512, 512 );
while (!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
if (screenshot_path)
{
screenshot( window, screenshot_path );
glfwSetWindowShouldClose( window, 1 );
}
}
glDeleteTextures( 1, &atlas->id );
atlas->id = 0;
texture_atlas_delete( atlas );
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
int main(int argc, char** argv)
{
Slot* slots;
GLFWmonitor* monitor = NULL;
int ch, i, width, height, count = 1;
setlocale(LC_ALL, "");
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
printf("Library initialized\n");
glfwSetMonitorCallback(monitor_callback);
while ((ch = getopt(argc, argv, "hfn:")) != -1)
{
switch (ch)
{
case 'h':
usage();
exit(EXIT_SUCCESS);
case 'f':
monitor = glfwGetPrimaryMonitor();
break;
case 'n':
count = (int) strtol(optarg, NULL, 10);
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
if (monitor)
{
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
glfwWindowHint(GLFW_RED_BITS, mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
width = mode->width;
height = mode->height;
}
else
{
width = 640;
height = 480;
}
if (!count)
{
fprintf(stderr, "Invalid user\n");
exit(EXIT_FAILURE);
}
slots = calloc(count, sizeof(Slot));
for (i = 0; i < count; i++)
{
char title[128];
slots[i].closeable = GL_TRUE;
slots[i].number = i + 1;
sprintf(title, "Event Linter (Window %i)", slots[i].number);
if (monitor)
{
printf("Creating full screen window %i (%ix%i on %s)\n",
slots[i].number,
width, height,
glfwGetMonitorName(monitor));
}
else
{
printf("Creating windowed mode window %i (%ix%i)\n",
slots[i].number,
width, height);
}
slots[i].window = glfwCreateWindow(width, height, title, monitor, NULL);
if (!slots[i].window)
{
free(slots);
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetWindowUserPointer(slots[i].window, slots + i);
glfwSetWindowPosCallback(slots[i].window, window_pos_callback);
glfwSetWindowSizeCallback(slots[i].window, window_size_callback);
glfwSetFramebufferSizeCallback(slots[i].window, framebuffer_size_callback);
glfwSetWindowCloseCallback(slots[i].window, window_close_callback);
glfwSetWindowRefreshCallback(slots[i].window, window_refresh_callback);
glfwSetWindowFocusCallback(slots[i].window, window_focus_callback);
glfwSetWindowIconifyCallback(slots[i].window, window_iconify_callback);
glfwSetMouseButtonCallback(slots[i].window, mouse_button_callback);
glfwSetCursorPosCallback(slots[i].window, cursor_position_callback);
glfwSetCursorEnterCallback(slots[i].window, cursor_enter_callback);
glfwSetScrollCallback(slots[i].window, scroll_callback);
glfwSetKeyCallback(slots[i].window, key_callback);
glfwSetCharCallback(slots[i].window, char_callback);
glfwSetCharModsCallback(slots[i].window, char_mods_callback);
glfwSetDropCallback(slots[i].window, drop_callback);
glfwMakeContextCurrent(slots[i].window);
glfwSwapInterval(1);
}
printf("Main loop starting\n");
for (;;)
{
for (i = 0; i < count; i++)
{
if (glfwWindowShouldClose(slots[i].window))
break;
}
if (i < count)
break;
glfwWaitEvents();
// Workaround for an issue with msvcrt and mintty
fflush(stdout);
}
free(slots);
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main( void )
{
int running;
// Initialise GLFW
glfwInit();
// Open OpenGL window
if( !glfwOpenWindow( 500, 500, 0,0,0,0, 16,0, GLFW_WINDOW ) )
{
glfwTerminate();
return 0;
}
// Set window title
glfwSetWindowTitle( "Split view demo" );
// Enable sticky keys
glfwEnable( GLFW_STICKY_KEYS );
// Enable mouse cursor (only needed for fullscreen mode)
glfwEnable( GLFW_MOUSE_CURSOR );
// Disable automatic event polling
glfwDisable( GLFW_AUTO_POLL_EVENTS );
// Set callback functions
glfwSetWindowSizeCallback( WindowSizeFun );
glfwSetWindowRefreshCallback( WindowRefreshFun );
glfwSetMousePosCallback( MousePosFun );
glfwSetMouseButtonCallback( MouseButtonFun );
// Main loop
do
{
// Only redraw if we need to
if( do_redraw )
{
// Draw all views
DrawAllViews();
// Swap buffers
glfwSwapBuffers();
do_redraw = 0;
}
// Wait for new events
glfwWaitEvents();
// Check if the ESC key was pressed or the window was closed
running = !glfwGetKey( GLFW_KEY_ESC ) &&
glfwGetWindowParam( GLFW_OPENED );
}
while( running );
// Close OpenGL window and terminate GLFW
glfwTerminate();
return 0;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, "Glyph Cartoon", NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
atlas = texture_atlas_new( 1024, 1024, 1 );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
texture_font_t *font =
texture_font_new_from_file( atlas, 128, "fonts/LuckiestGuy.ttf" );
vec2 pen = {{50, 50}};
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 yellow = {{1.0, 1.0, 0.0, 1.0}};
vec4 orange1 = {{1.0, 0.9, 0.0, 1.0}};
vec4 orange2 = {{1.0, 0.6, 0.0, 1.0}};
font->outline_type = 2;
font->outline_thickness = 7;
add_text( buffer, font, L"Freetype GL", pen, black, black );
font->outline_type = 2;
font->outline_thickness = 5;
add_text( buffer, font, L"Freetype GL", pen, yellow, yellow );
font->outline_type = 1;
font->outline_thickness = 3;
add_text( buffer, font, L"Freetype GL", pen, black, black );
font->outline_type = 0;
font->outline_thickness = 0;
add_text( buffer, font, L"Freetype GL", pen, orange1, orange2 );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glfwSetWindowSize( window, 850, 200 );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
glfwDestroyWindow( window );
glfwTerminate( );
return 0;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
GLFWwindow* window;
char* screenshot_path = NULL;
if (argc > 1)
{
if (argc == 3 && 0 == strcmp( "--screenshot", argv[1] ))
screenshot_path = argv[2];
else
{
fprintf( stderr, "Unknown or incomplete parameters given\n" );
exit( EXIT_FAILURE );
}
}
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_FALSE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 800, 600, argv[0], NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
TwInit( TW_OPENGL, NULL );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetCursorPosCallback( window, cursor_pos );
glfwSetMouseButtonCallback( window, mouse_button );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
init( window );
glfwShowWindow( window );
reshape( window, 800, 600 );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
if (screenshot_path)
{
screenshot( window, screenshot_path );
glfwSetWindowShouldClose( window, 1 );
}
}
TwTerminate();
glDeleteProgram( text_shader );
glDeleteTextures( 1, &font_manager_a->atlas->id );
glDeleteTextures( 1, &font_manager_rgb->atlas->id );
font_manager_a->atlas->id = 0;
font_manager_rgb->atlas->id = 0;
font_manager_delete( font_manager_rgb );
font_manager_delete( font_manager_a );
text_buffer_delete( text_buffer );
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
void callbacksInit(GLFWwindow * window) {
glfwSetKeyCallback(window, keyCallback);
glfwSetCursorPosCallback(window, cursorPosCallback);
glfwSetWindowRefreshCallback(window, winRefreshCallback);
glfwSetWindowSizeCallback(window, winResizeCallback);
}
// Main
int main(int argc, char *argv[])
{
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, "Font rendering advanced tweaking", NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
TwInit( TW_OPENGL, NULL );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetCursorPosCallback( window, cursor_pos );
glfwSetMouseButtonCallback( window, mouse_button );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
// Create a new tweak bar
bar = TwNewBar("TweakBar");
TwDefine("GLOBAL "
"help = 'This example shows how to tune all font parameters.' ");
TwDefine("TweakBar "
"size = '280 400' "
"position = '500 20' "
"color = '127 127 127' "
"alpha = 240 "
"label = 'Parameters' "
"resizable = True "
"fontresizable = True "
"iconifiable = True ");
{
TwEnumVal familyEV[NUM_FONTS] = {
{VERA, "Vera"},
{VERA_MONO, "Vera Mono"},
{LUCKIEST_GUY, "Luckiest Guy"},
{SOURCE_SANS, "Source Sans Pro"},
{SOURCE_CODE, "Source Code Pro"},
{OLD_STANDARD, "Old Standard TT"},
{LOBSTER, "Lobster"} };
TwType family_type = TwDefineEnum("Family", familyEV, NUM_FONTS);
TwAddVarCB(bar, "Family", family_type, set_family, get_family, NULL,
"label = 'Family' "
"group = 'Font' "
"help = ' ' ");
}
TwAddVarCB(bar, "Size", TW_TYPE_FLOAT, set_size, get_size, NULL,
"label = 'Size' "
"group = 'Font' "
"min = 6.0 "
"max = 24.0 "
"step = 0.05 "
"help = ' ' ");
TwAddVarCB(bar, "LCD filtering", TW_TYPE_BOOL32, set_lcd_filtering, get_lcd_filtering, NULL,
"label = 'LCD filtering' "
"group = 'Font' "
"help = ' ' ");
// Rendering
TwAddVarCB(bar, "Kerning", TW_TYPE_BOOL32, set_kerning, get_kerning, NULL,
"label = 'Kerning' "
"group = 'Rendering' "
"help = ' ' ");
TwAddVarCB(bar, "Hinting", TW_TYPE_BOOL32, set_hinting, get_hinting, NULL,
"label = 'Hinting' "
"group = 'Rendering' "
"help = ' ' ");
// Color
TwAddVarCB(bar, "Invert", TW_TYPE_BOOL32, set_invert, get_invert, NULL,
"label = 'Invert' "
"group = 'Color' "
"help = ' ' ");
// Glyph
TwAddVarCB(bar, "Width", TW_TYPE_FLOAT, set_width, get_width, NULL,
"label = 'Width' "
"group = 'Glyph' "
"min = 0.75 "
"max = 1.25 "
"step = 0.01 "
"help = ' ' ");
TwAddVarCB(bar, "Interval", TW_TYPE_FLOAT, set_interval, get_interval, NULL,
"label = 'Spacing' "
"group = 'Glyph' "
"min = -0.2 "
"max = 0.2 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Faux italic", TW_TYPE_FLOAT, set_faux_italic, get_faux_italic, NULL,
"label = 'Faux italic' "
"group = 'Glyph' "
"min = -30.0 "
"max = 30.0 "
"step = 0.1 "
"help = ' ' ");
// Energy distribution
TwAddVarCB(bar, "Primary", TW_TYPE_FLOAT, set_primary, get_primary, NULL,
"label = 'Primary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Secondary", TW_TYPE_FLOAT, set_secondary, get_secondary, NULL,
"label = 'Secondy weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Tertiary", TW_TYPE_FLOAT, set_tertiary, get_tertiary, NULL,
"label = 'Tertiary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddSeparator(bar, "",
"group = 'Energy distribution' " );
TwAddVarCB(bar, "Gamma", TW_TYPE_FLOAT, set_gamma, get_gamma, NULL,
"label = 'Gamma correction' "
"group = 'Energy distribution' "
"min = 0.50 "
"max = 2.5 "
"step = 0.01 "
"help = ' ' ");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Reset", (TwButtonCallback) reset, NULL,
"help='Reset all parameters to default values.'");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Quit", (TwButtonCallback) quit, window,
"help='Quit.'");
buffer_a = text_buffer_new( 1 );
buffer_rgb = text_buffer_new( 3 );
buffer = buffer_rgb;
reset();
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glfwSetWindowSize( window, 800, 600 );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
TwTerminate();
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
int width = 600;
int height = 600;
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, "Freetype OpenGL", NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
vec4 blue = {{0,0,1,1}};
vec4 black = {{0,0,0,1}};
texture_atlas_t * atlas = texture_atlas_new( 512, 512, 1);
texture_font_t * big = texture_font_new_from_file( atlas, 400, "fonts/Vera.ttf");
texture_font_t * small = texture_font_new_from_file( atlas, 18, "fonts/Vera.ttf");
texture_font_t * title = texture_font_new_from_file( atlas, 32, "fonts/Vera.ttf");
text_buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
line_buffer = vertex_buffer_new( "vertex:3f,color:4f" );
point_buffer = vertex_buffer_new( "vertex:3f,color:4f" );
vec2 pen, origin;
texture_glyph_t *glyph = texture_font_get_glyph( big, L'g' );
origin.x = width/2 - glyph->offset_x - glyph->width/2;
origin.y = height/2 - glyph->offset_y + glyph->height/2;
add_text( text_buffer, big, L"g", &black, &origin );
// title
pen.x = 50;
pen.y = 560;
add_text( text_buffer, title, L"Glyph metrics", &black, &pen );
point_t vertices[] =
{ // Baseline
{0.1*width, origin.y, 0, black},
{0.9*width, origin.y, 0, black},
// Top line
{0.1*width, origin.y + glyph->offset_y, 0, black},
{0.9*width, origin.y + glyph->offset_y, 0, black},
// Bottom line
{0.1*width, origin.y + glyph->offset_y - glyph->height, 0, black},
{0.9*width, origin.y + glyph->offset_y - glyph->height, 0, black},
// Left line at origin
{width/2-glyph->offset_x-glyph->width/2, 0.1*height, 0, black},
{width/2-glyph->offset_x-glyph->width/2, 0.9*height, 0, black},
// Left line
{width/2 - glyph->width/2, .3*height, 0, black},
{width/2 - glyph->width/2, .9*height, 0, black},
// Right line
{width/2 + glyph->width/2, .3*height, 0, black},
{width/2 + glyph->width/2, .9*height, 0, black},
// Right line at origin
{width/2-glyph->offset_x-glyph->width/2+glyph->advance_x, 0.1*height, 0, black},
{width/2-glyph->offset_x-glyph->width/2+glyph->advance_x, 0.7*height, 0, black},
// Width
{width/2 - glyph->width/2, 0.8*height, 0, blue},
{width/2 + glyph->width/2, 0.8*height, 0, blue},
// Advance_x
{width/2-glyph->width/2-glyph->offset_x, 0.2*height, 0, blue},
{width/2-glyph->width/2-glyph->offset_x+glyph->advance_x, 0.2*height, 0, blue},
// Offset_x
{width/2-glyph->width/2-glyph->offset_x, 0.85*height, 0, blue},
{width/2-glyph->width/2, 0.85*height, 0, blue},
// Height
{0.3*width/2, origin.y + glyph->offset_y - glyph->height, 0, blue},
{0.3*width/2, origin.y + glyph->offset_y, 0, blue},
// Offset y
{0.8*width, origin.y + glyph->offset_y, 0, blue},
{0.8*width, origin.y , 0, blue},
};
GLuint indices [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,
13,14,15,16,17,18,19,20,21,22,23,24,25};
vertex_buffer_push_back( line_buffer, vertices, 26, indices, 26 );
pen.x = width/2 - 48;
pen.y = .2*height - 18;
add_text( text_buffer, small, L"advance_x", &blue, &pen );
pen.x = width/2 - 20;
pen.y = .8*height + 3;
add_text( text_buffer, small, L"width", &blue, &pen );
pen.x = width/2 - glyph->width/2 + 5;
pen.y = .85*height-8;
add_text( text_buffer, small, L"offset_x", &blue, &pen );
pen.x = 0.2*width/2-30;
pen.y = origin.y + glyph->offset_y - glyph->height/2;
add_text( text_buffer, small, L"height", &blue, &pen );
pen.x = 0.8*width+3;
pen.y = origin.y + glyph->offset_y/2 -6;
add_text( text_buffer, small, L"offset_y", &blue, &pen );
pen.x = width/2 - glyph->offset_x - glyph->width/2 - 58;
pen.y = height/2 - glyph->offset_y + glyph->height/2 - 20;
add_text( text_buffer, small, L"Origin", &black, &pen );
GLuint i = 0;
point_t p;
p.color = black;
// Origin point
p.x = width/2 - glyph->offset_x - glyph->width/2;
p.y = height/2 - glyph->offset_y + glyph->height/2;
vertex_buffer_push_back( point_buffer, &p, 1, &i, 1 );
// Advance point
p.x = width/2 - glyph->offset_x - glyph->width/2 + glyph->advance_x;
p.y = height/2 - glyph->offset_y + glyph->height/2;
vertex_buffer_push_back( point_buffer, &p, 1, &i, 1 );
text_shader = shader_load( "shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag" );
shader = shader_load( "shaders/v3f-c4f.vert",
"shaders/v3f-c4f.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glfwSetWindowSize( window, width, height );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
glfwDestroyWindow( window );
glfwTerminate( );
return 0;
}
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);
}
int main(int argc, char** argv) {
g_validationLayers = std::vector<const char*> {
"VK_LAYER_LUNARG_mem_tracker",
"VK_LAYER_GOOGLE_unique_objects",
};
// Init GLFW
{
// Handle GLFW errors
glfwSetErrorCallback([](int error, const char* description) {
std::cout << "GLFW error: " << error << " - " << description << std::endl;
});
// Initialize GLFW
if (!glfwInit())
error("Cannot initialize GLFW.");
// Check Vulkan support
if (!glfwVulkanSupported())
error("Cannot find compatible Vulkan client driver.");
}
// Get Validation layers
{
uint32_t numInstanceLayers = 0;
// Get numInstanceLayers
if (vkEnumerateInstanceLayerProperties(&numInstanceLayers, nullptr))
error("Vulkan: Could not enumerate instance layer properties.");
if (numInstanceLayers > 0) {
std::vector<VkLayerProperties> instanceLayers(numInstanceLayers);
if (vkEnumerateInstanceLayerProperties(&numInstanceLayers, instanceLayers.data()))
error("Vulkan: Could not enumerate instance layer properties.");
// Print layers:
std::cout << "Validation layers: " << std::endl;
for (int i = 0; i < numInstanceLayers; ++i) {
std::cout << "\t" << instanceLayers[i].layerName << std::endl;
std::cout << "\t\t" << instanceLayers[i].description << std::endl;
std::cout << std::endl;
}
std::cout << std::endl;
}
else
std::cout << "No validation layers found!" << std::endl;
// TODO: Check Layers
}
// Check instance extensions
{
int numRequiredExtensions;
const char** requiredExtensions;
// Get required extensions from GLFW
{
requiredExtensions = glfwGetRequiredInstanceExtensions((int*)&numRequiredExtensions);
if (numRequiredExtensions > 0) {
// Write to global g_extensions
for (int i = 0; i < numRequiredExtensions; ++i)
g_extensions.push_back(requiredExtensions[i]);
// Print
std::cout << "Required Instance Extensions(GLFW):" << std::endl;
for (int i = 0; i < numRequiredExtensions; ++i) {
std::cout << "\t" << requiredExtensions[i] << std::endl;
}
std::cout << std::endl;
}
// TODO: Check extensions
}
// Get Instance extensions
{
VkResult err;
uint32_t numInstanceExtensions;
err = vkEnumerateInstanceExtensionProperties(nullptr, &numInstanceExtensions, nullptr);
if (numInstanceExtensions > 0) {
std::vector<VkExtensionProperties> instanceExtensions(numInstanceExtensions);
err = vkEnumerateInstanceExtensionProperties(NULL, &numInstanceExtensions, instanceExtensions.data());
// Print
std::cout << "Instance Extensions: " << std::endl;
for (int i = 0; i < numInstanceExtensions; ++i) {
std::cout << "\t" <<instanceExtensions[i].extensionName << std::endl;
std::cout << "\t\t" << instanceExtensions[i].specVersion << std::endl;
std::cout << std::endl;
}
std::cout << std::endl;
}
// TODO: Check instance extensions(with required instance extensions)
}
}
// Create Vulkan Instance
{
VkApplicationInfo app;
{
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app.pNext = nullptr;
app.pApplicationName = "Vulkan test 1";
app.applicationVersion = 0;
app.pEngineName = "Vulkan test 1";
app.engineVersion = 0;
app.apiVersion = VK_API_VERSION;
}
VkInstanceCreateInfo instanceInfo;
{
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceInfo.pNext = nullptr;
instanceInfo.pApplicationInfo = &app;
instanceInfo.enabledLayerCount = g_validationLayers.size();
instanceInfo.ppEnabledLayerNames = g_validationLayers.data();
instanceInfo.enabledExtensionCount = g_extensions.size();
instanceInfo.ppEnabledExtensionNames = g_extensions.data();
}
// TODO: Aligned allocators
VkAllocationCallbacks allocator;
{
allocator.pUserData = nullptr;
allocator.pfnAllocation = [](void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)->void* {
return malloc(size);
};
allocator.pfnFree = [](void* pUserData, void* pMemory) {
free(pMemory);
};
allocator.pfnReallocation = [](void* pUserData, void *pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope) {
free(pOriginal);
return malloc(size);
};
allocator.pfnInternalAllocation = nullptr;
allocator.pfnInternalFree = nullptr;
allocator.pfnReallocation = nullptr;
}
// Create vulkan instance
VkResult vkError = vkCreateInstance(&instanceInfo, &allocator, &g_vkInstance);
// Handle errors
switch (vkError) {
case VK_ERROR_INCOMPATIBLE_DRIVER:
error("Drivers do not support vulkan. Drivers could be outdated.");
break;
case VK_ERROR_EXTENSION_NOT_PRESENT:
error("Cannot find specified extension.");
break;
case VK_SUCCESS:
// Succes! (prevent default from catching success as error)
std::cout << "Vulkan instance created!" << std::endl;
break;
default:
error("Could not create vulkan Instance. Drivers could be outdated.");
break;
}
}
// Look for GPU device
{
uint32_t numGPUs;
VkResult vkError = vkEnumeratePhysicalDevices(g_vkInstance, &numGPUs, nullptr);
if (numGPUs < 0)
error("vkEnumeratePhysicalDevices could not find any GPU devices.");
if (vkError)
error("vkEnumeratePhysicalDevices could not enumerate GPU devices.");
if (numGPUs > 0) {
std::vector<VkPhysicalDevice> physicalDevices(numGPUs);
if (vkEnumeratePhysicalDevices(g_vkInstance, &numGPUs, physicalDevices.data()))
error("vkEnumeratePhysicalDevices could not enumerate GPU devices.");
g_vkGPU = physicalDevices[0];
std::cout << numGPUs << " GPUs found!" << std::endl;
}
}
// Get queue properties
{
uint32_t numQueues;
vkGetPhysicalDeviceProperties(g_vkGPU, &g_vkGPUProperties);
vkGetPhysicalDeviceQueueFamilyProperties(g_vkGPU, &numQueues, nullptr);
if (numQueues == 0)
error("vkGetPhysicalDeviceQueueFamilyProperties could not find any queues.");
g_vkQueueProperties = std::vector<VkQueueFamilyProperties>(numQueues);
vkGetPhysicalDeviceQueueFamilyProperties(g_vkGPU, &numQueues, g_vkQueueProperties.data());
}
// Look for device layers (Unecessary code that does nothing)
{
uint32_t numDeviceLayers;
if (vkEnumerateDeviceLayerProperties(g_vkGPU, &numDeviceLayers, nullptr))
error("vkEnumerateDeviceLayerProperties failed!");
if (numDeviceLayers > 0) {
std::vector<VkLayerProperties> deviceLayers(numDeviceLayers);
if (vkEnumerateDeviceLayerProperties(g_vkGPU, &numDeviceLayers, deviceLayers.data()))
error("vkEnumerateDeviceLayerProperties failed!");
// TODO: Check device layers.
}
}
// Look for device extensions (swapchain extension)
{
uint32_t numDeviceExtensions;
bool extensionSwapChainFound = false;
if (vkEnumerateDeviceExtensionProperties(g_vkGPU, nullptr, &numDeviceExtensions, nullptr))
error("vkEnumerateDeviceExtensionProperties failed!");
if (numDeviceExtensions > 0) {
std::vector<VkExtensionProperties> deviceExtensions(numDeviceExtensions);
if (vkEnumerateDeviceExtensionProperties(g_vkGPU, nullptr, &numDeviceExtensions, deviceExtensions.data()))
error("vkEnumerateDeviceExtensionProperties failed!");
// Search for swapchain extension
for (VkExtensionProperties extension : deviceExtensions) {
if (!strcmp(extension.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
extensionSwapChainFound = true;
}
// Print
std::cout << std::endl << "Extensions:" << std::endl;
for (VkExtensionProperties extension : deviceExtensions) {
std::cout << extension.extensionName << "(" << extension.specVersion << ")" << std::endl;
}
std::cout << std::endl;
}
if (!extensionSwapChainFound)
error("Failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME " extension!");
}
// TODO: Validate
// Get instance function adresses
{
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceFormatsKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfacePresentModesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceSupportKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, CreateSwapchainKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, DestroySwapchainKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetSwapchainImagesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, AcquireNextImageKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, QueuePresentKHR);
}
// Create window
{
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
g_window = glfwCreateWindow(g_width, g_height, "Vulkan test", NULL, NULL);
if (!g_window)
error("Could not create window!");
glfwSetWindowRefreshCallback(g_window, [](GLFWwindow* window) {
// TODO: draw();
});
glfwSetFramebufferSizeCallback(g_window, [](GLFWwindow* window, int width, int height) {
g_width = width;
g_height = height;
// TODO: resize();
});
}
// Init swapchain
{
glfwCreateWindowSurface(g_vkInstance, g_window, nullptr, &g_vkSurface);
std::vector<VkBool32> supportsPresent(g_vkQueueProperties.size());
for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i)
g_vkFPGetPhysicalDeviceSurfaceSupportKHR(g_vkGPU, i, g_vkSurface, &supportsPresent[i]);
uint32_t graphicsQueueNodeIndex = UINT32_MAX;
uint32_t presentQueueNodeIndex = UINT32_MAX;
for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i) {
if (graphicsQueueNodeIndex == UINT32_MAX) {
graphicsQueueNodeIndex = i;
}
if (supportsPresent[i] == VK_TRUE) {
graphicsQueueNodeIndex = i;
presentQueueNodeIndex = i;
break;
}
}
//if (presentQueueNodeIndex == UINT32_MAX) {
// for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i) {
// if (supportsPresent[i] == VK_TRUE) {
// presentQueueNodeIndex = i;
// }
// }
//}
if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX)
error("Could not find a graphics and a present queue.");
if (graphicsQueueNodeIndex != presentQueueNodeIndex)
error("Could not find a common graphics and present queue.");
g_vkGraphicsQueueNodeIndex = graphicsQueueNodeIndex;
//TODO: init device
{
float queuePriotities = 0.f;
VkDeviceQueueCreateInfo queue;
{
queue.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue.pNext = NULL;
queue.queueFamilyIndex = g_vkGraphicsQueueNodeIndex;
queue.queueCount = 1;
queue.pQueuePriorities = &queuePriotities;
}
}
//vkGetDeviceQueue(g_vkDevice, g_vkGraphicsQueueNodeIndex, 0, g_vkQueue);
}
std::cin.get();
return 0;
}
