mirror of
https://github.com/glfw/glfw.git
synced 2024-11-26 03:52:01 +00:00
Merge branch 'master' into EGL
Conflicts: CMakeLists.txt include/GL/glfw3.h readme.html src/CMakeLists.txt src/cocoa_window.m src/config.h.in src/glx_opengl.c src/internal.h src/opengl.c src/window.c tests/glfwinfo.c
This commit is contained in:
commit
e4ddcefc14
@ -218,10 +218,6 @@ if (_GLFW_X11_GLX)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
|
||||
set(_GLFW_HAS_LINUX_JOYSTICKS 1)
|
||||
endif()
|
||||
|
||||
endif()
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
@ -266,10 +262,6 @@ if (_GLFW_X11_EGL)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
|
||||
set(_GLFW_HAS_LINUX_JOYSTICKS 1)
|
||||
endif()
|
||||
|
||||
endif()
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
|
@ -577,8 +577,6 @@ int main( void )
|
||||
exit( EXIT_FAILURE );
|
||||
}
|
||||
|
||||
glfwSetWindowSizeCallback( reshape );
|
||||
|
||||
glfwWindowHint(GLFW_DEPTH_BITS, 16);
|
||||
|
||||
window = glfwCreateWindow( 400, 400, GLFW_WINDOWED, "Boing (classic Amiga demo)", NULL );
|
||||
@ -589,6 +587,8 @@ int main( void )
|
||||
exit( EXIT_FAILURE );
|
||||
}
|
||||
|
||||
glfwSetWindowSizeCallback(window, reshape);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval( 1 );
|
||||
|
||||
|
@ -338,11 +338,6 @@ int main(int argc, char *argv[])
|
||||
exit( EXIT_FAILURE );
|
||||
}
|
||||
|
||||
// Set callback functions
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetWindowSizeCallback( reshape );
|
||||
glfwSetKeyCallback( key );
|
||||
|
||||
glfwWindowHint(GLFW_DEPTH_BITS, 16);
|
||||
|
||||
window = glfwCreateWindow( 300, 300, GLFW_WINDOWED, "Gears", NULL );
|
||||
@ -353,14 +348,17 @@ int main(int argc, char *argv[])
|
||||
exit( EXIT_FAILURE );
|
||||
}
|
||||
|
||||
// Set callback functions
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
glfwSetWindowSizeCallback(window, reshape);
|
||||
glfwSetKeyCallback(window, key);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval( 1 );
|
||||
|
||||
glfwGetWindowSize(window, &width, &height);
|
||||
reshape(window, width, height);
|
||||
|
||||
glfwSetInputMode( window, GLFW_KEY_REPEAT, GL_TRUE );
|
||||
|
||||
// Parse command-line options
|
||||
init(argc, argv);
|
||||
|
||||
|
@ -595,12 +595,14 @@ int main(int argc, char** argv)
|
||||
|
||||
free(vertex_shader_src);
|
||||
free(fragment_shader_src);
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Register events callback */
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
if (GL_TRUE != init_opengl())
|
||||
@ -608,6 +610,8 @@ int main(int argc, char** argv)
|
||||
fprintf(stderr, "ERROR: unable to resolve OpenGL function pointers\n");
|
||||
free(vertex_shader_src);
|
||||
free(fragment_shader_src);
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
/* Prepare opengl resources for rendering */
|
||||
@ -619,6 +623,8 @@ int main(int argc, char** argv)
|
||||
{
|
||||
fprintf(stderr, "ERROR: during creation of the shader program\n");
|
||||
usage();
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
@ -683,6 +689,7 @@ int main(int argc, char** argv)
|
||||
}
|
||||
}
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
|
@ -450,12 +450,6 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// Set callback functions
|
||||
glfwSetWindowSizeCallback(windowSizeFun);
|
||||
glfwSetWindowRefreshCallback(windowRefreshFun);
|
||||
glfwSetCursorPosCallback(cursorPosFun);
|
||||
glfwSetMouseButtonCallback(mouseButtonFun);
|
||||
|
||||
glfwWindowHint(GLFW_DEPTH_BITS, 16);
|
||||
|
||||
// Open OpenGL window
|
||||
@ -463,9 +457,17 @@ int main(void)
|
||||
if (!window)
|
||||
{
|
||||
fprintf(stderr, "Failed to open GLFW window\n");
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// Set callback functions
|
||||
glfwSetWindowSizeCallback(window, windowSizeFun);
|
||||
glfwSetWindowRefreshCallback(window, windowRefreshFun);
|
||||
glfwSetCursorPosCallback(window, cursorPosFun);
|
||||
glfwSetMouseButtonCallback(window, mouseButtonFun);
|
||||
|
||||
// Enable vsync
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
@ -27,6 +27,8 @@ int main(void)
|
||||
if (!window)
|
||||
{
|
||||
fprintf(stderr, "Failed to open GLFW window\n");
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
|
@ -399,13 +399,6 @@ int main(int argc, char* argv[])
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetMouseButtonCallback(mouse_button_callback);
|
||||
glfwSetCursorPosCallback(cursor_position_callback);
|
||||
glfwSetScrollCallback(scroll_callback);
|
||||
|
||||
window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL);
|
||||
if (!window)
|
||||
{
|
||||
@ -413,14 +406,19 @@ int main(int argc, char* argv[])
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
glfwSetMouseButtonCallback(window, mouse_button_callback);
|
||||
glfwSetCursorPosCallback(window, cursor_position_callback);
|
||||
glfwSetScrollCallback(window, scroll_callback);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwGetWindowSize(window, &width, &height);
|
||||
window_size_callback(window, width, height);
|
||||
|
||||
glfwSetInputMode(window, GLFW_KEY_REPEAT, GL_TRUE);
|
||||
|
||||
// Initialize OpenGL
|
||||
init_opengl();
|
||||
|
||||
|
1171
include/GL/glfw3.h
1171
include/GL/glfw3.h
File diff suppressed because it is too large
Load Diff
13
readme.html
13
readme.html
@ -268,6 +268,7 @@ version of GLFW.</p>
|
||||
<h3>v3.0</h3>
|
||||
<ul>
|
||||
<li>Added <code>GLFWwindow</code> window handle type and updated window-related functions and callbacks to take a window handle</li>
|
||||
<li>Added <code>glfwDefaultWindowHints</code> function for resetting all window hints to their default values</li>
|
||||
<li>Added <code>glfwMakeContextCurrent</code> function for making the context of the specified window current</li>
|
||||
<li>Added <code>glfwGetError</code> and <code>glfwErrorString</code> error reporting functions and a number of error tokens</li>
|
||||
<li>Added <code>glfwSetErrorCallback</code> function and <code>GLFWerrorfun</code> type for receiving more specific and/or nested errors</li>
|
||||
@ -278,11 +279,10 @@ version of GLFW.</p>
|
||||
<li>Added <code>glfwSetWindowIconifyCallback</code> function and <code>GLFWwindowiconifyfun</code> type for receiving window iconification events</li>
|
||||
<li>Added <code>glfwGetClipboardString</code> and <code>glfwSetClipboardString</code> functions for interacting with the system clipboard</li>
|
||||
<li>Added <code>glfwGetCurrentContext</code> function for retrieving the window whose OpenGL context is current</li>
|
||||
<li>Added <code>glfwCopyContext</code> function for copying OpenGL state categories between contexts</li>
|
||||
<li>Added <code>GLFW_CLIENT_API</code> window hint for creating contexts for APIs other than desktop OpenGL</li>
|
||||
<li>Added <code>GLFW_OPENGL_ROBUSTNESS</code> window hint and associated strategy tokens for <code>GL_ARB_robustness</code> support</li>
|
||||
<li>Added <code>GLFW_OPENGL_REVISION</code> window parameter to make up for removal of <code>glfwGetGLVersion</code></li>
|
||||
<li>Added <code>GLFW_INCLUDE_GL3</code> macro for telling the GLFW header to include <code>gl3.h</code> header instead of <code>gl.h</code></li>
|
||||
<li>Added <code>GLFW_INCLUDE_GLCOREARB</code> macro for including <code>glcorearb.h</code> instead of <code>gl.h</code></li>
|
||||
<li>Added <code>GLFW_INCLUDE_ES2</code> macro for telling the GLFW header to include the OpenGL ES 2.0 header instead of <code>gl.h</code></li>
|
||||
<li>Added <code>GLFW_VISIBLE</code> window hint and parameter for controlling and polling window visibility</li>
|
||||
<li>Added <code>windows</code> simple multi-window test program</li>
|
||||
@ -298,6 +298,7 @@ version of GLFW.</p>
|
||||
<li>Changed <code>glfwGetVideoModes</code> to return a dynamic, unlimited number of video modes</li>
|
||||
<li>Renamed <code>glfw.h</code> to <code>glfw3.h</code> to avoid conflicts with 2.x series</li>
|
||||
<li>Renamed <code>glfwOpenWindowHint</code> to <code>glfwWindowHint</code></li>
|
||||
<li>Renamed <code>GLFW_ACTIVE</code> to <code>GLFW_FOCUSED</code></li>
|
||||
<li>Renamed <code>GLFW_WINDOW</code> token to <code>GLFW_WINDOWED</code></li>
|
||||
<li>Renamed <code>GLFW_WINDOW_NO_RESIZE</code> to <code>GLFW_RESIZABLE</code></li>
|
||||
<li>Renamed <code>GLFW_BUILD_DLL</code> to <code>_GLFW_BUILD_DLL</code></li>
|
||||
@ -312,12 +313,13 @@ version of GLFW.</p>
|
||||
<li>Replaced <code>glfwEnable</code> and <code>glfwDisable</code> with <code>glfwGetInputMode</code> and <code>glfwSetInputMode</code></li>
|
||||
<li>Replaced <code>joystick</code> test with graphical version</li>
|
||||
<li>Replaced automatic closing of windows with <code>GLFW_CLOSE_REQUESTED</code> window parameter</li>
|
||||
<li>Made Unicode character input unaffected by <code>GLFW_KEY_REPEAT</code></li>
|
||||
<li>Removed the <code>GLFW_KEY_REPEAT</code> input option</li>
|
||||
<li>Removed event auto-polling and the <code>GLFW_AUTO_POLL_EVENTS</code> window enable</li>
|
||||
<li>Removed the Win32 port .def files</li>
|
||||
<li>Removed the entire threading API</li>
|
||||
<li>Removed the entire image loading API</li>
|
||||
<li>Removed deprecated Carbon port</li>
|
||||
<li>Removed registering <code>glfwTerminate</code> with <code>atexit</code></li>
|
||||
<li>Removed <code>glfwSleep</code> function</li>
|
||||
<li>Removed <code>glfwGetNumberOfProcessors</code> function</li>
|
||||
<li>Removed <code>glfwGetGLVersion</code> function</li>
|
||||
@ -933,8 +935,9 @@ their skills. Special thanks go out to:</p>
|
||||
Leopard</li>
|
||||
|
||||
<li>Riku Salminen, for the initial implementation of
|
||||
<code>glfwShowWindow</code> and <code>glfwHideWindow</code>, and for making
|
||||
the X11 event processing able to support multi-threaded rendering</li>
|
||||
<code>glfwShowWindow</code> and <code>glfwHideWindow</code>, for the idea of
|
||||
<code>glfwDefaultWindowHints</code> and for making the X11 event processing
|
||||
able to support multi-threaded rendering</li>
|
||||
|
||||
<li>Douglas C. Schmidt and Irfan Pyarali, for their excellent article
|
||||
<a href="http://www.cs.wustl.edu/~schmidt/win32-cv-1.html">Strategies for Implementing POSIX Condition Variables on Win32</a></li>
|
||||
|
@ -2,6 +2,10 @@ include_directories(${GLFW_SOURCE_DIR}/src
|
||||
${GLFW_BINARY_DIR}/src
|
||||
${glfw_INCLUDE_DIRS})
|
||||
|
||||
if (MSVC)
|
||||
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
|
||||
endif()
|
||||
|
||||
set(common_HEADERS ${GLFW_SOURCE_DIR}/include/GL/glfw3.h internal.h)
|
||||
set(common_SOURCES clipboard.c fullscreen.c gamma.c init.c input.c
|
||||
joystick.c opengl.c time.c window.c)
|
||||
@ -9,7 +13,7 @@ set(common_SOURCES clipboard.c fullscreen.c gamma.c init.c input.c
|
||||
if (_GLFW_COCOA_NSGL)
|
||||
set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h)
|
||||
set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_fullscreen.m
|
||||
cocoa_gamma.c cocoa_init.m cocoa_input.m cocoa_joystick.m
|
||||
cocoa_gamma.c cocoa_init.m cocoa_joystick.m
|
||||
cocoa_opengl.m cocoa_time.c cocoa_window.m)
|
||||
|
||||
if (GLFW_NATIVE_API)
|
||||
@ -21,18 +25,17 @@ if (_GLFW_COCOA_NSGL)
|
||||
elseif (_GLFW_WIN32_WGL)
|
||||
set(glfw_HEADERS ${common_HEADERS} win32_platform.h)
|
||||
set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_fullscreen.c
|
||||
win32_gamma.c win32_init.c win32_input.c win32_joystick.c
|
||||
win32_gamma.c win32_init.c win32_joystick.c
|
||||
win32_opengl.c win32_time.c win32_window.c)
|
||||
|
||||
if (GLFW_NATIVE_API)
|
||||
list(APPEND glfw_SOURCES win32_native.c)
|
||||
endif()
|
||||
elseif (_GLFW_X11_GLX)
|
||||
set(glfw_HEADERS ${common_HEADERS} x11_platform.h glx_platform.h)
|
||||
set(glfw_HEADERS ${common_HEADERS} x11_platform.h)
|
||||
set(glfw_SOURCES ${common_SOURCES} glx_opengl.c x11_clipboard.c
|
||||
x11_fullscreen.c x11_gamma.c x11_init.c x11_input.c
|
||||
x11_joystick.c x11_keysym2unicode.c x11_time.c
|
||||
x11_window.c)
|
||||
x11_fullscreen.c x11_gamma.c x11_init.c x11_joystick.c
|
||||
x11_keysym2unicode.c x11_time.c x11_window.c)
|
||||
|
||||
if (GLFW_NATIVE_API)
|
||||
list(APPEND glfw_SOURCES x11_native.c)
|
||||
@ -40,7 +43,7 @@ elseif (_GLFW_X11_GLX)
|
||||
elseif (_GLFW_X11_EGL)
|
||||
set(glfw_HEADERS ${common_HEADERS} x11_platform.h egl_platform.h)
|
||||
set(glfw_SOURCES ${common_SOURCES} egl_opengl.c x11_clipboard.c
|
||||
x11_fullscreen.c x11_gamma.c x11_init.c x11_input.c
|
||||
x11_fullscreen.c x11_gamma.c x11_init.c
|
||||
x11_joystick.c x11_keysym2unicode.c x11_time.c
|
||||
x11_window.c)
|
||||
endif()
|
||||
|
@ -1,53 +0,0 @@
|
||||
//========================================================================
|
||||
// GLFW - An OpenGL library
|
||||
// Platform: Cocoa
|
||||
// API Version: 3.0
|
||||
// WWW: http://www.glfw.org/
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
|
||||
//
|
||||
// This software is provided 'as-is', without any express or implied
|
||||
// warranty. In no event will the authors be held liable for any damages
|
||||
// arising from the use of this software.
|
||||
//
|
||||
// Permission is granted to anyone to use this software for any purpose,
|
||||
// including commercial applications, and to alter it and redistribute it
|
||||
// freely, subject to the following restrictions:
|
||||
//
|
||||
// 1. The origin of this software must not be misrepresented; you must not
|
||||
// claim that you wrote the original software. If you use this software
|
||||
// in a product, an acknowledgment in the product documentation would
|
||||
// be appreciated but is not required.
|
||||
//
|
||||
// 2. Altered source versions must be plainly marked as such, and must not
|
||||
// be misrepresented as being the original software.
|
||||
//
|
||||
// 3. This notice may not be removed or altered from any source
|
||||
// distribution.
|
||||
//
|
||||
//========================================================================
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW platform API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//========================================================================
|
||||
// Enable and disable system keys
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
|
||||
{
|
||||
// This is checked in cocoa_window.m; no action needed here
|
||||
}
|
||||
|
||||
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
|
||||
{
|
||||
// This is checked in cocoa_window.m; no action needed here
|
||||
|
||||
// Note that it may not be possible to disable things like Exposé
|
||||
// except in full-screen mode.
|
||||
}
|
||||
|
@ -147,13 +147,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
|
||||
return symbol;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Copies the specified OpenGL state categories from src to dst
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask)
|
||||
{
|
||||
[dst->NSGL.context copyAttributesFromContext:src->NSGL.context withMask:mask];
|
||||
}
|
||||
|
||||
|
@ -455,8 +455,7 @@ static int convertMacKeyCode(unsigned int macKeyCode)
|
||||
|
||||
if ([event modifierFlags] & NSCommandKeyMask)
|
||||
{
|
||||
if (window->systemKeys)
|
||||
[super keyDown:event];
|
||||
[super keyDown:event];
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -654,9 +653,9 @@ static GLboolean initializeAppKit(void)
|
||||
// Implicitly create shared NSApplication instance
|
||||
[GLFWApplication sharedApplication];
|
||||
|
||||
// Setting up the menu bar must go between sharedApplication
|
||||
// above and finishLaunching below, in order to properly emulate the
|
||||
// behavior of NSApplicationMain
|
||||
// Menu bar setup must go between sharedApplication above and
|
||||
// finishLaunching below, in order to properly emulate the behavior
|
||||
// of NSApplicationMain
|
||||
createMenuBar();
|
||||
|
||||
[NSApp finishLaunching];
|
||||
@ -686,7 +685,7 @@ static GLboolean createWindow(_GLFWwindow* window,
|
||||
styleMask = NSBorderlessWindowMask;
|
||||
|
||||
window->NS.object = [[NSWindow alloc]
|
||||
initWithContentRect:NSMakeRect(0, 0, window->width, window->height)
|
||||
initWithContentRect:NSMakeRect(wndconfig->positionX, wndconfig->positionY, window->width, window->height)
|
||||
styleMask:styleMask
|
||||
backing:NSBackingStoreBuffered
|
||||
defer:NO];
|
||||
@ -729,7 +728,7 @@ static GLboolean createContext(_GLFWwindow* window,
|
||||
else if (colorBits < 15)
|
||||
colorBits = 15;
|
||||
|
||||
if (wndconfig->clientAPI != GLFW_OPENGL_ES_API)
|
||||
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
|
||||
{
|
||||
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
|
||||
"Cocoa/NSOpenGL: NSOpenGL does not support OpenGL ES");
|
||||
@ -969,7 +968,6 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
|
||||
[window->NSGL.pixelFormat release];
|
||||
window->NSGL.pixelFormat = nil;
|
||||
|
||||
[NSOpenGLContext clearCurrentContext];
|
||||
[window->NSGL.context release];
|
||||
window->NSGL.context = nil;
|
||||
|
||||
@ -1007,27 +1005,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set the window position
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
|
||||
{
|
||||
NSRect contentRect =
|
||||
[window->NS.object contentRectForFrameRect:[window->NS.object frame]];
|
||||
|
||||
// We assume here that the client code wants to position the window within the
|
||||
// screen the window currently occupies
|
||||
NSRect screenRect = [[window->NS.object screen] visibleFrame];
|
||||
contentRect.origin = NSMakePoint(screenRect.origin.x + x,
|
||||
screenRect.origin.y + screenRect.size.height -
|
||||
y - contentRect.size.height);
|
||||
|
||||
[window->NS.object setFrame:[window->NS.object frameRectForContentRect:contentRect]
|
||||
display:YES];
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Iconify the window
|
||||
//========================================================================
|
||||
|
@ -66,10 +66,7 @@
|
||||
#cmakedefine _GLFW_HAS_GLXGETPROCADDRESSEXT
|
||||
|
||||
// Define this to 1 if eglGetProcAddress is available
|
||||
#cmakedefine _GLFW_HAS_EGLGETPROCADDRESS 1
|
||||
|
||||
// Define this to 1 if the Linux joystick API is available
|
||||
#cmakedefine _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#cmakedefine _GLFW_HAS_EGLGETPROCADDRESS
|
||||
|
||||
// The GLFW version as used by glfwGetVersionString
|
||||
#define _GLFW_VERSION_FULL "@GLFW_VERSION_FULL@"
|
||||
|
@ -92,7 +92,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window,
|
||||
{
|
||||
free(configs);
|
||||
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"EGL: No EGLConfigs returned");
|
||||
return NULL;
|
||||
}
|
||||
@ -388,7 +388,7 @@ int _glfwInitOpenGL(void)
|
||||
_glfwLibrary.EGL.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
|
||||
if (_glfwLibrary.EGL.display == EGL_NO_DISPLAY)
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"EGL: Failed to get EGL display");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -397,7 +397,7 @@ int _glfwInitOpenGL(void)
|
||||
&_glfwLibrary.EGL.majorVersion,
|
||||
&_glfwLibrary.EGL.minorVersion))
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"EGL: Failed to initialize EGL");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
@ -67,8 +67,12 @@ GLFWAPI void glfwSetGamma(float gamma)
|
||||
value = (float) i / (float) (size - 1);
|
||||
// Apply gamma curve
|
||||
value = (float) pow(value, 1.f / gamma) * 65535.f + 0.5f;
|
||||
|
||||
// Clamp to value range
|
||||
value = (float) fmax(fmin(value, 65535.f), 0.f);
|
||||
if (value < 0.f)
|
||||
value = 0.f;
|
||||
else if (value > 65535.f)
|
||||
value = 65535.f;
|
||||
|
||||
ramp.red[i] = (unsigned short) value;
|
||||
ramp.green[i] = (unsigned short) value;
|
||||
|
@ -93,7 +93,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
|
||||
{
|
||||
if (!_glfwLibrary.GLX.SGIX_fbconfig)
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"GLX: GLXFBConfig support not found");
|
||||
return NULL;
|
||||
}
|
||||
@ -103,8 +103,8 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
|
||||
|
||||
if (strcmp(vendor, "Chromium") == 0)
|
||||
{
|
||||
// This is a (hopefully temporary) workaround for Chromium (VirtualBox
|
||||
// GL) not setting the window bit on any GLXFBConfigs
|
||||
// HACK: This is a (hopefully temporary) workaround for Chromium
|
||||
// (VirtualBox GL) not setting the window bit on any GLXFBConfigs
|
||||
trustWindowBit = GL_FALSE;
|
||||
}
|
||||
|
||||
@ -116,7 +116,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
|
||||
&count);
|
||||
if (!count)
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"GLX: No GLXFBConfigs returned");
|
||||
return NULL;
|
||||
}
|
||||
@ -128,7 +128,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
|
||||
&count);
|
||||
if (!count)
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"GLX: No GLXFBConfigs returned");
|
||||
return NULL;
|
||||
}
|
||||
@ -301,7 +301,7 @@ static int createContext(_GLFWwindow* window,
|
||||
!_glfwLibrary.GLX.EXT_create_context_es2_profile)
|
||||
{
|
||||
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
|
||||
"X11/GLX: OpenGL ES 2.x requested but "
|
||||
"GLX: OpenGL ES 2.x requested but "
|
||||
"GLX_EXT_create_context_es2_profile is unavailable");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -465,7 +465,7 @@ int _glfwInitOpenGL(void)
|
||||
// Check if GLX is supported on this display
|
||||
if (!glXQueryExtension(_glfwLibrary.X11.display, NULL, NULL))
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE, "GLX: GLX support not found");
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE, "GLX: GLX support not found");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
@ -473,8 +473,7 @@ int _glfwInitOpenGL(void)
|
||||
&_glfwLibrary.GLX.majorVersion,
|
||||
&_glfwLibrary.GLX.minorVersion))
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
|
||||
"GLX: Failed to query GLX version");
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE, "GLX: Failed to query GLX version");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
@ -619,8 +618,6 @@ void _glfwDestroyContext(_GLFWwindow* window)
|
||||
|
||||
if (window->GLX.context)
|
||||
{
|
||||
// Release and destroy the context
|
||||
glXMakeCurrent(_glfwLibrary.X11.display, None, NULL);
|
||||
glXDestroyContext(_glfwLibrary.X11.display, window->GLX.context);
|
||||
window->GLX.context = NULL;
|
||||
}
|
||||
@ -724,16 +721,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
|
||||
return _glfw_glXGetProcAddress((const GLubyte*) procname);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Copies the specified OpenGL state categories from src to dst
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask)
|
||||
{
|
||||
glXCopyContext(_glfwLibrary.X11.display,
|
||||
src->GLX.context,
|
||||
dst->GLX.context,
|
||||
mask);
|
||||
}
|
||||
|
||||
|
18
src/init.c
18
src/init.c
@ -121,19 +121,17 @@ GLFWAPI int glfwInit(void)
|
||||
|
||||
memset(&_glfwLibrary, 0, sizeof(_glfwLibrary));
|
||||
|
||||
// Not all window hints have zero as their default value
|
||||
_glfwSetDefaultWindowHints();
|
||||
|
||||
if (!_glfwPlatformInit())
|
||||
{
|
||||
_glfwPlatformTerminate();
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
atexit(glfwTerminate);
|
||||
|
||||
_glfwInitialized = GL_TRUE;
|
||||
|
||||
// Not all window hints have zero as their default value
|
||||
glfwDefaultWindowHints();
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
@ -217,21 +215,19 @@ GLFWAPI const char* glfwErrorString(int error)
|
||||
case GLFW_NOT_INITIALIZED:
|
||||
return "The GLFW library is not initialized";
|
||||
case GLFW_NO_CURRENT_CONTEXT:
|
||||
return "There is no current OpenGL context";
|
||||
return "There is no current context";
|
||||
case GLFW_INVALID_ENUM:
|
||||
return "Invalid argument for enum parameter";
|
||||
case GLFW_INVALID_VALUE:
|
||||
return "Invalid value for parameter";
|
||||
case GLFW_OUT_OF_MEMORY:
|
||||
return "Out of memory";
|
||||
case GLFW_OPENGL_UNAVAILABLE:
|
||||
return "OpenGL is not available on this machine";
|
||||
case GLFW_API_UNAVAILABLE:
|
||||
return "The requested client API is unavailable";
|
||||
case GLFW_VERSION_UNAVAILABLE:
|
||||
return "The requested OpenGL version is unavailable";
|
||||
return "The requested client API version is unavailable";
|
||||
case GLFW_PLATFORM_ERROR:
|
||||
return "A platform-specific error occurred";
|
||||
case GLFW_WINDOW_NOT_ACTIVE:
|
||||
return "The specified window is not active";
|
||||
case GLFW_FORMAT_UNAVAILABLE:
|
||||
return "The requested format is unavailable";
|
||||
}
|
||||
|
107
src/input.c
107
src/input.c
@ -115,34 +115,6 @@ static void setStickyMouseButtons(_GLFWwindow* window, int enabled)
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set system keys for the specified window
|
||||
//========================================================================
|
||||
|
||||
static void setSystemKeys(_GLFWwindow* window, int enabled)
|
||||
{
|
||||
if (window->systemKeys == enabled)
|
||||
return;
|
||||
|
||||
if (enabled)
|
||||
_glfwPlatformEnableSystemKeys(window);
|
||||
else
|
||||
_glfwPlatformDisableSystemKeys(window);
|
||||
|
||||
window->systemKeys = enabled;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set key repeat for the specified window
|
||||
//========================================================================
|
||||
|
||||
static void setKeyRepeat(_GLFWwindow* window, int enabled)
|
||||
{
|
||||
window->keyRepeat = enabled;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW internal API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
@ -172,8 +144,8 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
|
||||
}
|
||||
|
||||
// Call user callback function
|
||||
if (_glfwLibrary.keyCallback && (window->keyRepeat || !repeated))
|
||||
_glfwLibrary.keyCallback(window, key, action);
|
||||
if (window->keyCallback && !repeated)
|
||||
window->keyCallback(window, key, action);
|
||||
}
|
||||
|
||||
|
||||
@ -187,8 +159,8 @@ void _glfwInputChar(_GLFWwindow* window, int character)
|
||||
if (!((character >= 32 && character <= 126) || character >= 160))
|
||||
return;
|
||||
|
||||
if (_glfwLibrary.charCallback)
|
||||
_glfwLibrary.charCallback(window, character);
|
||||
if (window->charCallback)
|
||||
window->charCallback(window, character);
|
||||
}
|
||||
|
||||
|
||||
@ -201,8 +173,8 @@ void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
|
||||
window->scrollX += xoffset;
|
||||
window->scrollY += yoffset;
|
||||
|
||||
if (_glfwLibrary.scrollCallback)
|
||||
_glfwLibrary.scrollCallback(window, xoffset, yoffset);
|
||||
if (window->scrollCallback)
|
||||
window->scrollCallback(window, xoffset, yoffset);
|
||||
}
|
||||
|
||||
|
||||
@ -221,8 +193,8 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
|
||||
else
|
||||
window->mouseButton[button] = (char) action;
|
||||
|
||||
if (_glfwLibrary.mouseButtonCallback)
|
||||
_glfwLibrary.mouseButtonCallback(window, button, action);
|
||||
if (window->mouseButtonCallback)
|
||||
window->mouseButtonCallback(window, button, action);
|
||||
}
|
||||
|
||||
|
||||
@ -249,11 +221,11 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
|
||||
window->cursorPosY = y;
|
||||
}
|
||||
|
||||
if (_glfwLibrary.cursorPosCallback)
|
||||
if (window->cursorPosCallback)
|
||||
{
|
||||
_glfwLibrary.cursorPosCallback(window,
|
||||
window->cursorPosX,
|
||||
window->cursorPosY);
|
||||
window->cursorPosCallback(window,
|
||||
window->cursorPosX,
|
||||
window->cursorPosY);
|
||||
}
|
||||
}
|
||||
|
||||
@ -264,8 +236,8 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
|
||||
|
||||
void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
|
||||
{
|
||||
if (_glfwLibrary.cursorEnterCallback)
|
||||
_glfwLibrary.cursorEnterCallback(window, entered);
|
||||
if (window->cursorEnterCallback)
|
||||
window->cursorEnterCallback(window, entered);
|
||||
}
|
||||
|
||||
|
||||
@ -295,10 +267,6 @@ GLFWAPI int glfwGetInputMode(GLFWwindow handle, int mode)
|
||||
return window->stickyKeys;
|
||||
case GLFW_STICKY_MOUSE_BUTTONS:
|
||||
return window->stickyMouseButtons;
|
||||
case GLFW_SYSTEM_KEYS:
|
||||
return window->systemKeys;
|
||||
case GLFW_KEY_REPEAT:
|
||||
return window->keyRepeat;
|
||||
default:
|
||||
_glfwSetError(GLFW_INVALID_ENUM, NULL);
|
||||
return 0;
|
||||
@ -331,12 +299,6 @@ GLFWAPI void glfwSetInputMode(GLFWwindow handle, int mode, int value)
|
||||
case GLFW_STICKY_MOUSE_BUTTONS:
|
||||
setStickyMouseButtons(window, value ? GL_TRUE : GL_FALSE);
|
||||
break;
|
||||
case GLFW_SYSTEM_KEYS:
|
||||
setSystemKeys(window, value ? GL_TRUE : GL_FALSE);
|
||||
break;
|
||||
case GLFW_KEY_REPEAT:
|
||||
setKeyRepeat(window, value ? GL_TRUE : GL_FALSE);
|
||||
break;
|
||||
default:
|
||||
_glfwSetError(GLFW_INVALID_ENUM, NULL);
|
||||
break;
|
||||
@ -445,11 +407,8 @@ GLFWAPI void glfwSetCursorPos(GLFWwindow handle, int xpos, int ypos)
|
||||
return;
|
||||
}
|
||||
|
||||
if (_glfwLibrary.activeWindow != window)
|
||||
{
|
||||
_glfwSetError(GLFW_WINDOW_NOT_ACTIVE, NULL);
|
||||
if (_glfwLibrary.focusedWindow != window)
|
||||
return;
|
||||
}
|
||||
|
||||
// Don't do anything if the cursor position did not change
|
||||
if (xpos == window->cursorPosX && ypos == window->cursorPosY)
|
||||
@ -494,15 +453,17 @@ GLFWAPI void glfwGetScrollOffset(GLFWwindow handle, double* xoffset, double* yof
|
||||
// Set callback function for keyboard input
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
|
||||
GLFWAPI void glfwSetKeyCallback(GLFWwindow handle, GLFWkeyfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.keyCallback = cbfun;
|
||||
window->keyCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -510,15 +471,17 @@ GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
|
||||
// Set callback function for character input
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
|
||||
GLFWAPI void glfwSetCharCallback(GLFWwindow handle, GLFWcharfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.charCallback = cbfun;
|
||||
window->charCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -526,15 +489,17 @@ GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
|
||||
// Set callback function for mouse clicks
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
|
||||
GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow handle, GLFWmousebuttonfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.mouseButtonCallback = cbfun;
|
||||
window->mouseButtonCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -542,15 +507,17 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
|
||||
// Set callback function for mouse moves
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun)
|
||||
GLFWAPI void glfwSetCursorPosCallback(GLFWwindow handle, GLFWcursorposfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.cursorPosCallback = cbfun;
|
||||
window->cursorPosCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -558,15 +525,17 @@ GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun)
|
||||
// Set callback function for cursor enter/leave events
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetCursorEnterCallback(GLFWcursorenterfun cbfun)
|
||||
GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow handle, GLFWcursorenterfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.cursorEnterCallback = cbfun;
|
||||
window->cursorEnterCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -574,14 +543,16 @@ GLFWAPI void glfwSetCursorEnterCallback(GLFWcursorenterfun cbfun)
|
||||
// Set callback function for scroll events
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun)
|
||||
GLFWAPI void glfwSetScrollCallback(GLFWwindow handle, GLFWscrollfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.scrollCallback = cbfun;
|
||||
window->scrollCallback = cbfun;
|
||||
}
|
||||
|
||||
|
@ -107,6 +107,8 @@ struct _GLFWhints
|
||||
GLboolean glDebug;
|
||||
int glProfile;
|
||||
int glRobustness;
|
||||
int positionX;
|
||||
int positionY;
|
||||
};
|
||||
|
||||
|
||||
@ -123,6 +125,8 @@ struct _GLFWwndconfig
|
||||
int refreshRate;
|
||||
GLboolean resizable;
|
||||
GLboolean visible;
|
||||
int positionX;
|
||||
int positionY;
|
||||
int clientAPI;
|
||||
int glMajor;
|
||||
int glMinor;
|
||||
@ -172,7 +176,7 @@ struct _GLFWwindow
|
||||
GLboolean closeRequested; // GL_TRUE if this window should be closed
|
||||
int width, height;
|
||||
int positionX, positionY;
|
||||
int mode; // GLFW_WINDOW or GLFW_FULLSCREEN
|
||||
int mode; // GLFW_WINDOWED or GLFW_FULLSCREEN
|
||||
GLboolean resizable; // GL_TRUE if user may resize this window
|
||||
GLboolean visible; // GL_TRUE if this window is visible
|
||||
int refreshRate; // monitor refresh rate
|
||||
@ -181,8 +185,6 @@ struct _GLFWwindow
|
||||
// Window input state
|
||||
GLboolean stickyKeys;
|
||||
GLboolean stickyMouseButtons;
|
||||
GLboolean keyRepeat;
|
||||
GLboolean systemKeys; // system keys enabled flag
|
||||
int cursorPosX, cursorPosY;
|
||||
int cursorMode;
|
||||
double scrollX, scrollY;
|
||||
@ -197,6 +199,18 @@ struct _GLFWwindow
|
||||
int glRobustness;
|
||||
PFNGLGETSTRINGIPROC GetStringi;
|
||||
|
||||
GLFWwindowsizefun windowSizeCallback;
|
||||
GLFWwindowclosefun windowCloseCallback;
|
||||
GLFWwindowrefreshfun windowRefreshCallback;
|
||||
GLFWwindowfocusfun windowFocusCallback;
|
||||
GLFWwindowiconifyfun windowIconifyCallback;
|
||||
GLFWmousebuttonfun mouseButtonCallback;
|
||||
GLFWcursorposfun cursorPosCallback;
|
||||
GLFWcursorenterfun cursorEnterCallback;
|
||||
GLFWscrollfun scrollCallback;
|
||||
GLFWkeyfun keyCallback;
|
||||
GLFWcharfun charCallback;
|
||||
|
||||
// These are defined in the current port's platform.h
|
||||
_GLFW_PLATFORM_WINDOW_STATE;
|
||||
_GLFW_PLATFORM_CONTEXT_STATE;
|
||||
@ -211,19 +225,7 @@ struct _GLFWlibrary
|
||||
_GLFWhints hints;
|
||||
|
||||
_GLFWwindow* windowListHead;
|
||||
_GLFWwindow* activeWindow;
|
||||
|
||||
GLFWwindowsizefun windowSizeCallback;
|
||||
GLFWwindowclosefun windowCloseCallback;
|
||||
GLFWwindowrefreshfun windowRefreshCallback;
|
||||
GLFWwindowfocusfun windowFocusCallback;
|
||||
GLFWwindowiconifyfun windowIconifyCallback;
|
||||
GLFWmousebuttonfun mouseButtonCallback;
|
||||
GLFWcursorposfun cursorPosCallback;
|
||||
GLFWcursorenterfun cursorEnterCallback;
|
||||
GLFWscrollfun scrollCallback;
|
||||
GLFWkeyfun keyCallback;
|
||||
GLFWcharfun charCallback;
|
||||
_GLFWwindow* focusedWindow;
|
||||
|
||||
GLFWgammaramp currentRamp;
|
||||
GLFWgammaramp originalRamp;
|
||||
@ -290,7 +292,6 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window, const _GLFWwndconfig* wndcon
|
||||
void _glfwPlatformDestroyWindow(_GLFWwindow* window);
|
||||
void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
|
||||
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);
|
||||
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y);
|
||||
void _glfwPlatformIconifyWindow(_GLFWwindow* window);
|
||||
void _glfwPlatformRestoreWindow(_GLFWwindow* window);
|
||||
void _glfwPlatformShowWindow(_GLFWwindow* window);
|
||||
@ -308,7 +309,6 @@ void _glfwPlatformSwapInterval(int interval);
|
||||
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window);
|
||||
int _glfwPlatformExtensionSupported(const char* extension);
|
||||
GLFWglproc _glfwPlatformGetProcAddress(const char* procname);
|
||||
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask);
|
||||
|
||||
|
||||
//========================================================================
|
||||
@ -319,7 +319,7 @@ void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long
|
||||
//========================================================================
|
||||
|
||||
// Window event notification (window.c)
|
||||
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated);
|
||||
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused);
|
||||
void _glfwInputWindowPos(_GLFWwindow* window, int x, int y);
|
||||
void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
|
||||
void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);
|
||||
@ -350,9 +350,6 @@ void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
|
||||
// Error handling (init.c)
|
||||
void _glfwSetError(int error, const char* format, ...);
|
||||
|
||||
// Window management (window.c)
|
||||
void _glfwSetDefaultWindowHints(void);
|
||||
|
||||
// OpenGL context helpers (opengl.c)
|
||||
int _glfwStringInExtensionString(const char* string, const GLubyte* extensions);
|
||||
const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
|
||||
|
55
src/opengl.c
55
src/opengl.c
@ -258,7 +258,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
wndconfig->clientAPI != GLFW_OPENGL_ES_API)
|
||||
{
|
||||
_glfwSetError(GLFW_INVALID_ENUM,
|
||||
"glfwOpenWindow: Invalid client API requested");
|
||||
"glfwCreateWindow: Invalid client API requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
@ -268,28 +268,28 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
{
|
||||
// OpenGL 1.0 is the smallest valid version
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL version requested");
|
||||
"glfwCreateWindow: Invalid OpenGL version requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
if (wndconfig->glMajor == 1 && wndconfig->glMinor > 5)
|
||||
{
|
||||
// OpenGL 1.x series ended with version 1.5
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL version requested");
|
||||
"glfwCreateWindow: Invalid OpenGL version requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
else if (wndconfig->glMajor == 2 && wndconfig->glMinor > 1)
|
||||
{
|
||||
// OpenGL 2.x series ended with version 2.1
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL version requested");
|
||||
"glfwCreateWindow: Invalid OpenGL version requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
else if (wndconfig->glMajor == 3 && wndconfig->glMinor > 3)
|
||||
{
|
||||
// OpenGL 3.x series ended with version 3.3
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL version requested");
|
||||
"glfwCreateWindow: Invalid OpenGL version requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
else
|
||||
@ -303,7 +303,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
wndconfig->glProfile != GLFW_OPENGL_COMPAT_PROFILE)
|
||||
{
|
||||
_glfwSetError(GLFW_INVALID_ENUM,
|
||||
"glfwOpenWindow: Invalid OpenGL profile requested");
|
||||
"glfwCreateWindow: Invalid OpenGL profile requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
@ -314,7 +314,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
// and above
|
||||
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Context profiles only exist for "
|
||||
"glfwCreateWindow: Context profiles only exist for "
|
||||
"OpenGL version 3.2 and above");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -324,7 +324,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
{
|
||||
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Forward compatibility only exist "
|
||||
"glfwCreateWindow: Forward compatibility only exist "
|
||||
"for OpenGL version 3.0 and above");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -335,14 +335,14 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
{
|
||||
// OpenGL ES 1.0 is the smallest valid version
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL ES version requested");
|
||||
"glfwCreateWindow: Invalid OpenGL ES version requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
if (wndconfig->glMajor == 1 && wndconfig->glMinor > 1)
|
||||
{
|
||||
// OpenGL ES 1.x series ended with version 1.1
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL ES version requested");
|
||||
"glfwCreateWindow: Invalid OpenGL ES version requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
else
|
||||
@ -354,7 +354,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
{
|
||||
// OpenGL ES does not support profiles
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Context profiles are not supported "
|
||||
"glfwCreateWindow: Context profiles are not supported "
|
||||
"by OpenGL ES");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -363,7 +363,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
{
|
||||
// OpenGL ES does not support forward-compatibility
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Forward compatibility is not "
|
||||
"glfwCreateWindow: Forward compatibility is not "
|
||||
"supported by OpenGL ES");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -375,7 +375,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
|
||||
wndconfig->glRobustness != GLFW_OPENGL_LOSE_CONTEXT_ON_RESET)
|
||||
{
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwOpenWindow: Invalid OpenGL robustness mode "
|
||||
"glfwCreateWindow: Invalid OpenGL robustness mode "
|
||||
"requested");
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -683,32 +683,3 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
|
||||
return _glfwPlatformGetProcAddress(procname);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Copies the specified context state categories from src to dst
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwCopyContext(GLFWwindow hsrc, GLFWwindow hdst, unsigned long mask)
|
||||
{
|
||||
_GLFWwindow* src;
|
||||
_GLFWwindow* dst;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
src = (_GLFWwindow*) hsrc;
|
||||
dst = (_GLFWwindow*) hdst;
|
||||
|
||||
if (_glfwPlatformGetCurrentContext() == dst)
|
||||
{
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwCopyContext: Cannot copy OpenGL state to a current context");
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwPlatformCopyContext(src, dst, mask);
|
||||
}
|
||||
|
||||
|
@ -43,7 +43,7 @@ static GLboolean getClosestVideoMode(int* width, int* height,
|
||||
int* bpp, int* refreshRate,
|
||||
GLboolean exactBPP)
|
||||
{
|
||||
int mode, bestWidth, bestHeight, bestBPP, bestRate;
|
||||
int mode, bestWidth = 0, bestHeight = 0, bestBPP = 0, bestRate = 0;
|
||||
unsigned int sizeDiff, rateDiff, leastSizeDiff, leastRateDiff;
|
||||
GLboolean foundMode = GL_FALSE;
|
||||
DEVMODE dm;
|
||||
@ -130,7 +130,7 @@ void _glfwSetVideoMode(int* width, int* height,
|
||||
closestRate = *refreshRate;
|
||||
|
||||
if (getClosestVideoMode(&closestWidth, &closestHeight,
|
||||
&closestBPP, &closestRate, GL_FALSE))
|
||||
&closestBPP, &closestRate, exactBPP))
|
||||
{
|
||||
dm.dmSize = sizeof(DEVMODE);
|
||||
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
|
||||
|
@ -1,128 +0,0 @@
|
||||
//========================================================================
|
||||
// GLFW - An OpenGL library
|
||||
// Platform: Win32
|
||||
// API version: 3.0
|
||||
// WWW: http://www.glfw.org/
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2002-2006 Marcus Geelnard
|
||||
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
|
||||
//
|
||||
// This software is provided 'as-is', without any express or implied
|
||||
// warranty. In no event will the authors be held liable for any damages
|
||||
// arising from the use of this software.
|
||||
//
|
||||
// Permission is granted to anyone to use this software for any purpose,
|
||||
// including commercial applications, and to alter it and redistribute it
|
||||
// freely, subject to the following restrictions:
|
||||
//
|
||||
// 1. The origin of this software must not be misrepresented; you must not
|
||||
// claim that you wrote the original software. If you use this software
|
||||
// in a product, an acknowledgment in the product documentation would
|
||||
// be appreciated but is not required.
|
||||
//
|
||||
// 2. Altered source versions must be plainly marked as such, and must not
|
||||
// be misrepresented as being the original software.
|
||||
//
|
||||
// 3. This notice may not be removed or altered from any source
|
||||
// distribution.
|
||||
//
|
||||
//========================================================================
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Low level keyboard hook (system callback) function
|
||||
// Used to disable system keys under Windows NT
|
||||
//========================================================================
|
||||
|
||||
static LRESULT CALLBACK keyboardHook(int nCode, WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
BOOL syskeys = FALSE;
|
||||
PKBDLLHOOKSTRUCT p;
|
||||
|
||||
// We are only looking for keyboard events - interpret lParam as a
|
||||
// pointer to a KBDLLHOOKSTRUCT
|
||||
p = (PKBDLLHOOKSTRUCT) lParam;
|
||||
|
||||
if (nCode == HC_ACTION)
|
||||
{
|
||||
// We have a keyboard event
|
||||
|
||||
switch (wParam)
|
||||
{
|
||||
case WM_KEYDOWN:
|
||||
case WM_SYSKEYDOWN:
|
||||
case WM_KEYUP:
|
||||
case WM_SYSKEYUP:
|
||||
// Detect: ALT+TAB, ALT+ESC, ALT+F4, CTRL+ESC,
|
||||
// LWIN, RWIN, APPS (mysterious menu key)
|
||||
syskeys = (p->vkCode == VK_TAB &&
|
||||
p->flags & LLKHF_ALTDOWN) ||
|
||||
(p->vkCode == VK_ESCAPE &&
|
||||
p->flags & LLKHF_ALTDOWN) ||
|
||||
(p->vkCode == VK_F4 &&
|
||||
p->flags & LLKHF_ALTDOWN) ||
|
||||
(p->vkCode == VK_ESCAPE &&
|
||||
(GetKeyState(VK_CONTROL) & 0x8000)) ||
|
||||
p->vkCode == VK_LWIN ||
|
||||
p->vkCode == VK_RWIN ||
|
||||
p->vkCode == VK_APPS;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Was it a system key combination (e.g. ALT+TAB)?
|
||||
if (syskeys)
|
||||
{
|
||||
_GLFWwindow* window = _glfwLibrary.activeWindow;
|
||||
|
||||
// Pass the key event to our window message loop
|
||||
if (window)
|
||||
PostMessage(window->Win32.handle, (UINT) wParam, p->vkCode, 0);
|
||||
|
||||
// We've taken care of it - don't let the system know about this
|
||||
// key event
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// It's a harmless key press, let the system deal with it
|
||||
return CallNextHookEx(_glfwLibrary.Win32.keyboardHook, nCode, wParam, lParam);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW platform API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//========================================================================
|
||||
// Enable system keys
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
|
||||
{
|
||||
if (_glfwLibrary.Win32.keyboardHook != NULL)
|
||||
{
|
||||
UnhookWindowsHookEx(_glfwLibrary.Win32.keyboardHook);
|
||||
_glfwLibrary.Win32.keyboardHook = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Disable system keys
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
|
||||
{
|
||||
_glfwLibrary.Win32.keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL,
|
||||
keyboardHook,
|
||||
_glfwLibrary.Win32.instance,
|
||||
0);
|
||||
}
|
||||
|
@ -189,7 +189,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
|
||||
|
||||
if (!available)
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE, "WGL: No pixel formats found");
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE, "WGL: No pixel formats found");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -411,7 +411,7 @@ static GLboolean createContext(_GLFWwindow* window,
|
||||
|
||||
if (wndconfig->glRobustness)
|
||||
{
|
||||
int strategy;
|
||||
int strategy = 0;
|
||||
|
||||
if (!window->WGL.ARB_create_context_robustness)
|
||||
{
|
||||
@ -528,11 +528,6 @@ int _glfwCreateContext(_GLFWwindow* window,
|
||||
|
||||
void _glfwDestroyContext(_GLFWwindow* window)
|
||||
{
|
||||
// This is duplicated from glfwDestroyWindow
|
||||
// TODO: Stop duplicating code
|
||||
if (window == _glfwCurrentWindow)
|
||||
_glfwPlatformMakeContextCurrent(NULL);
|
||||
|
||||
if (window->WGL.context)
|
||||
{
|
||||
wglDeleteContext(window->WGL.context);
|
||||
@ -642,17 +637,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
|
||||
return (GLFWglproc) wglGetProcAddress(procname);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Copies the specified OpenGL state categories from src to dst
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask)
|
||||
{
|
||||
if (!wglCopyContext(src->WGL.context, dst->WGL.context, mask))
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"WGL: Failed to copy OpenGL context attributes");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -176,7 +176,6 @@ typedef struct _GLFWlibraryWin32
|
||||
{
|
||||
HINSTANCE instance; // Instance of the application
|
||||
ATOM classAtom; // Window class atom
|
||||
HHOOK keyboardHook; // Keyboard hook handle
|
||||
DWORD foregroundLockTimeout;
|
||||
char* clipboardString;
|
||||
|
||||
|
@ -41,6 +41,7 @@
|
||||
|
||||
static void hideCursor(_GLFWwindow* window)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(window);
|
||||
}
|
||||
|
||||
|
||||
@ -69,6 +70,8 @@ static void captureCursor(_GLFWwindow* window)
|
||||
|
||||
static void showCursor(_GLFWwindow* window)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(window);
|
||||
|
||||
// Un-capture cursor
|
||||
ReleaseCapture();
|
||||
|
||||
@ -325,22 +328,22 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
|
||||
|
||||
case WM_ACTIVATE:
|
||||
{
|
||||
// Window was (de)activated and/or (de)iconified
|
||||
// Window was (de)focused and/or (de)iconified
|
||||
|
||||
BOOL active = LOWORD(wParam) != WA_INACTIVE;
|
||||
BOOL focused = LOWORD(wParam) != WA_INACTIVE;
|
||||
BOOL iconified = HIWORD(wParam) ? TRUE : FALSE;
|
||||
|
||||
if (active && iconified)
|
||||
if (focused && iconified)
|
||||
{
|
||||
// This is a workaround for window iconification using the
|
||||
// taskbar leading to windows being told they're active and
|
||||
// iconified and then never told they're deactivated
|
||||
active = FALSE;
|
||||
// taskbar leading to windows being told they're focused and
|
||||
// iconified and then never told they're defocused
|
||||
focused = FALSE;
|
||||
}
|
||||
|
||||
if (!active && _glfwLibrary.activeWindow == window)
|
||||
if (!focused && _glfwLibrary.focusedWindow == window)
|
||||
{
|
||||
// The window was deactivated (or iconified, see above)
|
||||
// The window was defocused (or iconified, see above)
|
||||
|
||||
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
|
||||
showCursor(window);
|
||||
@ -361,9 +364,9 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (active && _glfwLibrary.activeWindow != window)
|
||||
else if (focused && _glfwLibrary.focusedWindow != window)
|
||||
{
|
||||
// The window was activated
|
||||
// The window was focused
|
||||
|
||||
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
|
||||
captureCursor(window);
|
||||
@ -383,7 +386,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
|
||||
}
|
||||
}
|
||||
|
||||
_glfwInputWindowFocus(window, active);
|
||||
_glfwInputWindowFocus(window, focused);
|
||||
_glfwInputWindowIconify(window, iconified);
|
||||
return 0;
|
||||
}
|
||||
@ -541,7 +544,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
|
||||
|
||||
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
|
||||
{
|
||||
if (_glfwLibrary.activeWindow != window)
|
||||
if (_glfwLibrary.focusedWindow != window)
|
||||
return 0;
|
||||
|
||||
x = newCursorX - window->Win32.oldCursorX;
|
||||
@ -769,7 +772,11 @@ static int createWindow(_GLFWwindow* window,
|
||||
if (window->mode == GLFW_FULLSCREEN)
|
||||
wa.left = wa.top = 0;
|
||||
else
|
||||
{
|
||||
SystemParametersInfo(SPI_GETWORKAREA, 0, &wa, 0);
|
||||
wa.left += wndconfig->positionX;
|
||||
wa.top += wndconfig->positionY;
|
||||
}
|
||||
|
||||
wideTitle = _glfwCreateWideStringFromUTF8(wndconfig->title);
|
||||
if (!wideTitle)
|
||||
@ -822,8 +829,8 @@ static void destroyWindow(_GLFWwindow* window)
|
||||
|
||||
// This is duplicated from glfwDestroyWindow
|
||||
// TODO: Stop duplicating code
|
||||
if (window == _glfwLibrary.activeWindow)
|
||||
_glfwLibrary.activeWindow = NULL;
|
||||
if (window == _glfwLibrary.focusedWindow)
|
||||
_glfwLibrary.focusedWindow = NULL;
|
||||
|
||||
if (window->Win32.handle)
|
||||
{
|
||||
@ -947,8 +954,16 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
|
||||
// we're just creating an OpenGL 3.0+ context with the same pixel
|
||||
// format, but it's not worth the added code complexity
|
||||
|
||||
// First we clear the current context (the one we just created)
|
||||
// This is usually done by glfwDestroyWindow, but as we're not doing
|
||||
// full window destruction, it's duplicated here
|
||||
_glfwPlatformMakeContextCurrent(NULL);
|
||||
|
||||
// Next destroy the Win32 window and WGL context (without resetting or
|
||||
// destroying the GLFW window object)
|
||||
destroyWindow(window);
|
||||
|
||||
// ...and then create them again, this time with better APIs
|
||||
if (!createWindow(window, wndconfig, fbconfig))
|
||||
return GL_FALSE;
|
||||
}
|
||||
@ -1043,23 +1058,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set the window position
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
|
||||
{
|
||||
RECT rect;
|
||||
|
||||
GetClientRect(window->Win32.handle, &rect);
|
||||
AdjustWindowRectEx(&rect, window->Win32.dwStyle, FALSE, window->Win32.dwExStyle);
|
||||
|
||||
SetWindowPos(window->Win32.handle, HWND_TOP,
|
||||
x + rect.left, y + rect.top, 0, 0,
|
||||
SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Window iconification
|
||||
//========================================================================
|
||||
@ -1134,7 +1132,7 @@ void _glfwPlatformPollEvents(void)
|
||||
MSG msg;
|
||||
_GLFWwindow* window;
|
||||
|
||||
window = _glfwLibrary.activeWindow;
|
||||
window = _glfwLibrary.focusedWindow;
|
||||
if (window)
|
||||
{
|
||||
window->Win32.cursorCentered = GL_FALSE;
|
||||
@ -1170,7 +1168,7 @@ void _glfwPlatformPollEvents(void)
|
||||
// LSHIFT/RSHIFT fixup (keys tend to "stick" without this fix)
|
||||
// This is the only async event handling in GLFW, but it solves some
|
||||
// nasty problems.
|
||||
window = _glfwLibrary.activeWindow;
|
||||
window = _glfwLibrary.focusedWindow;
|
||||
if (window)
|
||||
{
|
||||
int lshift_down, rshift_down;
|
||||
@ -1188,8 +1186,8 @@ void _glfwPlatformPollEvents(void)
|
||||
_glfwInputKey(window, GLFW_KEY_RIGHT_SHIFT, GLFW_RELEASE);
|
||||
}
|
||||
|
||||
// Did the cursor move in an active window that has captured the cursor
|
||||
window = _glfwLibrary.activeWindow;
|
||||
// Did the cursor move in an focused window that has captured the cursor
|
||||
window = _glfwLibrary.focusedWindow;
|
||||
if (window)
|
||||
{
|
||||
if (window->cursorMode == GLFW_CURSOR_CAPTURED &&
|
||||
|
228
src/window.c
228
src/window.c
@ -68,50 +68,25 @@ static void clearScrollOffsets(void)
|
||||
////// GLFW internal API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//========================================================================
|
||||
// Reset all window hints to their default values
|
||||
//========================================================================
|
||||
|
||||
void _glfwSetDefaultWindowHints(void)
|
||||
{
|
||||
memset(&_glfwLibrary.hints, 0, sizeof(_glfwLibrary.hints));
|
||||
|
||||
// The default is OpenGL with minimum version 1.0
|
||||
_glfwLibrary.hints.clientAPI = GLFW_OPENGL_API;
|
||||
_glfwLibrary.hints.glMajor = 1;
|
||||
_glfwLibrary.hints.glMinor = 0;
|
||||
|
||||
// The default is to show the window and allow window resizing
|
||||
_glfwLibrary.hints.resizable = GL_TRUE;
|
||||
_glfwLibrary.hints.visible = GL_TRUE;
|
||||
|
||||
// The default is 24 bits of depth, 8 bits of color
|
||||
_glfwLibrary.hints.depthBits = 24;
|
||||
_glfwLibrary.hints.redBits = 8;
|
||||
_glfwLibrary.hints.greenBits = 8;
|
||||
_glfwLibrary.hints.blueBits = 8;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Register window focus events
|
||||
//========================================================================
|
||||
|
||||
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
|
||||
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
|
||||
{
|
||||
if (activated)
|
||||
if (focused)
|
||||
{
|
||||
if (_glfwLibrary.activeWindow != window)
|
||||
if (_glfwLibrary.focusedWindow != window)
|
||||
{
|
||||
_glfwLibrary.activeWindow = window;
|
||||
_glfwLibrary.focusedWindow = window;
|
||||
|
||||
if (_glfwLibrary.windowFocusCallback)
|
||||
_glfwLibrary.windowFocusCallback(window, activated);
|
||||
if (window->windowFocusCallback)
|
||||
window->windowFocusCallback(window, focused);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (_glfwLibrary.activeWindow == window)
|
||||
if (_glfwLibrary.focusedWindow == window)
|
||||
{
|
||||
int i;
|
||||
|
||||
@ -129,10 +104,10 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
|
||||
_glfwInputMouseClick(window, i, GLFW_RELEASE);
|
||||
}
|
||||
|
||||
_glfwLibrary.activeWindow = NULL;
|
||||
_glfwLibrary.focusedWindow = NULL;
|
||||
|
||||
if (_glfwLibrary.windowFocusCallback)
|
||||
_glfwLibrary.windowFocusCallback(window, activated);
|
||||
if (window->windowFocusCallback)
|
||||
window->windowFocusCallback(window, focused);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -161,8 +136,8 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
|
||||
window->width = width;
|
||||
window->height = height;
|
||||
|
||||
if (_glfwLibrary.windowSizeCallback)
|
||||
_glfwLibrary.windowSizeCallback(window, width, height);
|
||||
if (window->windowSizeCallback)
|
||||
window->windowSizeCallback(window, width, height);
|
||||
}
|
||||
|
||||
|
||||
@ -177,8 +152,8 @@ void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
|
||||
|
||||
window->iconified = iconified;
|
||||
|
||||
if (_glfwLibrary.windowIconifyCallback)
|
||||
_glfwLibrary.windowIconifyCallback(window, iconified);
|
||||
if (window->windowIconifyCallback)
|
||||
window->windowIconifyCallback(window, iconified);
|
||||
}
|
||||
|
||||
|
||||
@ -198,8 +173,8 @@ void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
|
||||
|
||||
void _glfwInputWindowDamage(_GLFWwindow* window)
|
||||
{
|
||||
if (_glfwLibrary.windowRefreshCallback)
|
||||
_glfwLibrary.windowRefreshCallback(window);
|
||||
if (window->windowRefreshCallback)
|
||||
window->windowRefreshCallback(window);
|
||||
}
|
||||
|
||||
|
||||
@ -209,8 +184,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
|
||||
|
||||
void _glfwInputWindowCloseRequest(_GLFWwindow* window)
|
||||
{
|
||||
if (_glfwLibrary.windowCloseCallback)
|
||||
window->closeRequested = _glfwLibrary.windowCloseCallback(window);
|
||||
if (window->windowCloseCallback)
|
||||
window->closeRequested = window->windowCloseCallback(window);
|
||||
else
|
||||
window->closeRequested = GL_TRUE;
|
||||
}
|
||||
@ -263,6 +238,8 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
|
||||
wndconfig.refreshRate = Max(_glfwLibrary.hints.refreshRate, 0);
|
||||
wndconfig.resizable = _glfwLibrary.hints.resizable ? GL_TRUE : GL_FALSE;
|
||||
wndconfig.visible = _glfwLibrary.hints.visible ? GL_TRUE : GL_FALSE;
|
||||
wndconfig.positionX = _glfwLibrary.hints.positionX;
|
||||
wndconfig.positionY = _glfwLibrary.hints.positionY;
|
||||
wndconfig.clientAPI = _glfwLibrary.hints.clientAPI;
|
||||
wndconfig.glMajor = _glfwLibrary.hints.glMajor;
|
||||
wndconfig.glMinor = _glfwLibrary.hints.glMinor;
|
||||
@ -270,10 +247,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
|
||||
wndconfig.glDebug = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE;
|
||||
wndconfig.glProfile = _glfwLibrary.hints.glProfile;
|
||||
wndconfig.glRobustness = _glfwLibrary.hints.glRobustness ? GL_TRUE : GL_FALSE;
|
||||
wndconfig.share = share;
|
||||
|
||||
// Reset to default values for the next call
|
||||
_glfwSetDefaultWindowHints();
|
||||
wndconfig.share = (_GLFWwindow*) share;
|
||||
|
||||
// Check the OpenGL bits of the window config
|
||||
if (!_glfwIsValidContextConfig(&wndconfig))
|
||||
@ -289,33 +263,20 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
// Check width & height
|
||||
if (width > 0 && height <= 0)
|
||||
if (width <= 0 || height <= 0)
|
||||
{
|
||||
// Set the window aspect ratio to 4:3
|
||||
height = (width * 3) / 4;
|
||||
}
|
||||
else if (width <= 0 && height > 0)
|
||||
{
|
||||
// Set the window aspect ratio to 4:3
|
||||
width = (height * 4) / 3;
|
||||
}
|
||||
else if (width <= 0 && height <= 0)
|
||||
{
|
||||
// Default window size
|
||||
width = 640;
|
||||
height = 480;
|
||||
_glfwSetError(GLFW_INVALID_VALUE,
|
||||
"glfwCreateWindow: Invalid window size");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
window = (_GLFWwindow*) malloc(sizeof(_GLFWwindow));
|
||||
window = (_GLFWwindow*) calloc(1, sizeof(_GLFWwindow));
|
||||
if (!window)
|
||||
{
|
||||
_glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memset(window, 0, sizeof(_GLFWwindow));
|
||||
|
||||
window->next = _glfwLibrary.windowListHead;
|
||||
_glfwLibrary.windowListHead = window;
|
||||
|
||||
@ -325,7 +286,6 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
|
||||
window->mode = mode;
|
||||
window->resizable = wndconfig.resizable;
|
||||
window->cursorMode = GLFW_CURSOR_NORMAL;
|
||||
window->systemKeys = GL_TRUE;
|
||||
|
||||
// Open the actual window and create its context
|
||||
if (!_glfwPlatformCreateWindow(window, &wndconfig, &fbconfig))
|
||||
@ -376,6 +336,42 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Reset all window hints to their default values
|
||||
//========================================================================
|
||||
|
||||
void glfwDefaultWindowHints(void)
|
||||
{
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
memset(&_glfwLibrary.hints, 0, sizeof(_glfwLibrary.hints));
|
||||
|
||||
// The default is OpenGL with minimum version 1.0
|
||||
_glfwLibrary.hints.clientAPI = GLFW_OPENGL_API;
|
||||
_glfwLibrary.hints.glMajor = 1;
|
||||
_glfwLibrary.hints.glMinor = 0;
|
||||
|
||||
// The default is to show the window and allow window resizing
|
||||
_glfwLibrary.hints.resizable = GL_TRUE;
|
||||
_glfwLibrary.hints.visible = GL_TRUE;
|
||||
|
||||
// The default window position is the upper left corner of the screen
|
||||
_glfwLibrary.hints.positionX = 0;
|
||||
_glfwLibrary.hints.positionY = 0;
|
||||
|
||||
// The default is 24 bits of color, 24 bits of depth and 8 bits of stencil
|
||||
_glfwLibrary.hints.redBits = 8;
|
||||
_glfwLibrary.hints.greenBits = 8;
|
||||
_glfwLibrary.hints.blueBits = 8;
|
||||
_glfwLibrary.hints.depthBits = 24;
|
||||
_glfwLibrary.hints.stencilBits = 8;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set hints for creating the window
|
||||
//========================================================================
|
||||
@ -435,6 +431,12 @@ GLFWAPI void glfwWindowHint(int target, int hint)
|
||||
case GLFW_VISIBLE:
|
||||
_glfwLibrary.hints.visible = hint;
|
||||
break;
|
||||
case GLFW_POSITION_X:
|
||||
_glfwLibrary.hints.positionX = hint;
|
||||
break;
|
||||
case GLFW_POSITION_Y:
|
||||
_glfwLibrary.hints.positionY = hint;
|
||||
break;
|
||||
case GLFW_FSAA_SAMPLES:
|
||||
_glfwLibrary.hints.samples = hint;
|
||||
break;
|
||||
@ -484,14 +486,14 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow handle)
|
||||
if (window == NULL)
|
||||
return;
|
||||
|
||||
// Clear the current context if this window's context is current
|
||||
// TODO: Re-examine this in light of multithreading
|
||||
// The window's context must not be current on another thread when the
|
||||
// window is destroyed
|
||||
if (window == _glfwPlatformGetCurrentContext())
|
||||
_glfwPlatformMakeContextCurrent(NULL);
|
||||
|
||||
// Clear the active window pointer if this is the active window
|
||||
if (window == _glfwLibrary.activeWindow)
|
||||
_glfwLibrary.activeWindow = NULL;
|
||||
// Clear the focused window pointer if this is the focused window
|
||||
if (window == _glfwLibrary.focusedWindow)
|
||||
_glfwLibrary.focusedWindow = NULL;
|
||||
|
||||
_glfwPlatformDestroyWindow(window);
|
||||
|
||||
@ -584,52 +586,6 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow handle, int width, int height)
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Get the window position
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwGetWindowPos(GLFWwindow handle, int* xpos, int* ypos)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
if (xpos != NULL)
|
||||
*xpos = window->positionX;
|
||||
|
||||
if (ypos != NULL)
|
||||
*ypos = window->positionY;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set the window position
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetWindowPos(GLFWwindow handle, int xpos, int ypos)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
if (window->mode == GLFW_FULLSCREEN || window->iconified)
|
||||
{
|
||||
// TODO: Figure out if this is an error
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwPlatformSetWindowPos(window, xpos, ypos);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Window iconification
|
||||
//========================================================================
|
||||
@ -733,8 +689,8 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param)
|
||||
|
||||
switch (param)
|
||||
{
|
||||
case GLFW_ACTIVE:
|
||||
return window == _glfwLibrary.activeWindow;
|
||||
case GLFW_FOCUSED:
|
||||
return window == _glfwLibrary.focusedWindow;
|
||||
case GLFW_ICONIFIED:
|
||||
return window->iconified;
|
||||
case GLFW_CLOSE_REQUESTED:
|
||||
@ -745,6 +701,10 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param)
|
||||
return window->resizable;
|
||||
case GLFW_VISIBLE:
|
||||
return window->visible;
|
||||
case GLFW_POSITION_X:
|
||||
return window->positionX;
|
||||
case GLFW_POSITION_Y:
|
||||
return window->positionY;
|
||||
case GLFW_CLIENT_API:
|
||||
return window->clientAPI;
|
||||
case GLFW_OPENGL_VERSION_MAJOR:
|
||||
@ -808,15 +768,17 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow handle)
|
||||
// Set callback function for window size changes
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
|
||||
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow handle, GLFWwindowsizefun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.windowSizeCallback = cbfun;
|
||||
window->windowSizeCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -824,15 +786,17 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
|
||||
// Set callback function for window close events
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
|
||||
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow handle, GLFWwindowclosefun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.windowCloseCallback = cbfun;
|
||||
window->windowCloseCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -840,15 +804,17 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
|
||||
// Set callback function for window refresh events
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
|
||||
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow handle, GLFWwindowrefreshfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.windowRefreshCallback = cbfun;
|
||||
window->windowRefreshCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -856,15 +822,17 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
|
||||
// Set callback function for window focus events
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
|
||||
GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow handle, GLFWwindowfocusfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.windowFocusCallback = cbfun;
|
||||
window->windowFocusCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
@ -872,15 +840,17 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
|
||||
// Set callback function for window iconification events
|
||||
//========================================================================
|
||||
|
||||
GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun)
|
||||
GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow handle, GLFWwindowiconifyfun cbfun)
|
||||
{
|
||||
_GLFWwindow* window = (_GLFWwindow*) handle;
|
||||
|
||||
if (!_glfwInitialized)
|
||||
{
|
||||
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
_glfwLibrary.windowIconifyCallback = cbfun;
|
||||
window->windowIconifyCallback = cbfun;
|
||||
}
|
||||
|
||||
|
||||
|
@ -491,7 +491,7 @@ static GLboolean initDisplay(void)
|
||||
_glfwLibrary.X11.display = XOpenDisplay(NULL);
|
||||
if (!_glfwLibrary.X11.display)
|
||||
{
|
||||
_glfwSetError(GLFW_OPENGL_UNAVAILABLE, "X11: Failed to open X display");
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE, "X11: Failed to open X display");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
@ -728,7 +728,7 @@ const char* _glfwPlatformGetVersionString(void)
|
||||
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
|
||||
" clock_gettime"
|
||||
#endif
|
||||
#if defined(_GLFW_HAS_LINUX_JOYSTICKS)
|
||||
#if defined(__linux__)
|
||||
" Linux-joystick-API"
|
||||
#else
|
||||
" no-joystick-support"
|
||||
|
@ -1,65 +0,0 @@
|
||||
//========================================================================
|
||||
// GLFW - An OpenGL library
|
||||
// Platform: X11
|
||||
// API version: 3.0
|
||||
// WWW: http://www.glfw.org/
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2002-2006 Marcus Geelnard
|
||||
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
|
||||
//
|
||||
// This software is provided 'as-is', without any express or implied
|
||||
// warranty. In no event will the authors be held liable for any damages
|
||||
// arising from the use of this software.
|
||||
//
|
||||
// Permission is granted to anyone to use this software for any purpose,
|
||||
// including commercial applications, and to alter it and redistribute it
|
||||
// freely, subject to the following restrictions:
|
||||
//
|
||||
// 1. The origin of this software must not be misrepresented; you must not
|
||||
// claim that you wrote the original software. If you use this software
|
||||
// in a product, an acknowledgment in the product documentation would
|
||||
// be appreciated but is not required.
|
||||
//
|
||||
// 2. Altered source versions must be plainly marked as such, and must not
|
||||
// be misrepresented as being the original software.
|
||||
//
|
||||
// 3. This notice may not be removed or altered from any source
|
||||
// distribution.
|
||||
//
|
||||
//========================================================================
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW platform API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//========================================================================
|
||||
// Enable system keys
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
|
||||
{
|
||||
if (window->X11.keyboardGrabbed)
|
||||
{
|
||||
XUngrabKeyboard(_glfwLibrary.X11.display, CurrentTime);
|
||||
window->X11.keyboardGrabbed = GL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Disable system keys
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
|
||||
{
|
||||
if (XGrabKeyboard(_glfwLibrary.X11.display, window->X11.handle,
|
||||
True, GrabModeAsync, GrabModeAsync, CurrentTime)
|
||||
== GrabSuccess)
|
||||
{
|
||||
window->X11.keyboardGrabbed = GL_TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -30,7 +30,7 @@
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
#ifdef _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#ifdef __linux__
|
||||
#include <linux/joystick.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
@ -41,7 +41,7 @@
|
||||
#include <dirent.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#endif // _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#endif // __linux__
|
||||
|
||||
|
||||
//========================================================================
|
||||
@ -50,7 +50,7 @@
|
||||
|
||||
static int openJoystickDevice(int joy, const char* path)
|
||||
{
|
||||
#ifdef _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#ifdef __linux__
|
||||
char numAxes, numButtons;
|
||||
int fd, version;
|
||||
|
||||
@ -97,7 +97,7 @@ static int openJoystickDevice(int joy, const char* path)
|
||||
}
|
||||
|
||||
_glfwLibrary.X11.joystick[joy].present = GL_TRUE;
|
||||
#endif // _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#endif // __linux__
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
@ -109,7 +109,7 @@ static int openJoystickDevice(int joy, const char* path)
|
||||
|
||||
static void pollJoystickEvents(void)
|
||||
{
|
||||
#ifdef _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#ifdef __linux__
|
||||
int i;
|
||||
ssize_t result;
|
||||
struct js_event e;
|
||||
@ -160,7 +160,7 @@ static void pollJoystickEvents(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif // _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#endif // __linux__
|
||||
}
|
||||
|
||||
|
||||
@ -174,7 +174,7 @@ static void pollJoystickEvents(void)
|
||||
|
||||
int _glfwInitJoysticks(void)
|
||||
{
|
||||
#ifdef _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#ifdef __linux__
|
||||
int i, joy = 0;
|
||||
regex_t regex;
|
||||
DIR* dir;
|
||||
@ -215,7 +215,7 @@ int _glfwInitJoysticks(void)
|
||||
}
|
||||
|
||||
regfree(®ex);
|
||||
#endif // _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#endif // __linux__
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
@ -227,7 +227,7 @@ int _glfwInitJoysticks(void)
|
||||
|
||||
void _glfwTerminateJoysticks(void)
|
||||
{
|
||||
#ifdef _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#ifdef __linux__
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= GLFW_JOYSTICK_LAST; i++)
|
||||
@ -241,7 +241,7 @@ void _glfwTerminateJoysticks(void)
|
||||
_glfwLibrary.X11.joystick[i].present = GL_FALSE;
|
||||
}
|
||||
}
|
||||
#endif // _GLFW_HAS_LINUX_JOYSTICKS
|
||||
#endif // __linux__
|
||||
}
|
||||
|
||||
|
||||
|
@ -99,12 +99,17 @@ typedef struct _GLFWwindowX11
|
||||
|
||||
// Various platform specific internal variables
|
||||
GLboolean overrideRedirect; // True if window is OverrideRedirect
|
||||
GLboolean keyboardGrabbed; // True if keyboard is currently grabbed
|
||||
GLboolean cursorGrabbed; // True if cursor is currently grabbed
|
||||
GLboolean cursorHidden; // True if cursor is currently hidden
|
||||
GLboolean cursorCentered; // True if cursor was moved since last poll
|
||||
int cursorPosX, cursorPosY;
|
||||
|
||||
// Window position hint (commited the first time the window is shown)
|
||||
GLboolean windowPosSet; // False until the window position has
|
||||
// been set
|
||||
int positionX; // The window position to be set the
|
||||
int positionY; // first time the window is shown
|
||||
|
||||
} _GLFWwindowX11;
|
||||
|
||||
|
||||
|
@ -119,7 +119,7 @@ static GLboolean createWindow(_GLFWwindow* window,
|
||||
|
||||
window->X11.handle = XCreateWindow(_glfwLibrary.X11.display,
|
||||
_glfwLibrary.X11.root,
|
||||
0, 0, // Position
|
||||
wndconfig->positionX, wndconfig->positionY,
|
||||
window->width, window->height,
|
||||
0, // Border width
|
||||
visual->depth, // Color depth
|
||||
@ -136,6 +136,12 @@ static GLboolean createWindow(_GLFWwindow* window,
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR, "X11: Failed to create window");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
// Request a window position to be set once the window is shown
|
||||
// (see _glfwPlatformShowWindow)
|
||||
window->X11.windowPosSet = GL_FALSE;
|
||||
window->X11.positionX = wndconfig->positionX;
|
||||
window->X11.positionY = wndconfig->positionY;
|
||||
}
|
||||
|
||||
if (window->mode == GLFW_FULLSCREEN && !_glfwLibrary.X11.hasEWMH)
|
||||
@ -238,6 +244,15 @@ static GLboolean createWindow(_GLFWwindow* window,
|
||||
|
||||
static void hideCursor(_GLFWwindow* window)
|
||||
{
|
||||
// Un-grab cursor (in windowed mode only; in fullscreen mode we still
|
||||
// want the cursor grabbed in order to confine the cursor to the window
|
||||
// area)
|
||||
if (window->X11.cursorGrabbed && window->mode == GLFW_WINDOWED)
|
||||
{
|
||||
XUngrabPointer(_glfwLibrary.X11.display, CurrentTime);
|
||||
window->X11.cursorGrabbed = GL_FALSE;
|
||||
}
|
||||
|
||||
if (!window->X11.cursorHidden)
|
||||
{
|
||||
XDefineCursor(_glfwLibrary.X11.display,
|
||||
@ -280,7 +295,7 @@ static void showCursor(_GLFWwindow* window)
|
||||
// Un-grab cursor (in windowed mode only; in fullscreen mode we still
|
||||
// want the cursor grabbed in order to confine the cursor to the window
|
||||
// area)
|
||||
if (window->X11.cursorGrabbed)
|
||||
if (window->X11.cursorGrabbed && window->mode == GLFW_WINDOWED)
|
||||
{
|
||||
XUngrabPointer(_glfwLibrary.X11.display, CurrentTime);
|
||||
window->X11.cursorGrabbed = GL_FALSE;
|
||||
@ -617,7 +632,7 @@ static void processEvent(XEvent *event)
|
||||
|
||||
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
|
||||
{
|
||||
if (_glfwLibrary.activeWindow != window)
|
||||
if (_glfwLibrary.focusedWindow != window)
|
||||
break;
|
||||
|
||||
x = event->xmotion.x - window->X11.cursorPosX;
|
||||
@ -997,16 +1012,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set the window position.
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
|
||||
{
|
||||
XMoveWindow(_glfwLibrary.X11.display, window->X11.handle, x, y);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Window iconification
|
||||
//========================================================================
|
||||
@ -1051,6 +1056,15 @@ void _glfwPlatformShowWindow(_GLFWwindow* window)
|
||||
{
|
||||
XMapRaised(_glfwLibrary.X11.display, window->X11.handle);
|
||||
XFlush(_glfwLibrary.X11.display);
|
||||
|
||||
// Set the window position the first time the window is shown
|
||||
// Note: XMoveWindow has no effect before the window has been mapped.
|
||||
if (!window->X11.windowPosSet)
|
||||
{
|
||||
XMoveWindow(_glfwLibrary.X11.display, window->X11.handle,
|
||||
window->X11.positionX, window->X11.positionY);
|
||||
window->X11.windowPosSet = GL_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1120,11 +1134,11 @@ void _glfwPlatformPollEvents(void)
|
||||
processEvent(&event);
|
||||
}
|
||||
|
||||
// Check whether the cursor has moved inside an active window that has
|
||||
// Check whether the cursor has moved inside an focused window that has
|
||||
// captured the cursor (because then it needs to be re-centered)
|
||||
|
||||
_GLFWwindow* window;
|
||||
window = _glfwLibrary.activeWindow;
|
||||
window = _glfwLibrary.focusedWindow;
|
||||
if (window)
|
||||
{
|
||||
if (window->cursorMode == GLFW_CURSOR_CAPTURED &&
|
||||
|
@ -86,10 +86,6 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetCursorPosCallback(cursor_position_callback);
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
|
||||
window = glfwCreateWindow(window_width, window_height, GLFW_WINDOWED, "", NULL);
|
||||
if (!window)
|
||||
{
|
||||
@ -99,6 +95,10 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetCursorPosCallback(window, cursor_position_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
|
||||
glfwGetWindowSize(window, &width, &height);
|
||||
|
@ -125,7 +125,7 @@ int main(int argc, char** argv)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Clipboard Test", NULL);
|
||||
window = glfwCreateWindow(200, 200, GLFW_WINDOWED, "Clipboard Test", NULL);
|
||||
if (!window)
|
||||
{
|
||||
glfwTerminate();
|
||||
@ -137,9 +137,9 @@ int main(int argc, char** argv)
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
|
||||
|
@ -85,7 +85,7 @@ int main(void)
|
||||
|
||||
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
|
||||
|
||||
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Defaults", NULL);
|
||||
window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Defaults", NULL);
|
||||
if (!window)
|
||||
{
|
||||
glfwTerminate();
|
||||
|
@ -41,8 +41,6 @@
|
||||
#include <locale.h>
|
||||
|
||||
// These must match the input mode defaults
|
||||
static GLboolean keyrepeat = GL_FALSE;
|
||||
static GLboolean systemkeys = GL_TRUE;
|
||||
static GLboolean closeable = GL_TRUE;
|
||||
|
||||
// Event index
|
||||
@ -249,12 +247,12 @@ static void window_refresh_callback(GLFWwindow window)
|
||||
}
|
||||
}
|
||||
|
||||
static void window_focus_callback(GLFWwindow window, int activated)
|
||||
static void window_focus_callback(GLFWwindow window, int focused)
|
||||
{
|
||||
printf("%08x at %0.3f: Window %s\n",
|
||||
counter++,
|
||||
glfwGetTime(),
|
||||
activated ? "activated" : "deactivated");
|
||||
focused ? "focused" : "defocused");
|
||||
}
|
||||
|
||||
static void window_iconify_callback(GLFWwindow window, int iconified)
|
||||
@ -311,24 +309,6 @@ static void key_callback(GLFWwindow window, int key, int action)
|
||||
|
||||
switch (key)
|
||||
{
|
||||
case GLFW_KEY_R:
|
||||
{
|
||||
keyrepeat = !keyrepeat;
|
||||
glfwSetInputMode(window, GLFW_KEY_REPEAT, keyrepeat);
|
||||
|
||||
printf("(( key repeat %s ))\n", keyrepeat ? "enabled" : "disabled");
|
||||
break;
|
||||
}
|
||||
|
||||
case GLFW_KEY_S:
|
||||
{
|
||||
systemkeys = !systemkeys;
|
||||
glfwSetInputMode(window, GLFW_SYSTEM_KEYS, systemkeys);
|
||||
|
||||
printf("(( system keys %s ))\n", systemkeys ? "enabled" : "disabled");
|
||||
break;
|
||||
}
|
||||
|
||||
case GLFW_KEY_C:
|
||||
{
|
||||
closeable = !closeable;
|
||||
@ -363,19 +343,7 @@ int main(void)
|
||||
|
||||
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);
|
||||
window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Event Linter", NULL);
|
||||
if (!window)
|
||||
{
|
||||
glfwTerminate();
|
||||
@ -386,15 +354,24 @@ int main(void)
|
||||
|
||||
printf("Window opened\n");
|
||||
|
||||
glfwSetWindowSizeCallback(window, window_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("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))
|
||||
|
@ -93,9 +93,6 @@ int main(int argc, char** argv)
|
||||
else
|
||||
printf("Requesting that FSAA not be available\n");
|
||||
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
|
||||
glfwWindowHint(GLFW_FSAA_SAMPLES, samples);
|
||||
|
||||
window = glfwCreateWindow(800, 400, GLFW_WINDOWED, "Aliasing Detector", NULL);
|
||||
@ -107,6 +104,9 @@ int main(int argc, char** argv)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
|
@ -23,7 +23,7 @@
|
||||
//
|
||||
//========================================================================
|
||||
//
|
||||
// This test is used to test window activation and iconfication for
|
||||
// This test is used to test window focusing and iconfication for
|
||||
// fullscreen windows with a video mode differing from the desktop mode
|
||||
//
|
||||
//========================================================================
|
||||
@ -35,11 +35,11 @@
|
||||
|
||||
static GLboolean running = GL_TRUE;
|
||||
|
||||
static void window_focus_callback(GLFWwindow window, int activated)
|
||||
static void window_focus_callback(GLFWwindow window, int focused)
|
||||
{
|
||||
printf("%0.3f: Window %s\n",
|
||||
glfwGetTime(),
|
||||
activated ? "activated" : "deactivated");
|
||||
focused ? "focused" : "defocused");
|
||||
}
|
||||
|
||||
static void window_key_callback(GLFWwindow window, int key, int action)
|
||||
@ -96,9 +96,9 @@ int main(void)
|
||||
|
||||
glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL);
|
||||
|
||||
glfwSetWindowFocusCallback(window_focus_callback);
|
||||
glfwSetKeyCallback(window_key_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetWindowFocusCallback(window, window_focus_callback);
|
||||
glfwSetKeyCallback(window, window_key_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
|
||||
while (running)
|
||||
{
|
||||
|
@ -133,8 +133,8 @@ int main(int argc, char** argv)
|
||||
}
|
||||
else
|
||||
{
|
||||
width = 0;
|
||||
height = 0;
|
||||
width = 200;
|
||||
height = 200;
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(width, height, mode, "Gamma Test", NULL);
|
||||
@ -151,9 +151,9 @@ int main(int argc, char** argv)
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetWindowSizeCallback(size_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
glfwSetWindowSizeCallback(window, size_callback);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
|
||||
|
@ -61,7 +61,7 @@ static void usage(void)
|
||||
|
||||
static void error_callback(int error, const char* description)
|
||||
{
|
||||
fprintf(stderr, "Error: %s in %s\n", glfwErrorString(error), description);
|
||||
fprintf(stderr, "Error: %s\n", description);
|
||||
}
|
||||
|
||||
static const char* get_client_api_name(int api)
|
||||
@ -74,7 +74,7 @@ static const char* get_client_api_name(int api)
|
||||
return "Unknown API";
|
||||
}
|
||||
|
||||
static const char* get_profile_name(GLint mask)
|
||||
static const char* get_profile_name_gl(GLint mask)
|
||||
{
|
||||
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
|
||||
return "compatibility";
|
||||
@ -84,6 +84,16 @@ static const char* get_profile_name(GLint mask)
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
static const char* get_profile_name_glfw(int profile)
|
||||
{
|
||||
if (profile == GLFW_OPENGL_COMPAT_PROFILE)
|
||||
return "compatibility";
|
||||
if (profile == GLFW_OPENGL_CORE_PROFILE)
|
||||
return "core";
|
||||
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
static void list_extensions(int api, int major, int minor)
|
||||
{
|
||||
int i;
|
||||
@ -96,7 +106,10 @@ static void list_extensions(int api, int major, int minor)
|
||||
{
|
||||
PFNGLGETSTRINGIPROC glGetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
|
||||
if (!glGetStringi)
|
||||
{
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glGetIntegerv(GL_NUM_EXTENSIONS, &count);
|
||||
|
||||
@ -255,9 +268,12 @@ int main(int argc, char** argv)
|
||||
// We assume here that we stand a better chance of success by leaving all
|
||||
// possible details of pixel format selection to GLFW
|
||||
|
||||
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Version", NULL);
|
||||
window = glfwCreateWindow(200, 200, GLFW_WINDOWED, "Version", NULL);
|
||||
if (!window)
|
||||
{
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
|
||||
@ -302,13 +318,17 @@ int main(int argc, char** argv)
|
||||
|
||||
if (major > 3 || (major == 3 && minor >= 2))
|
||||
{
|
||||
int profile = glfwGetWindowParam(window, GLFW_OPENGL_PROFILE);
|
||||
|
||||
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
|
||||
printf("%s profile mask (0x%08x): %s\n",
|
||||
get_client_api_name(api),
|
||||
mask,
|
||||
get_profile_name(mask));
|
||||
get_profile_name_gl(mask));
|
||||
|
||||
printf("%s profile mask parsed by GLFW:\n", get_client_api_name(api));
|
||||
printf("%s profile mask parsed by GLFW: %s\n",
|
||||
get_client_api_name(api),
|
||||
get_profile_name_glfw(profile));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -70,16 +70,29 @@ static void key_callback(GLFWwindow window, int key, int action)
|
||||
|
||||
static void window_size_callback(GLFWwindow window, int width, int height)
|
||||
{
|
||||
printf("%0.2f Size %ix%i\n", glfwGetTime(), width, height);
|
||||
printf("%0.2f Window resized to %ix%i\n", glfwGetTime(), width, height);
|
||||
|
||||
glViewport(0, 0, width, height);
|
||||
}
|
||||
|
||||
static void window_focus_callback(GLFWwindow window, int focused)
|
||||
{
|
||||
printf("%0.2f Window %s\n",
|
||||
glfwGetTime(),
|
||||
focused ? "focused" : "defocused");
|
||||
}
|
||||
|
||||
static void window_iconify_callback(GLFWwindow window, int iconified)
|
||||
{
|
||||
printf("%0.2f Window %s\n",
|
||||
glfwGetTime(),
|
||||
iconified ? "iconified" : "restored");
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
int width, height, ch;
|
||||
int mode = GLFW_WINDOWED;
|
||||
GLboolean active = -1, iconified = -1;
|
||||
GLFWwindow window;
|
||||
|
||||
while ((ch = getopt(argc, argv, "fh")) != -1)
|
||||
@ -115,8 +128,8 @@ int main(int argc, char** argv)
|
||||
}
|
||||
else
|
||||
{
|
||||
width = 0;
|
||||
height = 0;
|
||||
width = 640;
|
||||
height = 480;
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(width, height, mode, "Iconify", NULL);
|
||||
@ -131,26 +144,20 @@ int main(int argc, char** argv)
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
glfwSetWindowFocusCallback(window, window_focus_callback);
|
||||
glfwSetWindowIconifyCallback(window, window_iconify_callback);
|
||||
|
||||
printf("Window is %s and %s\n",
|
||||
glfwGetWindowParam(window, GLFW_ICONIFIED) ? "iconified" : "restored",
|
||||
glfwGetWindowParam(window, GLFW_FOCUSED) ? "focused" : "defocused");
|
||||
|
||||
glEnable(GL_SCISSOR_TEST);
|
||||
|
||||
while (!closed)
|
||||
{
|
||||
if (iconified != glfwGetWindowParam(window, GLFW_ICONIFIED) ||
|
||||
active != glfwGetWindowParam(window, GLFW_ACTIVE))
|
||||
{
|
||||
iconified = glfwGetWindowParam(window, GLFW_ICONIFIED);
|
||||
active = glfwGetWindowParam(window, GLFW_ACTIVE);
|
||||
|
||||
printf("%0.2f %s %s\n",
|
||||
glfwGetTime(),
|
||||
iconified ? "Iconified" : "Restored",
|
||||
active ? "Active" : "Inactive");
|
||||
}
|
||||
|
||||
glfwGetWindowSize(window, &width, &height);
|
||||
|
||||
glScissor(0, 0, width, height);
|
||||
|
@ -186,7 +186,7 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Joystick Test", NULL);
|
||||
window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Joystick Test", NULL);
|
||||
if (!window)
|
||||
{
|
||||
glfwTerminate();
|
||||
@ -195,7 +195,7 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
@ -117,10 +117,6 @@ static void test_modes(void)
|
||||
int i, count;
|
||||
GLFWvidmode* modes = glfwGetVideoModes(&count);
|
||||
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
GLFWvidmode* mode = modes + i;
|
||||
@ -143,6 +139,10 @@ static void test_modes(void)
|
||||
continue;
|
||||
}
|
||||
|
||||
glfwSetWindowSizeCallback(window_handle, window_size_callback);
|
||||
glfwSetWindowCloseCallback(window_handle, window_close_callback);
|
||||
glfwSetKeyCallback(window_handle, key_callback);
|
||||
|
||||
glfwMakeContextCurrent(window_handle);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
@ -157,6 +157,8 @@ static void test_modes(void)
|
||||
if (!window_handle)
|
||||
{
|
||||
printf("User terminated program\n");
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
}
|
||||
@ -224,6 +226,7 @@ int main(int argc, char** argv)
|
||||
else if (mode == TEST_MODE)
|
||||
test_modes();
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
|
@ -92,7 +92,7 @@ static void window_size_callback(GLFWwindow window, int width, int height)
|
||||
|
||||
static GLboolean open_window(void)
|
||||
{
|
||||
window_handle = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Peter Detector", NULL);
|
||||
window_handle = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Peter Detector", NULL);
|
||||
if (!window_handle)
|
||||
return GL_FALSE;
|
||||
|
||||
@ -102,9 +102,9 @@ static GLboolean open_window(void)
|
||||
glfwGetCursorPos(window_handle, &cursor_x, &cursor_y);
|
||||
printf("Cursor position: %i %i\n", cursor_x, cursor_y);
|
||||
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetCursorPosCallback(cursor_position_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowSizeCallback(window_handle, window_size_callback);
|
||||
glfwSetCursorPosCallback(window_handle, cursor_position_callback);
|
||||
glfwSetKeyCallback(window_handle, key_callback);
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
@ -120,6 +120,8 @@ int main(void)
|
||||
if (!open_window())
|
||||
{
|
||||
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
@ -138,6 +140,8 @@ int main(void)
|
||||
if (!open_window())
|
||||
{
|
||||
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
|
@ -102,9 +102,9 @@ static GLboolean open_window(int width, int height, int mode)
|
||||
glfwMakeContextCurrent(window_handle);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowSizeCallback(window_handle, window_size_callback);
|
||||
glfwSetWindowCloseCallback(window_handle, window_close_callback);
|
||||
glfwSetKeyCallback(window_handle, key_callback);
|
||||
|
||||
printf("Opening %s mode window took %0.3f seconds\n",
|
||||
get_mode_name(mode),
|
||||
@ -132,7 +132,10 @@ int main(int argc, char** argv)
|
||||
for (;;)
|
||||
{
|
||||
if (!open_window(640, 480, (count & 1) ? GLFW_FULLSCREEN : GLFW_WINDOWED))
|
||||
{
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
|
||||
@ -156,6 +159,8 @@ int main(int argc, char** argv)
|
||||
{
|
||||
close_window();
|
||||
printf("User closed window\n");
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
}
|
||||
|
@ -51,10 +51,12 @@ static int window_close_callback(GLFWwindow window)
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
static GLFWwindow open_window(const char* title, GLFWwindow share)
|
||||
static GLFWwindow open_window(const char* title, GLFWwindow share, int posX, int posY)
|
||||
{
|
||||
GLFWwindow window;
|
||||
|
||||
glfwWindowHint(GLFW_POSITION_X, posX);
|
||||
glfwWindowHint(GLFW_POSITION_Y, posY);
|
||||
window = glfwCreateWindow(WIDTH, HEIGHT, GLFW_WINDOWED, title, share);
|
||||
if (!window)
|
||||
return NULL;
|
||||
@ -62,8 +64,8 @@ static GLFWwindow open_window(const char* title, GLFWwindow share)
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwSetWindowCloseCallback(window_close_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowCloseCallback(window, window_close_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
|
||||
return window;
|
||||
}
|
||||
@ -125,7 +127,6 @@ static void draw_quad(GLuint texture)
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
GLuint texture;
|
||||
int x, y;
|
||||
|
||||
if (!glfwInit())
|
||||
{
|
||||
@ -133,10 +134,12 @@ int main(int argc, char** argv)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
windows[0] = open_window("First", NULL);
|
||||
windows[0] = open_window("First", NULL, 0, 0);
|
||||
if (!windows[0])
|
||||
{
|
||||
fprintf(stderr, "Failed to open first GLFW window: %s\n", glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
@ -145,21 +148,23 @@ int main(int argc, char** argv)
|
||||
// It will then be shared with the second context, created below
|
||||
texture = create_texture();
|
||||
|
||||
windows[1] = open_window("Second", windows[0]);
|
||||
// Put the second window to the right of the first one
|
||||
windows[1] = open_window("Second", windows[0], WIDTH + 50, 0);
|
||||
if (!windows[1])
|
||||
{
|
||||
fprintf(stderr, "Failed to open second GLFW window: %s\n", glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// Set drawing color for the first context and copy it to the second
|
||||
// Set drawing color for both contexts
|
||||
glfwMakeContextCurrent(windows[0]);
|
||||
glColor3f(0.6f, 0.f, 0.6f);
|
||||
glfwCopyContext(windows[0], windows[1], GL_CURRENT_BIT);
|
||||
glfwMakeContextCurrent(windows[1]);
|
||||
glColor3f(0.6f, 0.6f, 0.f);
|
||||
|
||||
// Put the second window to the right of the first one
|
||||
glfwGetWindowPos(windows[0], &x, &y);
|
||||
glfwSetWindowPos(windows[1], x + WIDTH + 50, y);
|
||||
glfwMakeContextCurrent(windows[0]);
|
||||
|
||||
while (!closed)
|
||||
{
|
||||
|
@ -70,20 +70,20 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "", NULL);
|
||||
window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "", NULL);
|
||||
if (!window)
|
||||
{
|
||||
glfwTerminate();
|
||||
|
||||
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
set_swap_interval(window, swap_interval);
|
||||
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetKeyCallback(key_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
glfwSetKeyCallback(window, key_callback);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
|
||||
|
@ -28,6 +28,8 @@
|
||||
//
|
||||
//========================================================================
|
||||
|
||||
#include "tinycthread.h"
|
||||
|
||||
#include <GL/glfw3.h>
|
||||
|
||||
#include <stdio.h>
|
||||
@ -35,8 +37,6 @@
|
||||
#include <math.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "tinycthread.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
GLFWwindow window;
|
||||
@ -89,6 +89,8 @@ int main(void)
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
glfwWindowHint(GLFW_POSITION_X, 200 + 250 * i);
|
||||
glfwWindowHint(GLFW_POSITION_Y, 200);
|
||||
threads[i].window = glfwCreateWindow(200, 200,
|
||||
GLFW_WINDOWED,
|
||||
threads[i].title,
|
||||
@ -100,8 +102,6 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200);
|
||||
|
||||
if (thrd_create(&threads[i].id, thread_main, threads + i) !=
|
||||
thrd_success)
|
||||
{
|
||||
|
@ -47,17 +47,19 @@ int main(void)
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL);
|
||||
window = glfwCreateWindow(400, 400, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL);
|
||||
if (!window)
|
||||
{
|
||||
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
glfwSetWindowSizeCallback(window_size_callback);
|
||||
glfwSetWindowSizeCallback(window, window_size_callback);
|
||||
|
||||
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
|
||||
{
|
||||
@ -66,6 +68,7 @@ int main(void)
|
||||
glfwWaitEvents();
|
||||
}
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
|
@ -55,11 +55,14 @@ int main(void)
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
glfwWindowHint(GLFW_POSITION_X, 100 + (i & 1) * 300);
|
||||
glfwWindowHint(GLFW_POSITION_Y, 100 + (i >> 1) * 300);
|
||||
windows[i] = glfwCreateWindow(200, 200, GLFW_WINDOWED, titles[i], NULL);
|
||||
if (!windows[i])
|
||||
{
|
||||
fprintf(stderr, "Failed to open GLFW window: %s\n",
|
||||
glfwErrorString(glfwGetError()));
|
||||
|
||||
glfwTerminate();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
@ -69,8 +72,6 @@ int main(void)
|
||||
(GLclampf) (i >> 1),
|
||||
i ? 0.f : 1.f,
|
||||
0.f);
|
||||
|
||||
glfwSetWindowPos(windows[i], 100 + (i & 1) * 300, 100 + (i >> 1) * 300);
|
||||
}
|
||||
|
||||
while (running)
|
||||
|
Loading…
Reference in New Issue
Block a user