mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-22 04:54:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into multi-monitor

Browse Source 
Conflicts:
	tests/modes.c
This commit is contained in:
Camilla Berglund 2012-08-14 14:02:37 +02:00
commit 39c171a61d
53 changed files with 517 additions and 842 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -8,6 +8,7 @@ set(GLFW_VERSION_PATCH "0")
set(GLFW_VERSION_EXTRA "")
set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}")
set(GLFW_VERSION_FULL "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib will be installed: lib or lib64")
option(GLFW_BUILD_EXAMPLES "Build the GLFW example programs" ON)
option(GLFW_BUILD_TESTS "Build the GLFW test programs" ON)
@ -261,11 +262,11 @@ install(FILES COPYING.txt readme.html
# Create and install pkg-config file on supported platforms
#--------------------------------------------------------------------
if (_GLFW_X11_GLX OR _GLFW_COCOA_NSGL)
configure_file(${GLFW_SOURCE_DIR}/src/libglfw3.pc.in
${GLFW_BINARY_DIR}/src/libglfw3.pc @ONLY)
configure_file(${GLFW_SOURCE_DIR}/src/glfw3.pc.in
${GLFW_BINARY_DIR}/src/glfw3.pc @ONLY)
install(FILES ${GLFW_BINARY_DIR}/src/libglfw3.pc
DESTINATION lib/pkgconfig)
install(FILES ${GLFW_BINARY_DIR}/src/glfw3.pc
DESTINATION lib${LIB_SUFFIX}/pkgconfig)
endif()
#--------------------------------------------------------------------

5
examples/CMakeLists.txt
View File

@ -12,6 +12,9 @@ include_directories(${GLFW_SOURCE_DIR}/include
${GLFW_SOURCE_DIR}/support
${OPENGL_INCLUDE_DIR})
set(GETOPT ${GLFW_SOURCE_DIR}/support/getopt.h
${GLFW_SOURCE_DIR}/support/getopt.c)
if (APPLE)
# Set fancy names for bundles
add_executable(Boing MACOSX_BUNDLE boing.c)
@ -29,7 +32,7 @@ else()
# Set boring names for executables
add_executable(boing WIN32 boing.c)
add_executable(gears WIN32 gears.c)
add_executable(heightmap WIN32 heightmap.c getopt.c)
add_executable(heightmap WIN32 heightmap.c ${GETOPT})
add_executable(splitview WIN32 splitview.c)
add_executable(triangle WIN32 triangle.c)
add_executable(wave WIN32 wave.c)

32
examples/boing.c
View File

@ -330,7 +330,7 @@ void DrawBoingBall( void )
/*****************************************************************************
* Bounce the ball.
*****************************************************************************/
void BounceBall( double dt )
void BounceBall( double delta_t )
{
GLfloat sign;
GLfloat deg;
@ -358,8 +358,8 @@ void BounceBall( double dt )
}
/* Update ball position */
ball_x += ball_x_inc * ((float)dt*ANIMATION_SPEED);
ball_y += ball_y_inc * ((float)dt*ANIMATION_SPEED);
ball_x += ball_x_inc * ((float)delta_t*ANIMATION_SPEED);
ball_y += ball_y_inc * ((float)delta_t*ANIMATION_SPEED);
/*
* Simulate the effects of gravity on Y movement.
@ -567,8 +567,8 @@ void DrawGrid( void )
int main( void )
{
int running;
GLFWwindow window;
int width, height;
/* Init GLFW */
if( !glfwInit() )
@ -577,9 +577,11 @@ int main( void )
exit( EXIT_FAILURE );
}
glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
glfwSetWindowSizeCallback( reshape );
window = glfwOpenWindow( 400, 400, GLFW_WINDOWED, "Boing (classic Amiga demo)", NULL );
glfwWindowHint(GLFW_DEPTH_BITS, 16);
window = glfwCreateWindow( 400, 400, GLFW_WINDOWED, "Boing (classic Amiga demo)", NULL );
if (!window)
{
fprintf( stderr, "Failed to open GLFW window\n" );
@ -587,15 +589,19 @@ int main( void )
exit( EXIT_FAILURE );
}
glfwSetWindowSizeCallback( reshape );
glfwSetInputMode( window, GLFW_STICKY_KEYS, GL_TRUE );
glfwMakeContextCurrent(window);
glfwSwapInterval( 1 );
glfwGetWindowSize(window, &width, &height);
reshape(window, width, height);
glfwSetInputMode( window, GLFW_STICKY_KEYS, GL_TRUE );
glfwSetTime( 0.0 );
init();
/* Main loop */
do
for (;;)
{
/* Timing */
t = glfwGetTime();
@ -606,13 +612,15 @@ int main( void )
display();
/* Swap buffers */
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
/* Check if we are still running */
running = glfwIsWindow(window) && !glfwGetKey( window, GLFW_KEY_ESCAPE );
if (glfwGetKey( window, GLFW_KEY_ESCAPE ))
break;
if (glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
break;
}
while( running );
glfwTerminate();
exit( EXIT_SUCCESS );

37
examples/gears.c
View File

@ -267,6 +267,14 @@ void reshape( GLFWwindow window, int width, int height )
}
/* close callback */
static int window_close_callback(GLFWwindow window)
{
running = 0;
return GL_TRUE;
}
/* program & OpenGL initialization */
static void init(int argc, char *argv[])
{
@ -322,6 +330,7 @@ static void init(int argc, char *argv[])
int main(int argc, char *argv[])
{
GLFWwindow window;
int width, height;
if( !glfwInit() )
{
@ -329,9 +338,14 @@ int main(int argc, char *argv[])
exit( EXIT_FAILURE );
}
glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
// Set callback functions
glfwSetWindowCloseCallback(window_close_callback);
glfwSetWindowSizeCallback( reshape );
glfwSetKeyCallback( key );
window = glfwOpenWindow( 300, 300, GLFW_WINDOWED, "Gears", NULL );
glfwWindowHint(GLFW_DEPTH_BITS, 16);
window = glfwCreateWindow( 300, 300, GLFW_WINDOWED, "Gears", NULL );
if (!window)
{
fprintf( stderr, "Failed to open GLFW window\n" );
@ -339,16 +353,17 @@ int main(int argc, char *argv[])
exit( EXIT_FAILURE );
}
glfwSetInputMode( window, GLFW_KEY_REPEAT, GL_TRUE );
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);
// Set callback functions
glfwSetWindowSizeCallback( reshape );
glfwSetKeyCallback( key );
// Main loop
while( running )
{
@ -359,14 +374,8 @@ int main(int argc, char *argv[])
animate();
// Swap buffers
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
// Was the window closed?
if( !glfwIsWindow( window ) )
{
running = 0;
}
}
// Terminate GLFW

18
examples/heightmap.c
View File

@ -581,13 +581,13 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
glfwOpenWindowHint(GLFW_WINDOW_RESIZABLE, GL_FALSE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE);
glfwWindowHint(GLFW_WINDOW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE);
window = glfwOpenWindow(800, 600, GLFW_WINDOWED, "GLFW OpenGL3 Heightmap demo", NULL);
window = glfwCreateWindow(800, 600, GLFW_WINDOWED, "GLFW OpenGL3 Heightmap demo", NULL);
if (! window )
{
fprintf(stderr, "ERROR: Unable to create the OpenGL context and associated window\n");
@ -597,10 +597,12 @@ int main(int argc, char** argv)
free(fragment_shader_src);
exit(EXIT_FAILURE);
}
/* Register events callback */
glfwSetWindowCloseCallback(window_close_callback);
glfwSetKeyCallback(key_callback);
/* Register events callback */
glfwMakeContextCurrent(window);
if (GL_TRUE != init_opengl())
{
fprintf(stderr, "ERROR: unable to resolve OpenGL function pointers\n");
@ -663,7 +665,7 @@ int main(int argc, char** argv)
glDrawElements(GL_LINES, 2* MAP_NUM_LINES , GL_UNSIGNED_INT, 0);
/* display and process events through callbacks */
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
/* Check the frame rate and update the heightmap if needed */
dt = glfwGetTime();

2
examples/particles.c
View File

@ -1028,7 +1028,7 @@ int main( int argc, char **argv )
}
// Open OpenGL fullscreen window
if( !glfwOpenWindow( WIDTH, HEIGHT, 0,0,0,0, 16,0, GLFW_FULLSCREEN ) )
if( !glfwCreateWindow( WIDTH, HEIGHT, 0,0,0,0, 16,0, GLFW_FULLSCREEN ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();

2
examples/pong3d.c
View File

@ -810,7 +810,7 @@ int main( void )
}
// Open OpenGL window
if( !glfwOpenWindow( WIDTH, HEIGHT, 0,0,0,0, 16,0, GLFW_FULLSCREEN ) )
if( !glfwCreateWindow( WIDTH, HEIGHT, 0,0,0,0, 16,0, GLFW_FULLSCREEN ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();

33
examples/splitview.c
View File

@ -450,10 +450,16 @@ int main(void)
exit(EXIT_FAILURE);
}
glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
// Set callback functions
glfwSetWindowSizeCallback(windowSizeFun);
glfwSetWindowRefreshCallback(windowRefreshFun);
glfwSetCursorPosCallback(cursorPosFun);
glfwSetMouseButtonCallback(mouseButtonFun);
glfwWindowHint(GLFW_DEPTH_BITS, 16);
// Open OpenGL window
window = glfwOpenWindow(500, 500, GLFW_WINDOWED, "Split view demo", NULL);
window = glfwCreateWindow(500, 500, GLFW_WINDOWED, "Split view demo", NULL);
if (!window)
{
fprintf(stderr, "Failed to open GLFW window\n");
@ -461,22 +467,20 @@ int main(void)
}
// Enable vsync
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwGetWindowSize(window, &width, &height);
windowSizeFun(window, width, height);
// Enable sticky keys
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
// Enable mouse cursor (only needed for fullscreen mode)
glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL);
// Set callback functions
glfwSetWindowSizeCallback(windowSizeFun);
glfwSetWindowRefreshCallback(windowRefreshFun);
glfwSetCursorPosCallback(cursorPosFun);
glfwSetMouseButtonCallback(mouseButtonFun);
// Main loop
do
for (;;)
{
// Only redraw if we need to
if (do_redraw)
@ -485,7 +489,7 @@ int main(void)
drawAllViews();
// Swap buffers
glfwSwapBuffers();
glfwSwapBuffers(window);
do_redraw = 0;
}
@ -493,9 +497,12 @@ int main(void)
// Wait for new events
glfwWaitEvents();
} // Check if the ESC key was pressed or the window was closed
while (glfwIsWindow(window) &&
glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS);
// Check if the ESC key was pressed or the window should be closed
if (glfwGetKey(window, GLFW_KEY_ESCAPE))
break;
if (glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
break;
}
// Close OpenGL window and terminate GLFW
glfwTerminate();

22
examples/triangle.c
View File

@ -23,20 +23,21 @@ int main(void)
}
// Open a window and create its OpenGL context
window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Spinning Triangle", NULL);
window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Spinning Triangle", NULL);
if (!window)
{
fprintf(stderr, "Failed to open GLFW window\n");
exit(EXIT_FAILURE);
}
// Enable vertical sync (on cards that support it)
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
// Ensure we can capture the escape key being pressed below
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
// Enable vertical sync (on cards that support it)
glfwSwapInterval(1);
do
for (;;)
{
double t = glfwGetTime();
glfwGetCursorPos(window, &x, NULL);
@ -79,12 +80,15 @@ int main(void)
glEnd();
// Swap buffers
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
} // Check if the ESC key was pressed or the window was closed
while (glfwIsWindow(window) &&
glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS);
// Check if the ESC key was pressed or the window should be closed
if (glfwGetKey(window, GLFW_KEY_ESCAPE))
break;
if (glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
break;
}
// Close OpenGL window and terminate GLFW
glfwTerminate();

44
examples/wave.c
View File

@ -145,7 +145,7 @@ void init_grid(void)
// Draw scene
//========================================================================
void draw_scene(void)
void draw_scene(GLFWwindow window)
{
// Clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@ -162,7 +162,7 @@ void draw_scene(void)
glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad);
glfwSwapBuffers();
glfwSwapBuffers(window);
}
@ -355,7 +355,7 @@ void scroll_callback(GLFWwindow window, double x, double y)
// Callback function for window resize events
//========================================================================
void window_resize_callback(GLFWwindow window, int width, int height)
void window_size_callback(GLFWwindow window, int width, int height)
{
float ratio = 1.f;
@ -372,6 +372,17 @@ void window_resize_callback(GLFWwindow window, int width, int height)
}
//========================================================================
// Callback function for window close events
//========================================================================
static int window_close_callback(GLFWwindow window)
{
running = GL_FALSE;
return GL_TRUE;
}
//========================================================================
// main
//========================================================================
@ -380,6 +391,7 @@ int main(int argc, char* argv[])
{
GLFWwindow window;
double t, dt_total, t_old;
int width, height;
if (!glfwInit())
{
@ -387,24 +399,27 @@ int main(int argc, char* argv[])
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL);
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)
{
fprintf(stderr, "Could not open window\n");
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
// Keyboard handler
glfwSetKeyCallback(key_callback);
glfwSetInputMode(window, GLFW_KEY_REPEAT, GL_TRUE);
glfwGetWindowSize(window, &width, &height);
window_size_callback(window, width, height);
// Window resize handler
glfwSetWindowSizeCallback(window_resize_callback);
glfwSetMouseButtonCallback(mouse_button_callback);
glfwSetCursorPosCallback(cursor_position_callback);
glfwSetScrollCallback(scroll_callback);
glfwSetInputMode(window, GLFW_KEY_REPEAT, GL_TRUE);
// Initialize OpenGL
init_opengl();
@ -438,12 +453,9 @@ int main(int argc, char* argv[])
adjust_grid();
// Draw wave grid to OpenGL display
draw_scene();
draw_scene(window);
glfwPollEvents();
// Still running?
running = running && glfwIsWindow(window);
}
exit(EXIT_SUCCESS);

20
include/GL/glfw3.h
View File

@ -381,18 +381,17 @@ extern "C" {
* Other definitions
*************************************************************************/
/* glfwOpenWindow modes */
/* glfwCreateWindow modes */
#define GLFW_WINDOWED 0x00010001
#define GLFW_FULLSCREEN 0x00010002
/* glfwGetWindowParam tokens */
#define GLFW_ACTIVE 0x00020001
#define GLFW_ICONIFIED 0x00020002
#define GLFW_CLOSE_REQUESTED 0x00020003
#define GLFW_OPENGL_REVISION 0x00020004
/* The following constants are used for both glfwGetWindowParam
* and glfwOpenWindowHint
*/
/* glfwWindowHint tokens */
#define GLFW_RED_BITS 0x00021000
#define GLFW_GREEN_BITS 0x00021001
#define GLFW_BLUE_BITS 0x00021002
@ -408,6 +407,10 @@ extern "C" {
#define GLFW_STEREO 0x0002100C
#define GLFW_WINDOW_RESIZABLE 0x0002100D
#define GLFW_FSAA_SAMPLES 0x0002100E
/* The following constants are used with both glfwGetWindowParam
* and glfwWindowHint
*/
#define GLFW_OPENGL_VERSION_MAJOR 0x0002100F
#define GLFW_OPENGL_VERSION_MINOR 0x00021010
#define GLFW_OPENGL_FORWARD_COMPAT 0x00021011
@ -552,10 +555,9 @@ GLFWAPI void glfwGetGammaRamp(GLFWgammaramp* ramp);
GLFWAPI void glfwSetGammaRamp(const GLFWgammaramp* ramp);
/* Window handling */
GLFWAPI GLFWwindow glfwOpenWindow(int width, int height, int mode, const char* title, GLFWwindow share);
GLFWAPI void glfwOpenWindowHint(int target, int hint);
GLFWAPI int glfwIsWindow(GLFWwindow window);
GLFWAPI void glfwCloseWindow(GLFWwindow window);
GLFWAPI void glfwWindowHint(int target, int hint);
GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, int mode, const char* title, GLFWwindow share);
GLFWAPI void glfwDestroyWindow(GLFWwindow window);
GLFWAPI void glfwSetWindowTitle(GLFWwindow, const char* title);
GLFWAPI void glfwGetWindowSize(GLFWwindow, int* width, int* height);
GLFWAPI void glfwSetWindowSize(GLFWwindow, int width, int height);
@ -607,7 +609,7 @@ GLFWAPI void glfwSetTime(double time);
/* OpenGL support */
GLFWAPI void glfwMakeContextCurrent(GLFWwindow window);
GLFWAPI GLFWwindow glfwGetCurrentContext(void);
GLFWAPI void glfwSwapBuffers(void);
GLFWAPI void glfwSwapBuffers(GLFWwindow window);
GLFWAPI void glfwSwapInterval(int interval);
GLFWAPI int glfwExtensionSupported(const char* extension);
GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname);

8
readme.html
View File

@ -268,7 +268,6 @@ 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>glfwIsWindow</code> function for verifying that a given window handle is (still) valid</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>
@ -288,25 +287,27 @@ version of GLFW.</p>
<li>Added <code>sharing</code> simple OpenGL object sharing test program</li>
<li>Added <code>modes</code> video mode enumeration and setting test program</li>
<li>Added <code>glfw3native.h</code> header and platform-specific functions for explicit access to native display, window and context handles</li>
<li>Added a parameter to <code>glfwOpenWindow</code> for specifying a context the new window's context will share objects with</li>
<li>Added initial window title parameter to <code>glfwOpenWindow</code></li>
<li>Added <code>glfwSetGamma</code>, <code>glfwSetGammaRamp</code> and <code>glfwGetGammaRamp</code> functions and <code>GLFWgammaramp</code> type for monitor gamma ramp control</li>
<li>Added window parameter to <code>glfwSwapBuffers</code></li>
<li>Changed buffer bit depth parameters of <code>glfwOpenWindow</code> to window hints</li>
<li>Changed <code>glfwOpenWindow</code> and <code>glfwSetWindowTitle</code> to use UTF-8 encoded strings</li>
<li>Changed <code>glfwGetProcAddress</code> to return a (generic) function pointer</li>
<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_WINDOW</code> token to <code>GLFW_WINDOWED</code></li>
<li>Renamed <code>GLFW_WINDOW_NO_RESIZE</code> to <code>GLFW_WINDOW_RESIZABLE</code></li>
<li>Renamed <code>GLFW_BUILD_DLL</code> to <code>_GLFW_BUILD_DLL</code></li>
<li>Renamed <code>version</code> test to <code>glfwinfo</code></li>
<li>Renamed <code>GLFW_NO_GLU</code> to <code>GLFW_INCLUDE_GLU</code> and made it disabled by default</li>
<li>Renamed mouse position functions to cursor position equivalents</li>
<li>Replaced <code>glfwOpenWindow</code> and <code>glfwCloseWindow</code> with <code>glfwCreateWindow</code> and <code>glfwDestroyWindow</code></li>
<li>Replaced ad hoc build system with CMake</li>
<li>Replaced layout-dependent key codes with single, platform-independent set based on US layout</li>
<li>Replaced mouse wheel interface with two-dimensional, floating point scrolling interface</li>
<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 event auto-polling and the <code>GLFW_AUTO_POLL_EVENTS</code> window enable</li>
<li>Removed the Win32 port .def files</li>
@ -320,6 +321,7 @@ version of GLFW.</p>
<li>Removed nonsensical key actions for Unicode character input</li>
<li>Removed <code>GLFWCALL</code> and <code>GLFWAPIENTRY</code> macros for stdcall calling convention</li>
<li>Removed <code>GLFW_ACCELERATED</code> window parameter</li>
<li>Removed default framebuffer attributes from <code>glfwGetWindowParam</code></li>
<li>Bugfix: The default OpenGL version in the <code>glfwinfo</code> test was set to 1.1</li>
<li>Bugfix: The OpenGL profile and forward-compatibility window parameters were not saved after context creation</li>
<li>Bugfix: The FSAA test did not check for the availability of <code>GL_ARB_multisample</code></li>

3
src/CMakeLists.txt
View File

@ -1,4 +1,3 @@
include_directories(${GLFW_SOURCE_DIR}/src
${GLFW_BINARY_DIR}/src
${glfw_INCLUDE_DIRS})
@ -59,5 +58,5 @@ if (BUILD_SHARED_LIBS)
target_link_libraries(glfw LINK_INTERFACE_LIBRARIES)
endif()
install(TARGETS glfw DESTINATION lib)
install(TARGETS glfw DESTINATION lib${LIB_SUFFIX} )

4
src/cocoa_opengl.m
View File

@ -51,10 +51,8 @@ void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
// Swap buffers
//========================================================================
void _glfwPlatformSwapBuffers(void)
void _glfwPlatformSwapBuffers(_GLFWwindow* window)
{
_GLFWwindow* window = _glfwLibrary.currentWindow;
// ARP appears to be unnecessary, but this is future-proof
[window->NSGL.context flushBuffer];
}

21
src/cocoa_window.m
View File

@ -59,8 +59,7 @@
- (BOOL)windowShouldClose:(id)sender
{
window->closeRequested = GL_TRUE;
_glfwInputWindowCloseRequest(window);
return NO;
}
@ -127,7 +126,7 @@
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
window->closeRequested = GL_TRUE;
_glfwInputWindowCloseRequest(window);
return NSTerminateCancel;
}
@ -860,15 +859,13 @@ static GLboolean createContext(_GLFWwindow* window,
// created
//========================================================================
int _glfwPlatformOpenWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
{
if (!initializeAppKit())
return GL_FALSE;
window->resizable = wndconfig->resizable;
// We can only have one application delegate, but we only allocate it the
// first time we create a window to keep all window code in this file
if (_glfwLibrary.NS.delegate == nil)
@ -928,14 +925,10 @@ int _glfwPlatformOpenWindow(_GLFWwindow* window,
withOptions:nil];
}
glfwMakeContextCurrent(window);
NSPoint point = [[NSCursor currentCursor] hotSpot];
window->cursorPosX = point.x;
window->cursorPosY = point.y;
window->resizable = wndconfig->resizable;
return GL_TRUE;
}
@ -944,7 +937,7 @@ int _glfwPlatformOpenWindow(_GLFWwindow* window,
// Properly kill the window / video display
//========================================================================
void _glfwPlatformCloseWindow(_GLFWwindow* window)
void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
[window->NS.object orderOut:nil];
@ -1041,7 +1034,7 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
// Write back window parameters into GLFW window structure
//========================================================================
void _glfwPlatformRefreshWindowParams(void)
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window)
{
}

2
src/error.c
View File

@ -59,8 +59,6 @@ void _glfwSetError(int error, const char* format, ...)
char buffer[16384];
const char* description;
// We would use vasprintf here if msvcrt supported it
if (format)
{
int count;

1
src/fullscreen.c
View File

@ -31,6 +31,7 @@
#include "internal.h"
#include <stdlib.h>
#include <malloc.h>
//========================================================================

0
src/libglfw3.pc.in → src/glfw3.pc.in
View File

2
src/init.c
View File

@ -79,7 +79,7 @@ GLFWAPI void glfwTerminate(void)
// Close all remaining windows
while (_glfwLibrary.windowListHead)
glfwCloseWindow(_glfwLibrary.windowListHead);
glfwDestroyWindow(_glfwLibrary.windowListHead);
if (!_glfwPlatformTerminate())
return;

10
src/input.c
View File

@ -551,16 +551,6 @@ GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun)
}
_glfwLibrary.cursorPosCallback = cbfun;
// Call the callback function to let the application know the current
// cursor position
if (cbfun)
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
cbfun(window, window->cursorPosX, window->cursorPosY);
}
}

28
src/internal.h
View File

@ -89,10 +89,10 @@ typedef struct _GLFWmonitor _GLFWmonitor;
//------------------------------------------------------------------------
// Window hints, set by glfwOpenWindowHint and consumed by glfwOpenWindow
// Window hints, set by glfwWindowHint and consumed by glfwCreateWindow
// A bucket of semi-random stuff lumped together for historical reasons
// This is used only by the platform independent code and only to store
// parameters passed to us by glfwOpenWindowHint
// parameters passed to us by glfwWindowHint
//------------------------------------------------------------------------
struct _GLFWhints
{
@ -196,21 +196,6 @@ struct _GLFWwindow
char mouseButton[GLFW_MOUSE_BUTTON_LAST + 1];
char key[GLFW_KEY_LAST + 1];
// Framebuffer attributes
GLint redBits;
GLint greenBits;
GLint blueBits;
GLint alphaBits;
GLint depthBits;
GLint stencilBits;
GLint accumRedBits;
GLint accumGreenBits;
GLint accumBlueBits;
GLint accumAlphaBits;
GLint auxBuffers;
GLboolean stereo;
GLint samples;
// OpenGL extensions and context attributes
int glMajor, glMinor, glRevision;
GLboolean glForward, glDebug;
@ -335,8 +320,8 @@ double _glfwPlatformGetTime(void);
void _glfwPlatformSetTime(double time);
// Window management
int _glfwPlatformOpenWindow(_GLFWwindow* window, const _GLFWwndconfig* wndconfig, const _GLFWfbconfig* fbconfig);
void _glfwPlatformCloseWindow(_GLFWwindow* window);
int _glfwPlatformCreateWindow(_GLFWwindow* window, const _GLFWwndconfig* wndconfig, const _GLFWfbconfig* fbconfig);
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);
@ -349,9 +334,9 @@ void _glfwPlatformWaitEvents(void);
// OpenGL context management
void _glfwPlatformMakeContextCurrent(_GLFWwindow* window);
void _glfwPlatformSwapBuffers(void);
void _glfwPlatformSwapBuffers(_GLFWwindow* window);
void _glfwPlatformSwapInterval(int interval);
void _glfwPlatformRefreshWindowParams(void);
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window);
int _glfwPlatformExtensionSupported(const char* extension);
GLFWglproc _glfwPlatformGetProcAddress(const char* procname);
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask);
@ -377,6 +362,7 @@ void _glfwInputWindowPos(_GLFWwindow* window, int x, int y);
void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);
void _glfwInputWindowDamage(_GLFWwindow* window);
void _glfwInputWindowCloseRequest(_GLFWwindow* window);
// Input event notification (input.c)
void _glfwInputKey(_GLFWwindow* window, int key, int action);

61
src/opengl.c
View File

@ -244,7 +244,7 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
//========================================================================
// Checks whether the OpenGL part of the window config is sane
// It blames glfwOpenWindow because that's the only caller
// It blames glfwCreateWindow because that's the only caller
//========================================================================
GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
@ -253,28 +253,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
@ -292,7 +292,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
// everything 2.x and let the driver report invalid 2.x versions
_glfwSetError(GLFW_INVALID_VALUE,
"glfwOpenWindow: Invalid OpenGL ES 2.x version requested");
"glfwCreateWindow: Invalid OpenGL ES 2.x version requested");
return GL_FALSE;
}
}
@ -302,7 +302,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;
}
@ -313,7 +313,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;
}
@ -323,7 +323,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 for "
"glfwCreateWindow: Forward compatibility only exist for "
"OpenGL version 3.0 and above");
return GL_FALSE;
}
@ -334,7 +334,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
wndconfig->glRobustness != GLFW_OPENGL_LOSE_CONTEXT_ON_RESET)
{
_glfwSetError(GLFW_INVALID_VALUE,
"glfwOpenWindow: Invalid OpenGL robustness mode requested");
"glfwCreateWindow: Invalid OpenGL robustness mode requested");
return GL_FALSE;
}
}
@ -345,7 +345,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
//========================================================================
// Reads back context properties
// It blames glfwOpenWindow because that's the only caller
// It blames glfwCreateWindow because that's the only caller
//========================================================================
GLboolean _glfwRefreshContextParams(void)
@ -369,7 +369,7 @@ GLboolean _glfwRefreshContextParams(void)
if (!window->GetStringi)
{
_glfwSetError(GLFW_PLATFORM_ERROR,
"glfwOpenWindow: Entry point retrieval is broken");
"glfwCreateWindow: Entry point retrieval is broken");
return GL_FALSE;
}
}
@ -406,34 +406,13 @@ GLboolean _glfwRefreshContextParams(void)
}
}
glGetIntegerv(GL_RED_BITS, &window->redBits);
glGetIntegerv(GL_GREEN_BITS, &window->greenBits);
glGetIntegerv(GL_BLUE_BITS, &window->blueBits);
glGetIntegerv(GL_ALPHA_BITS, &window->alphaBits);
glGetIntegerv(GL_DEPTH_BITS, &window->depthBits);
glGetIntegerv(GL_STENCIL_BITS, &window->stencilBits);
glGetIntegerv(GL_ACCUM_RED_BITS, &window->accumRedBits);
glGetIntegerv(GL_ACCUM_GREEN_BITS, &window->accumGreenBits);
glGetIntegerv(GL_ACCUM_BLUE_BITS, &window->accumBlueBits);
glGetIntegerv(GL_ACCUM_ALPHA_BITS, &window->accumAlphaBits);
glGetIntegerv(GL_AUX_BUFFERS, &window->auxBuffers);
glGetBooleanv(GL_STEREO, &window->stereo);
if (glfwExtensionSupported("GL_ARB_multisample"))
glGetIntegerv(GL_SAMPLES_ARB, &window->samples);
else
window->samples = 0;
return GL_TRUE;
}
//========================================================================
// Checks whether the current context fulfils the specified requirements
// It blames glfwOpenWindow because that's the only caller
// It blames glfwCreateWindow because that's the only caller
//========================================================================
GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
@ -452,7 +431,7 @@ GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
// {GLX|WGL}_ARB_create_context extension and fail here
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"glfwOpenWindow: The requested OpenGL version is not available");
"glfwCreateWindow: The requested OpenGL version is not available");
return GL_FALSE;
}
@ -541,21 +520,17 @@ GLFWAPI GLFWwindow glfwGetCurrentContext(void)
// Swap buffers (double-buffering)
//========================================================================
GLFWAPI void glfwSwapBuffers(void)
GLFWAPI void glfwSwapBuffers(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return;
}
if (!_glfwLibrary.currentWindow)
{
_glfwSetError(GLFW_NO_CURRENT_CONTEXT, NULL);
return;
}
_glfwPlatformSwapBuffers();
_glfwPlatformSwapBuffers(window);
}

1
src/win32_clipboard.c
View File

@ -32,6 +32,7 @@
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
//////////////////////////////////////////////////////////////////////////

1
src/win32_fullscreen.c
View File

@ -32,6 +32,7 @@
#include <stdlib.h>
#include <limits.h>
#include <malloc.h>
//========================================================================

1
src/win32_init.c
View File

@ -31,6 +31,7 @@
#include "internal.h"
#include <stdlib.h>
#include <malloc.h>
#ifdef __BORLANDC__
// With the Borland C++ compiler, we want to disable FPU exceptions

9
src/win32_opengl.c
View File

@ -30,6 +30,9 @@
#include "internal.h"
#include <stdlib.h>
#include <malloc.h>
//========================================================================
// Initialize WGL-specific extensions
@ -505,7 +508,7 @@ int _glfwCreateContext(_GLFWwindow* window,
void _glfwDestroyContext(_GLFWwindow* window)
{
// This is duplicated from glfwCloseWindow
// This is duplicated from glfwDestroyWindow
// TODO: Stop duplicating code
if (window == _glfwLibrary.currentWindow)
glfwMakeContextCurrent(NULL);
@ -545,10 +548,8 @@ void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
// Swap buffers (double-buffering)
//========================================================================
void _glfwPlatformSwapBuffers(void)
void _glfwPlatformSwapBuffers(_GLFWwindow* window)
{
_GLFWwindow* window = _glfwLibrary.currentWindow;
SwapBuffers(window->WGL.DC);
}

22
src/win32_window.c Executable file → Normal file
View File

@ -31,6 +31,7 @@
#include "internal.h"
#include <stdlib.h>
#include <malloc.h>
//========================================================================
@ -531,8 +532,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
case WM_CLOSE:
{
// Flag this window for closing (handled in glfwPollEvents)
window->closeRequested = GL_TRUE;
_glfwInputWindowCloseRequest(window);
return 0;
}
@ -895,7 +895,7 @@ static int createWindow(_GLFWwindow* window,
if (!wideTitle)
{
_glfwSetError(GLFW_PLATFORM_ERROR,
"glfwOpenWindow: Failed to convert title to wide string");
"glfwCreateWindow: Failed to convert title to wide string");
return GL_FALSE;
}
@ -940,7 +940,7 @@ static void destroyWindow(_GLFWwindow* window)
{
_glfwDestroyContext(window);
// This is duplicated from glfwCloseWindow
// This is duplicated from glfwDestroyWindow
// TODO: Stop duplicating code
if (window == _glfwLibrary.activeWindow)
_glfwLibrary.activeWindow = NULL;
@ -962,14 +962,13 @@ static void destroyWindow(_GLFWwindow* window)
// created
//========================================================================
int _glfwPlatformOpenWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
{
GLboolean recreateContext = GL_FALSE;
window->Win32.desiredRefreshRate = wndconfig->refreshRate;
window->resizable = wndconfig->resizable;
if (!_glfwLibrary.Win32.classAtom)
{
@ -1092,7 +1091,7 @@ int _glfwPlatformOpenWindow(_GLFWwindow* window,
// Properly kill the window / video display
//========================================================================
void _glfwPlatformCloseWindow(_GLFWwindow* window)
void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
destroyWindow(window);
@ -1207,10 +1206,9 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
// Write back window parameters into GLFW window structure
//========================================================================
void _glfwPlatformRefreshWindowParams(void)
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window)
{
DEVMODE dm;
_GLFWwindow* window = _glfwLibrary.currentWindow;
ZeroMemory(&dm, sizeof(DEVMODE));
dm.dmSize = sizeof(DEVMODE);
@ -1259,7 +1257,7 @@ void _glfwPlatformPollEvents(void)
window = _glfwLibrary.windowListHead;
while (window)
{
window->closeRequested = GL_TRUE;
_glfwInputWindowCloseRequest(window);
window = window->next;
}

159
src/window.c
View File

@ -32,6 +32,7 @@
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
//========================================================================
@ -44,31 +45,6 @@ static int Max(int a, int b)
}
//========================================================================
// Close all GLFW windows with the closed flag set
//========================================================================
static void closeFlaggedWindows(void)
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; )
{
if (window->closeRequested && _glfwLibrary.windowCloseCallback)
window->closeRequested = _glfwLibrary.windowCloseCallback(window);
if (window->closeRequested)
{
_GLFWwindow* next = window->next;
glfwCloseWindow(window);
window = next;
}
else
window = window->next;
}
}
//========================================================================
// Clear scroll offsets for all windows
//========================================================================
@ -206,6 +182,19 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
}
//========================================================================
// Register window close request events
//========================================================================
void _glfwInputWindowCloseRequest(_GLFWwindow* window)
{
if (_glfwLibrary.windowCloseCallback)
window->closeRequested = _glfwLibrary.windowCloseCallback(window);
else
window->closeRequested = GL_TRUE;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW public API //////
//////////////////////////////////////////////////////////////////////////
@ -214,13 +203,14 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
// Create the GLFW window and its associated context
//========================================================================
GLFWAPI GLFWwindow glfwOpenWindow(int width, int height,
int mode, const char* title,
GLFWwindow share)
GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
int mode, const char* title,
GLFWwindow share)
{
_GLFWfbconfig fbconfig;
_GLFWwndconfig wndconfig;
_GLFWwindow* window;
_GLFWwindow* previous;
if (!_glfwInitialized)
{
@ -266,10 +256,13 @@ GLFWAPI GLFWwindow glfwOpenWindow(int width, int height,
if (!_glfwIsValidContextConfig(&wndconfig))
return GL_FALSE;
// Save the currently current context so it can be restored later
previous = glfwGetCurrentContext();
if (mode != GLFW_WINDOWED && mode != GLFW_FULLSCREEN)
{
_glfwSetError(GLFW_INVALID_ENUM,
"glfwOpenWindow: Invalid enum for 'mode' parameter");
"glfwCreateWindow: Invalid enum for 'mode' parameter");
return GL_FALSE;
}
@ -295,7 +288,7 @@ GLFWAPI GLFWwindow glfwOpenWindow(int width, int height,
if (!window)
{
_glfwSetError(GLFW_OUT_OF_MEMORY,
"glfwOpenWindow: Failed to allocate window structure");
"glfwCreateWindow: Failed to allocate window structure");
return NULL;
}
@ -308,33 +301,41 @@ GLFWAPI GLFWwindow glfwOpenWindow(int width, int height,
window->width = width;
window->height = 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 (!_glfwPlatformOpenWindow(window, &wndconfig, &fbconfig))
if (!_glfwPlatformCreateWindow(window, &wndconfig, &fbconfig))
{
glfwCloseWindow(window);
glfwDestroyWindow(window);
glfwMakeContextCurrent(previous);
return GL_FALSE;
}
// Cache the actual (as opposed to desired) window parameters
_glfwPlatformRefreshWindowParams();
// Cache the actual (as opposed to requested) window parameters
_glfwPlatformRefreshWindowParams(window);
// Cache the actual (as opposed to requested) context parameters
glfwMakeContextCurrent(window);
if (!_glfwRefreshContextParams())
{
glfwCloseWindow(window);
glfwDestroyWindow(window);
glfwMakeContextCurrent(previous);
return GL_FALSE;
}
// Verify the context against the requested parameters
if (!_glfwIsValidContext(&wndconfig))
{
glfwCloseWindow(window);
glfwDestroyWindow(window);
glfwMakeContextCurrent(previous);
return GL_FALSE;
}
// Restore the previously current context (or NULL)
glfwMakeContextCurrent(previous);
// The GLFW specification states that fullscreen windows have the cursor
// captured by default
if (mode == GLFW_FULLSCREEN)
@ -343,45 +344,17 @@ GLFWAPI GLFWwindow glfwOpenWindow(int width, int height,
// Clearing the front buffer to black to avoid garbage pixels left over
// from previous uses of our bit of VRAM
glClear(GL_COLOR_BUFFER_BIT);
_glfwPlatformSwapBuffers();
_glfwPlatformSwapBuffers(window);
return window;
}
//========================================================================
// Returns GL_TRUE if the specified window handle is an actual window
// Set hints for creating the window
//========================================================================
GLFWAPI int glfwIsWindow(GLFWwindow handle)
{
_GLFWwindow* entry;
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return GL_FALSE;
}
if (window == NULL)
return GL_FALSE;
for (entry = _glfwLibrary.windowListHead; entry; entry = entry->next)
{
if (entry == window)
return GL_TRUE;
}
return GL_FALSE;
}
//========================================================================
// Set hints for opening the window
//========================================================================
GLFWAPI void glfwOpenWindowHint(int target, int hint)
GLFWAPI void glfwWindowHint(int target, int hint)
{
if (!_glfwInitialized)
{
@ -465,7 +438,7 @@ GLFWAPI void glfwOpenWindowHint(int target, int hint)
// Properly kill the window / video display
//========================================================================
GLFWAPI void glfwCloseWindow(GLFWwindow handle)
GLFWAPI void glfwDestroyWindow(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
@ -487,7 +460,7 @@ GLFWAPI void glfwCloseWindow(GLFWwindow handle)
if (window == _glfwLibrary.activeWindow)
_glfwLibrary.activeWindow = NULL;
_glfwPlatformCloseWindow(window);
_glfwPlatformDestroyWindow(window);
// Unlink window from global linked list
{
@ -573,7 +546,7 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow handle, int width, int height)
{
// Refresh window parameters (may have changed due to changed video
// modes)
_glfwPlatformRefreshWindowParams();
_glfwPlatformRefreshWindowParams(window);
}
}
@ -665,7 +638,7 @@ GLFWAPI void glfwRestoreWindow(GLFWwindow handle)
_glfwPlatformRestoreWindow(window);
if (window->mode == GLFW_FULLSCREEN)
_glfwPlatformRefreshWindowParams();
_glfwPlatformRefreshWindowParams(window);
}
@ -689,36 +662,12 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param)
return window == _glfwLibrary.activeWindow;
case GLFW_ICONIFIED:
return window->iconified;
case GLFW_RED_BITS:
return window->redBits;
case GLFW_GREEN_BITS:
return window->greenBits;
case GLFW_BLUE_BITS:
return window->blueBits;
case GLFW_ALPHA_BITS:
return window->alphaBits;
case GLFW_DEPTH_BITS:
return window->depthBits;
case GLFW_STENCIL_BITS:
return window->stencilBits;
case GLFW_ACCUM_RED_BITS:
return window->accumRedBits;
case GLFW_ACCUM_GREEN_BITS:
return window->accumGreenBits;
case GLFW_ACCUM_BLUE_BITS:
return window->accumBlueBits;
case GLFW_ACCUM_ALPHA_BITS:
return window->accumAlphaBits;
case GLFW_AUX_BUFFERS:
return window->auxBuffers;
case GLFW_STEREO:
return window->stereo;
case GLFW_CLOSE_REQUESTED:
return window->closeRequested;
case GLFW_REFRESH_RATE:
return window->refreshRate;
case GLFW_WINDOW_RESIZABLE:
return window->resizable;
case GLFW_FSAA_SAMPLES:
return window->samples;
case GLFW_OPENGL_VERSION_MAJOR:
return window->glMajor;
case GLFW_OPENGL_VERSION_MINOR:
@ -789,16 +738,6 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
}
_glfwLibrary.windowSizeCallback = cbfun;
// Call the callback function to let the application know the current
// window size
if (cbfun)
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
cbfun(window, window->width, window->height);
}
}
@ -881,8 +820,6 @@ GLFWAPI void glfwPollEvents(void)
clearScrollOffsets();
_glfwPlatformPollEvents();
closeFlaggedWindows();
}
@ -901,7 +838,5 @@ GLFWAPI void glfwWaitEvents(void)
clearScrollOffsets();
_glfwPlatformWaitEvents();
closeFlaggedWindows();
}

2
src/x11_joystick.c
View File

@ -83,7 +83,7 @@ void _glfwInitJoysticks(void)
{
#ifdef _GLFW_USE_LINUX_JOYSTICKS
int k, n, fd, joy_count;
char* joy_base_name;
const char* joy_base_name;
char joy_dev_name[20];
int driver_version = 0x000800;
char ret_data;

5
src/x11_opengl.c
View File

@ -642,10 +642,9 @@ void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
// Swap OpenGL buffers
//========================================================================
void _glfwPlatformSwapBuffers(void)
void _glfwPlatformSwapBuffers(_GLFWwindow* window)
{
glXSwapBuffers(_glfwLibrary.X11.display,
_glfwLibrary.currentWindow->X11.handle);
glXSwapBuffers(_glfwLibrary.X11.display, window->X11.handle);
}

50
src/x11_window.c
View File

@ -43,16 +43,6 @@
#define Button6 6
#define Button7 7
//========================================================================
// Checks whether the event is a MapNotify for the specified window
//========================================================================
static Bool isMapNotify(Display* d, XEvent* e, char* arg)
{
return (e->type == MapNotify) && (e->xmap.window == (Window)arg);
}
//========================================================================
// Translates an X Window key to internal coding
//========================================================================
@ -94,7 +84,6 @@ static int translateChar(XKeyEvent* event)
static GLboolean createWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig)
{
XEvent event;
unsigned long wamask;
XSetWindowAttributes wa;
XVisualInfo* visual = _glfwGetContextVisual(window);
@ -243,8 +232,7 @@ static GLboolean createWindow(_GLFWwindow* window,
// Make sure the window is mapped before proceeding
XMapWindow(_glfwLibrary.X11.display, window->X11.handle);
XPeekIfEvent(_glfwLibrary.X11.display, &event, isMapNotify,
(char*) window->X11.handle);
XFlush(_glfwLibrary.X11.display);
return GL_TRUE;
}
@ -723,7 +711,7 @@ static void processSingleEvent(void)
// The window manager was asked to close the window, for example by
// the user pressing a 'close' window decoration button
window->closeRequested = GL_TRUE;
_glfwInputWindowCloseRequest(window);
}
else if (_glfwLibrary.X11.wmPing != None &&
(Atom) event.xclient.data.l[0] == _glfwLibrary.X11.wmPing)
@ -888,24 +876,6 @@ static void processSingleEvent(void)
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Processes all pending events
//========================================================================
void _glfwProcessPendingEvents(void)
{
int i, count = XPending(_glfwLibrary.X11.display);
for (i = 0; i < count; i++)
processSingleEvent();
}
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
@ -915,12 +885,11 @@ void _glfwProcessPendingEvents(void)
// the OpenGL rendering context is created
//========================================================================
int _glfwPlatformOpenWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
{
window->refreshRate = wndconfig->refreshRate;
window->resizable = wndconfig->resizable;
if (!_glfwCreateContext(window, wndconfig, fbconfig))
return GL_FALSE;
@ -943,9 +912,6 @@ int _glfwPlatformOpenWindow(_GLFWwindow* window,
enterFullscreenMode(window);
}
// Process the window map event and any other that may have arrived
_glfwProcessPendingEvents();
// Retrieve and set initial cursor position
{
Window cursorWindow, cursorRoot;
@ -974,7 +940,7 @@ int _glfwPlatformOpenWindow(_GLFWwindow* window,
// Properly kill the window/video display
//========================================================================
void _glfwPlatformCloseWindow(_GLFWwindow* window)
void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (window->mode == GLFW_FULLSCREEN)
leaveFullscreenMode(window);
@ -1138,10 +1104,8 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
// Read back framebuffer parameters from the context
//========================================================================
void _glfwPlatformRefreshWindowParams(void)
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window)
{
_GLFWwindow* window = _glfwLibrary.currentWindow;
// Retrieve refresh rate if possible
if (_glfwLibrary.X11.RandR.available)
{

8
examples/getopt.c → support/getopt.c
View File

@ -41,7 +41,10 @@
#include <string.h>
#include "getopt.h"
/* 2012-08-12 Lambert Clara <lambert.clara@yahoo.fr>
*
* Constify third argument of getopt.
*/
/* 2011-07-27 Camilla Berglund <elmindreda@elmindreda.org>
*
* Added _CRT_SECURE_NO_WARNINGS macro.
@ -51,7 +54,6 @@
* Removed unused global static variable 'ID'.
*/
char* optarg = NULL;
int optind = 0;
int opterr = 1;
@ -103,7 +105,7 @@ static int permute_argv_once()
}
int getopt(int argc, char** argv, char* optstr)
int getopt(int argc, char** argv, const char* optstr)
{
int c = 0;

2
examples/getopt.h → support/getopt.h
View File

@ -48,7 +48,7 @@ extern int optind;
extern int opterr;
extern int optopt;
int getopt(int argc, char** argv, char* optstr);
int getopt(int argc, char** argv, const char* optstr);
#ifdef __cplusplus

15
tests/CMakeLists.txt
View File

@ -12,16 +12,19 @@ include_directories(${GLFW_SOURCE_DIR}/include
${GLFW_SOURCE_DIR}/support
${OPENGL_INCLUDE_DIR})
add_executable(clipboard clipboard.c getopt.c)
set(GETOPT ${GLFW_SOURCE_DIR}/support/getopt.h
${GLFW_SOURCE_DIR}/support/getopt.c)
add_executable(clipboard clipboard.c ${GETOPT})
add_executable(defaults defaults.c)
add_executable(events events.c)
add_executable(fsaa fsaa.c getopt.c)
add_executable(fsaa fsaa.c ${GETOPT})
add_executable(fsfocus fsfocus.c)
add_executable(gamma gamma.c getopt.c)
add_executable(glfwinfo glfwinfo.c getopt.c)
add_executable(iconify iconify.c getopt.c)
add_executable(gamma gamma.c ${GETOPT})
add_executable(glfwinfo glfwinfo.c ${GETOPT})
add_executable(iconify iconify.c ${GETOPT})
add_executable(joysticks joysticks.c)
add_executable(modes modes.c getopt.c)
add_executable(modes modes.c ${GETOPT})
add_executable(peter peter.c)
add_executable(reopen reopen.c)

39
tests/accuracy.c
View File

@ -37,6 +37,19 @@
static int cursor_x = 0, cursor_y = 0;
static int window_width = 640, window_height = 480;
static int swap_interval = 1;
static void set_swap_interval(GLFWwindow window, int interval)
{
char title[256];
swap_interval = interval;
glfwSwapInterval(swap_interval);
sprintf(title, "Cursor Inaccuracy Detector (interval %i)", swap_interval);
glfwSetWindowTitle(window, title);
}
static void window_size_callback(GLFWwindow window, int width, int height)
{
@ -56,9 +69,16 @@ static void cursor_position_callback(GLFWwindow window, int x, int y)
cursor_y = y;
}
static void key_callback(GLFWwindow window, int key, int action)
{
if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
set_swap_interval(window, 1 - swap_interval);
}
int main(void)
{
GLFWwindow window;
int width, height;
if (!glfwInit())
{
@ -66,7 +86,11 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(window_width, window_height, GLFW_WINDOWED, "Cursor Inaccuracy Detector", NULL);
glfwSetCursorPosCallback(cursor_position_callback);
glfwSetWindowSizeCallback(window_size_callback);
glfwSetKeyCallback(key_callback);
window = glfwCreateWindow(window_width, window_height, GLFW_WINDOWED, "", NULL);
if (!window)
{
glfwTerminate();
@ -75,11 +99,14 @@ int main(void)
exit(EXIT_FAILURE);
}
glfwSetCursorPosCallback(cursor_position_callback);
glfwSetWindowSizeCallback(window_size_callback);
glfwSwapInterval(1);
glfwMakeContextCurrent(window);
while (glfwIsWindow(window))
glfwGetWindowSize(window, &width, &height);
window_size_callback(window, width, height);
set_swap_interval(window, swap_interval);
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
@ -90,7 +117,7 @@ int main(void)
glVertex2f((GLfloat) cursor_x, (GLfloat) window_height);
glEnd();
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
}

10
tests/clipboard.c
View File

@ -53,7 +53,7 @@ static void key_callback(GLFWwindow window, int key, int action)
switch (key)
{
case GLFW_KEY_ESCAPE:
glfwCloseWindow(window);
glfwDestroyWindow(window);
break;
case GLFW_KEY_V:
@ -117,7 +117,7 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Clipboard Test", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Clipboard Test", NULL);
if (!window)
{
glfwTerminate();
@ -126,7 +126,9 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetKeyCallback(key_callback);
glfwSetWindowSizeCallback(size_callback);
@ -136,14 +138,14 @@ int main(int argc, char** argv)
glClearColor(0.5f, 0.5f, 0.5f, 0);
while (glfwIsWindow(window))
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.8f, 0.2f, 0.4f);
glRectf(-0.5f, -0.5f, 0.5f, 0.5f);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwWaitEvents();
}

67
tests/defaults.c
View File

@ -30,6 +30,7 @@
//========================================================================
#include <GL/glfw3.h>
#include <GL/glext.h>
#include <stdio.h>
#include <stdlib.h>
@ -37,30 +38,38 @@
typedef struct
{
int param;
char* name;
} Param;
const char* ext;
const char* name;
} ParamGL;
static Param parameters[] =
typedef struct
{
int param;
const char* name;
} ParamGLFW;
static ParamGL gl_params[] =
{
{ GL_RED_BITS, NULL, "red bits" },
{ GL_GREEN_BITS, NULL, "green bits" },
{ GL_BLUE_BITS, NULL, "blue bits" },
{ GL_ALPHA_BITS, NULL, "alpha bits" },
{ GL_DEPTH_BITS, NULL, "depth bits" },
{ GL_STENCIL_BITS, NULL, "stencil bits" },
{ GL_STEREO, NULL, "stereo" },
{ GL_SAMPLES_ARB, "GL_ARB_multisample", "FSAA samples" },
{ 0, NULL, NULL }
};
static ParamGLFW glfw_params[] =
{
{ GLFW_RED_BITS, "red bits" },
{ GLFW_GREEN_BITS, "green bits" },
{ GLFW_BLUE_BITS, "blue bits" },
{ GLFW_ALPHA_BITS, "alpha bits" },
{ GLFW_DEPTH_BITS, "depth bits" },
{ GLFW_STENCIL_BITS, "stencil bits" },
{ GLFW_REFRESH_RATE, "refresh rate" },
{ GLFW_ACCUM_RED_BITS, "accum red bits" },
{ GLFW_ACCUM_GREEN_BITS, "accum green bits" },
{ GLFW_ACCUM_BLUE_BITS, "accum blue bits" },
{ GLFW_ACCUM_ALPHA_BITS, "accum alpha bits" },
{ GLFW_AUX_BUFFERS, "aux buffers" },
{ GLFW_STEREO, "stereo" },
{ GLFW_FSAA_SAMPLES, "FSAA samples" },
{ GLFW_OPENGL_VERSION_MAJOR, "OpenGL major" },
{ GLFW_OPENGL_VERSION_MINOR, "OpenGL minor" },
{ GLFW_OPENGL_FORWARD_COMPAT, "OpenGL forward compatible" },
{ GLFW_OPENGL_DEBUG_CONTEXT, "OpenGL debug context" },
{ GLFW_OPENGL_PROFILE, "OpenGL profile" },
{ 0, NULL }
};
int main(void)
@ -74,7 +83,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Defaults", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Defaults", NULL);
if (!window)
{
glfwTerminate();
@ -83,18 +92,34 @@ int main(void)
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwGetWindowSize(window, &width, &height);
printf("window size: %ix%i\n", width, height);
for (i = 0; (size_t) i < sizeof(parameters) / sizeof(parameters[0]); i++)
for (i = 0; glfw_params[i].name; i++)
{
printf("%s: %i\n",
parameters[i].name,
glfwGetWindowParam(window, parameters[i].param));
glfw_params[i].name,
glfwGetWindowParam(window, glfw_params[i].param));
}
glfwCloseWindow(window);
for (i = 0; gl_params[i].name; i++)
{
GLint value = 0;
if (gl_params[i].ext)
{
if (!glfwExtensionSupported(gl_params[i].ext))
continue;
}
glGetIntegerv(gl_params[i].param, &value);
printf("%s: %i\n", gl_params[i].name, value);
}
glfwDestroyWindow(window);
window = NULL;
glfwTerminate();

15
tests/events.c
View File

@ -40,9 +40,12 @@
#include <ctype.h>
#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
static unsigned int counter = 0;
static const char* get_key_name(int key)
@ -244,6 +247,7 @@ static void window_size_callback(GLFWwindow window, int width, int height)
static int window_close_callback(GLFWwindow window)
{
printf("%08x at %0.3f: Window close\n", counter++, glfwGetTime());
return closeable;
}
@ -252,7 +256,7 @@ static void window_refresh_callback(GLFWwindow window)
printf("%08x at %0.3f: Window refresh\n", counter++, glfwGetTime());
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(window);
}
static void window_focus_callback(GLFWwindow window, int activated)
@ -367,6 +371,7 @@ void monitor_callback(GLFWmonitor monitor, int event)
int main(void)
{
GLFWwindow window;
int width, height;
setlocale(LC_ALL, "");
@ -391,7 +396,7 @@ int main(void)
glfwSetCharCallback(char_callback);
glfwSetMonitorDeviceCallback(monitor_callback);
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL);
if (!window)
{
glfwTerminate();
@ -402,14 +407,18 @@ int main(void)
printf("Window opened\n");
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwGetWindowSize(window, &width, &height);
printf("Window size should be %ix%i\n", width, height);
printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled");
printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled");
printf("Main loop starting\n");
while (glfwIsWindow(window) == GL_TRUE)
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
glfwWaitEvents();
glfwTerminate();

15
tests/fsaa.c
View File

@ -96,9 +96,9 @@ int main(int argc, char** argv)
glfwSetKeyCallback(key_callback);
glfwSetWindowSizeCallback(window_size_callback);
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, samples);
glfwWindowHint(GLFW_FSAA_SAMPLES, samples);
window = glfwOpenWindow(800, 400, GLFW_WINDOWED, "Aliasing Detector", NULL);
window = glfwCreateWindow(800, 400, GLFW_WINDOWED, "Aliasing Detector", NULL);
if (!window)
{
glfwTerminate();
@ -107,6 +107,9 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
if (!glfwExtensionSupported("GL_ARB_multisample"))
{
glfwTerminate();
@ -115,9 +118,7 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
glfwSwapInterval(1);
samples = glfwGetWindowParam(window, GLFW_FSAA_SAMPLES);
glGetIntegerv(GL_SAMPLES_ARB, &samples);
if (samples)
printf("Context reports FSAA is available with %i samples\n", samples);
else
@ -127,7 +128,7 @@ int main(int argc, char** argv)
gluOrtho2D(0.f, 1.f, 0.f, 0.5f);
glMatrixMode(GL_MODELVIEW);
while (glfwIsWindow(window))
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
GLfloat time = (GLfloat) glfwGetTime();
@ -147,7 +148,7 @@ int main(int argc, char** argv)
glEnable(GL_MULTISAMPLE_ARB);
glRectf(-0.15f, -0.15f, 0.15f, 0.15f);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
}

9
tests/fsfocus.c
View File

@ -68,6 +68,7 @@ static void window_key_callback(GLFWwindow window, int key, int action)
static int window_close_callback(GLFWwindow window)
{
printf("%0.3f: User closed window\n", glfwGetTime());
running = GL_FALSE;
return GL_TRUE;
}
@ -81,7 +82,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(640, 480, GLFW_FULLSCREEN, "Fullscreen focus", NULL);
window = glfwCreateWindow(640, 480, GLFW_FULLSCREEN, "Fullscreen focus", NULL);
if (!window)
{
glfwTerminate();
@ -90,17 +91,19 @@ int main(void)
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL);
glfwSetWindowFocusCallback(window_focus_callback);
glfwSetKeyCallback(window_key_callback);
glfwSetWindowCloseCallback(window_close_callback);
while (running && glfwIsWindow(window) == GL_TRUE)
while (running)
{
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwWaitEvents();
}

32
tests/gamma.c
View File

@ -37,7 +37,7 @@
#define STEP_SIZE 0.1f
static GLfloat gamma = 1.0f;
static GLfloat gamma_value = 1.0f;
static void usage(void)
{
@ -46,9 +46,9 @@ static void usage(void)
static void set_gamma(float value)
{
gamma = value;
printf("Gamma: %f\n", gamma);
glfwSetGamma(gamma);
gamma_value = value;
printf("Gamma: %f\n", gamma_value);
glfwSetGamma(gamma_value);
}
static void key_callback(GLFWwindow window, int key, int action)
@ -60,22 +60,22 @@ static void key_callback(GLFWwindow window, int key, int action)
{
case GLFW_KEY_ESCAPE:
{
glfwCloseWindow(window);
glfwDestroyWindow(window);
break;
}
case GLFW_KEY_KP_ADD:
case GLFW_KEY_Q:
{
set_gamma(gamma + STEP_SIZE);
set_gamma(gamma_value + STEP_SIZE);
break;
}
case GLFW_KEY_KP_SUBTRACT:
case GLFW_KEY_W:
{
if (gamma - STEP_SIZE > 0.f)
set_gamma(gamma - STEP_SIZE);
if (gamma_value - STEP_SIZE > 0.f)
set_gamma(gamma_value - STEP_SIZE);
break;
}
@ -119,10 +119,10 @@ int main(int argc, char** argv)
if (mode == GLFW_FULLSCREEN)
{
GLFWvidmode mode;
glfwGetDesktopMode(&mode);
width = mode.width;
height = mode.height;
GLFWvidmode desktop_mode;
glfwGetDesktopMode(&desktop_mode);
width = desktop_mode.width;
height = desktop_mode.height;
}
else
{
@ -130,7 +130,7 @@ int main(int argc, char** argv)
height = 0;
}
window = glfwOpenWindow(width, height, mode, "Gamma Test", NULL);
window = glfwCreateWindow(width, height, mode, "Gamma Test", NULL);
if (!window)
{
glfwTerminate();
@ -141,7 +141,9 @@ int main(int argc, char** argv)
set_gamma(1.f);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetKeyCallback(key_callback);
glfwSetWindowSizeCallback(size_callback);
@ -151,14 +153,14 @@ int main(int argc, char** argv)
glClearColor(0.5f, 0.5f, 0.5f, 0);
while (glfwIsWindow(window))
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.8f, 0.2f, 0.4f);
glRectf(-0.5f, -0.5f, 0.5f, 0.5f);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
}

258
tests/getopt.c
View File

@ -1,258 +0,0 @@
/*****************************************************************************
* getopt.c - competent and free getopt library.
* $Header: /cvsroot/freegetopt/freegetopt/getopt.c,v 1.2 2003/10/26 03:10:20 vindaci Exp $
*
* Copyright (c)2002-2003 Mark K. Kim
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* * Neither the original author of this software nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "getopt.h"
/* 2011-07-27 Camilla Berglund <elmindreda@elmindreda.org>
*
* Added _CRT_SECURE_NO_WARNINGS macro.
*/
/* 2009-10-12 Camilla Berglund <elmindreda@elmindreda.org>
*
* Removed unused global static variable 'ID'.
*/
char* optarg = NULL;
int optind = 0;
int opterr = 1;
int optopt = '?';
static char** prev_argv = NULL; /* Keep a copy of argv and argc to */
static int prev_argc = 0; /* tell if getopt params change */
static int argv_index = 0; /* Option we're checking */
static int argv_index2 = 0; /* Option argument we're checking */
static int opt_offset = 0; /* Index into compounded "-option" */
static int dashdash = 0; /* True if "--" option reached */
static int nonopt = 0; /* How many nonopts we've found */
static void increment_index()
{
/* Move onto the next option */
if(argv_index < argv_index2)
{
while(prev_argv[++argv_index] && prev_argv[argv_index][0] != '-'
&& argv_index < argv_index2+1);
}
else argv_index++;
opt_offset = 1;
}
/*
* Permutes argv[] so that the argument currently being processed is moved
* to the end.
*/
static int permute_argv_once()
{
/* Movability check */
if(argv_index + nonopt >= prev_argc) return 1;
/* Move the current option to the end, bring the others to front */
else
{
char* tmp = prev_argv[argv_index];
/* Move the data */
memmove(&prev_argv[argv_index], &prev_argv[argv_index+1],
sizeof(char**) * (prev_argc - argv_index - 1));
prev_argv[prev_argc - 1] = tmp;
nonopt++;
return 0;
}
}
int getopt(int argc, char** argv, char* optstr)
{
int c = 0;
/* If we have new argv, reinitialize */
if(prev_argv != argv || prev_argc != argc)
{
/* Initialize variables */
prev_argv = argv;
prev_argc = argc;
argv_index = 1;
argv_index2 = 1;
opt_offset = 1;
dashdash = 0;
nonopt = 0;
}
/* Jump point in case we want to ignore the current argv_index */
getopt_top:
/* Misc. initializations */
optarg = NULL;
/* Dash-dash check */
if(argv[argv_index] && !strcmp(argv[argv_index], "--"))
{
dashdash = 1;
increment_index();
}
/* If we're at the end of argv, that's it. */
if(argv[argv_index] == NULL)
{
c = -1;
}
/* Are we looking at a string? Single dash is also a string */
else if(dashdash || argv[argv_index][0] != '-' || !strcmp(argv[argv_index], "-"))
{
/* If we want a string... */
if(optstr[0] == '-')
{
c = 1;
optarg = argv[argv_index];
increment_index();
}
/* If we really don't want it (we're in POSIX mode), we're done */
else if(optstr[0] == '+' || getenv("POSIXLY_CORRECT"))
{
c = -1;
/* Everything else is a non-opt argument */
nonopt = argc - argv_index;
}
/* If we mildly don't want it, then move it back */
else
{
if(!permute_argv_once()) goto getopt_top;
else c = -1;
}
}
/* Otherwise we're looking at an option */
else
{
char* opt_ptr = NULL;
/* Grab the option */
c = argv[argv_index][opt_offset++];
/* Is the option in the optstr? */
if(optstr[0] == '-') opt_ptr = strchr(optstr+1, c);
else opt_ptr = strchr(optstr, c);
/* Invalid argument */
if(!opt_ptr)
{
if(opterr)
{
fprintf(stderr, "%s: invalid option -- %c\n", argv[0], c);
}
optopt = c;
c = '?';
/* Move onto the next option */
increment_index();
}
/* Option takes argument */
else if(opt_ptr[1] == ':')
{
/* ie, -oARGUMENT, -xxxoARGUMENT, etc. */
if(argv[argv_index][opt_offset] != '\0')
{
optarg = &argv[argv_index][opt_offset];
increment_index();
}
/* ie, -o ARGUMENT (only if it's a required argument) */
else if(opt_ptr[2] != ':')
{
/* One of those "you're not expected to understand this" moment */
if(argv_index2 < argv_index) argv_index2 = argv_index;
while(argv[++argv_index2] && argv[argv_index2][0] == '-');
optarg = argv[argv_index2];
/* Don't cross into the non-option argument list */
if(argv_index2 + nonopt >= prev_argc) optarg = NULL;
/* Move onto the next option */
increment_index();
}
else
{
/* Move onto the next option */
increment_index();
}
/* In case we got no argument for an option with required argument */
if(optarg == NULL && opt_ptr[2] != ':')
{
optopt = c;
c = '?';
if(opterr)
{
fprintf(stderr,"%s: option requires an argument -- %c\n",
argv[0], optopt);
}
}
}
/* Option does not take argument */
else
{
/* Next argv_index */
if(argv[argv_index][opt_offset] == '\0')
{
increment_index();
}
}
}
/* Calculate optind */
if(c == -1)
{
optind = argc - nonopt;
}
else
{
optind = argv_index;
}
return c;
}
/* vim:ts=3
*/

63
tests/getopt.h
View File

@ -1,63 +0,0 @@
/*****************************************************************************
* getopt.h - competent and free getopt library.
* $Header: /cvsroot/freegetopt/freegetopt/getopt.h,v 1.2 2003/10/26 03:10:20 vindaci Exp $
*
* Copyright (c)2002-2003 Mark K. Kim
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* * Neither the original author of this software nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
#ifndef GETOPT_H_
#define GETOPT_H_
#ifdef __cplusplus
extern "C" {
#endif
extern char* optarg;
extern int optind;
extern int opterr;
extern int optopt;
int getopt(int argc, char** argv, char* optstr);
#ifdef __cplusplus
}
#endif
#endif /* GETOPT_H_ */
/* vim:ts=3
*/

16
tests/glfwinfo.c
View File

@ -191,29 +191,31 @@ int main(int argc, char** argv)
if (major != 1 || minor != 0)
{
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, major);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, minor);
glfwWindowHint(GLFW_OPENGL_VERSION_MAJOR, major);
glfwWindowHint(GLFW_OPENGL_VERSION_MINOR, minor);
}
if (debug)
glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
if (forward)
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
if (profile != 0)
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, profile);
glfwWindowHint(GLFW_OPENGL_PROFILE, profile);
if (strategy)
glfwOpenWindowHint(GLFW_OPENGL_ROBUSTNESS, strategy);
glfwWindowHint(GLFW_OPENGL_ROBUSTNESS, strategy);
// We assume here that we stand a better chance of success by leaving all
// possible details of pixel format selection to GLFW
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Version", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Version", NULL);
if (!window)
exit(EXIT_FAILURE);
glfwMakeContextCurrent(window);
// Report GLFW version
glfwGetVersion(&major, &minor, &revision);

20
tests/iconify.c
View File

@ -55,7 +55,7 @@ static void key_callback(GLFWwindow window, int key, int action)
glfwIconifyWindow(window);
break;
case GLFW_KEY_ESCAPE:
glfwCloseWindow(window);
glfwDestroyWindow(window);
break;
}
}
@ -100,10 +100,10 @@ int main(int argc, char** argv)
if (mode == GLFW_FULLSCREEN)
{
GLFWvidmode mode;
glfwGetDesktopMode(&mode);
width = mode.width;
height = mode.height;
GLFWvidmode desktop_mode;
glfwGetDesktopMode(&desktop_mode);
width = desktop_mode.width;
height = desktop_mode.height;
}
else
{
@ -111,7 +111,7 @@ int main(int argc, char** argv)
height = 0;
}
window = glfwOpenWindow(width, height, mode, "Iconify", NULL);
window = glfwCreateWindow(width, height, mode, "Iconify", NULL);
if (!window)
{
glfwTerminate();
@ -120,16 +120,16 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetKeyCallback(key_callback);
glfwSetWindowSizeCallback(size_callback);
glEnable(GL_SCISSOR_TEST);
while (glfwIsWindow(window))
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
int width, height;
if (iconified != glfwGetWindowParam(window, GLFW_ICONIFIED) ||
active != glfwGetWindowParam(window, GLFW_ACTIVE))
{
@ -152,7 +152,7 @@ int main(int argc, char** argv)
glClearColor(1, 1, 1, 0);
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
}

9
tests/joysticks.c
View File

@ -44,7 +44,6 @@ typedef struct Joystick
} Joystick;
static Joystick joysticks[GLFW_JOYSTICK_LAST - GLFW_JOYSTICK_1 + 1];
static int joystick_count = 0;
static void window_size_callback(GLFWwindow window, int width, int height)
@ -187,7 +186,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Joystick Test", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Joystick Test", NULL);
if (!window)
{
glfwTerminate();
@ -197,16 +196,18 @@ int main(void)
}
glfwSetWindowSizeCallback(window_size_callback);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
while (glfwIsWindow(window))
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
refresh_joysticks();
draw_joysticks();
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
}

63
tests/modes.c
View File

@ -53,11 +53,11 @@ static const char* format_mode(GLFWvidmode* mode)
{
static char buffer[512];
snprintf(buffer, sizeof(buffer),
"%i x %i x %i (%i %i %i)",
mode->width, mode->height,
mode->redBits + mode->greenBits + mode->blueBits,
mode->redBits, mode->greenBits, mode->blueBits);
sprintf(buffer,
"%i x %i x %i (%i %i %i)",
mode->width, mode->height,
mode->redBits + mode->greenBits + mode->blueBits,
mode->redBits, mode->greenBits, mode->blueBits);
buffer[sizeof(buffer) - 1] = '\0';
return buffer;
@ -68,7 +68,7 @@ static void error_callback(int error, const char* description)
fprintf(stderr, "Error: %s\n", description);
}
static void window_size_callback(GLFWwindow window, int width, int height)
static void window_size_callback(GLFWwindow in_window, int width, int height)
{
printf("Window resized to %ix%i\n", width, height);
@ -85,7 +85,7 @@ static void key_callback(GLFWwindow dummy, int key, int action)
{
if (key == GLFW_KEY_ESCAPE)
{
glfwCloseWindow(window);
glfwDestroyWindow(window);
window = NULL;
}
}
@ -117,7 +117,7 @@ static void list_modes(GLFWmonitor monitor)
static void test_modes(GLFWmonitor monitor)
{
int i, count, width, height;
int i, count;
GLFWvidmode* modes = glfwGetVideoModes(monitor, &count);
glfwSetWindowSizeCallback(window_size_callback);
@ -127,19 +127,20 @@ static void test_modes(GLFWmonitor monitor)
for (i = 0; i < count; i++)
{
GLFWvidmode* mode = modes + i;
GLFWvidmode current;
glfwOpenWindowHint(GLFW_RED_BITS, mode->redBits);
glfwOpenWindowHint(GLFW_GREEN_BITS, mode->greenBits);
glfwOpenWindowHint(GLFW_BLUE_BITS, mode->blueBits);
glfwWindowHint(GLFW_RED_BITS, mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
printf("Testing mode %u on monitor %s: %s\n",
(unsigned int) i,
glfwGetMonitorString(monitor, GLFW_MONITOR_NAME),
format_mode(mode));
window = glfwOpenWindow(mode->width, mode->height,
GLFW_FULLSCREEN, "Video Mode Test",
NULL);
window = glfwCreateWindow(mode->width, mode->height,
GLFW_FULLSCREEN, "Video Mode Test",
NULL);
if (!window)
{
printf("Failed to enter mode %u: %s\n",
@ -148,13 +149,15 @@ static void test_modes(GLFWmonitor monitor)
continue;
}
glfwSetTime(0.0);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetTime(0.0);
while (glfwGetTime() < 5.0)
{
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
if (!window)
@ -164,31 +167,31 @@ static void test_modes(GLFWmonitor monitor)
}
}
if (glfwGetWindowParam(window, GLFW_RED_BITS) != mode->redBits ||
glfwGetWindowParam(window, GLFW_GREEN_BITS) != mode->greenBits ||
glfwGetWindowParam(window, GLFW_BLUE_BITS) != mode->blueBits)
glGetIntegerv(GL_RED_BITS, &current.redBits);
glGetIntegerv(GL_GREEN_BITS, &current.greenBits);
glGetIntegerv(GL_BLUE_BITS, &current.blueBits);
glfwGetWindowSize(window, &current.width, &current.height);
if (current.redBits != mode->redBits ||
current.greenBits != mode->greenBits ||
current.blueBits != mode->blueBits)
{
printf("*** Color bit mismatch: (%i %i %i) instead of (%i %i %i)\n",
glfwGetWindowParam(window, GLFW_RED_BITS),
glfwGetWindowParam(window, GLFW_GREEN_BITS),
glfwGetWindowParam(window, GLFW_BLUE_BITS),
mode->redBits,
mode->greenBits,
mode->blueBits);
current.redBits, current.greenBits, current.blueBits,
mode->redBits, mode->greenBits, mode->blueBits);
}
glfwGetWindowSize(window, &width, &height);
if (width != mode->width || height != mode->height)
if (current.width != mode->width || current.height != mode->height)
{
printf("*** Size mismatch: %ix%i instead of %ix%i\n",
width, height,
current.width, current.height,
mode->width, mode->height);
}
printf("Closing window\n");
glfwCloseWindow(window);
glfwDestroyWindow(window);
glfwPollEvents();
window = NULL;
}

12
tests/peter.c
View File

@ -78,7 +78,7 @@ static void key_callback(GLFWwindow window, int key, int action)
{
if (action == GLFW_PRESS)
{
glfwCloseWindow(window);
glfwDestroyWindow(window);
open_window();
}
@ -94,17 +94,19 @@ static void window_size_callback(GLFWwindow window, int width, int height)
static GLboolean open_window(void)
{
window_handle = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Peter Detector", NULL);
window_handle = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Peter Detector", NULL);
if (!window_handle)
return GL_FALSE;
glfwMakeContextCurrent(window_handle);
glfwSwapInterval(1);
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);
glfwSwapInterval(1);
return GL_TRUE;
}
@ -127,11 +129,11 @@ int main(void)
glClearColor(0.f, 0.f, 0.f, 0.f);
while (glfwIsWindow(window_handle))
while (!glfwGetWindowParam(window_handle, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(window_handle);
glfwWaitEvents();
}

10
tests/reopen.c
View File

@ -92,17 +92,19 @@ static GLboolean open_window(int width, int height, int mode)
base = glfwGetTime();
window_handle = glfwOpenWindow(width, height, mode, "Window Re-opener", NULL);
window_handle = glfwCreateWindow(width, height, mode, "Window Re-opener", NULL);
if (!window_handle)
{
fprintf(stderr, "Failed to open %s mode GLFW window: %s\n", get_mode_name(mode), glfwErrorString(glfwGetError()));
return GL_FALSE;
}
glfwMakeContextCurrent(window_handle);
glfwSwapInterval(1);
glfwSetWindowSizeCallback(window_size_callback);
glfwSetWindowCloseCallback(window_close_callback);
glfwSetKeyCallback(key_callback);
glfwSwapInterval(1);
printf("Opening %s mode window took %0.3f seconds\n",
get_mode_name(mode),
@ -115,7 +117,7 @@ static void close_window(void)
{
double base = glfwGetTime();
glfwCloseWindow(window_handle);
glfwDestroyWindow(window_handle);
window_handle = NULL;
printf("Closing window took %0.3f seconds\n", glfwGetTime() - base);
@ -147,7 +149,7 @@ int main(int argc, char** argv)
glRectf(-0.5f, -0.5f, 1.f, 1.f);
glPopMatrix();
glfwSwapBuffers();
glfwSwapBuffers(window_handle);
glfwPollEvents();
if (closed)

35
tests/sharing.c
View File

@ -36,23 +36,44 @@
#define WIDTH 400
#define HEIGHT 400
static GLFWwindow windows[2];
static void key_callback(GLFWwindow window, int key, int action)
{
if (action == GLFW_PRESS && key == GLFW_KEY_ESCAPE)
glfwCloseWindow(window);
glfwDestroyWindow(window);
}
static int window_close_callback(GLFWwindow window)
{
int i;
for (i = 0; i < 2; i++)
{
if (windows[i] == window)
{
windows[i] = NULL;
break;
}
}
return GL_TRUE;
}
static GLFWwindow open_window(const char* title, GLFWwindow share)
{
GLFWwindow window;
window = glfwOpenWindow(WIDTH, HEIGHT, GLFW_WINDOWED, title, share);
window = glfwCreateWindow(WIDTH, HEIGHT, GLFW_WINDOWED, title, share);
if (!window)
return NULL;
glfwSetKeyCallback(key_callback);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetWindowCloseCallback(window_close_callback);
glfwSetKeyCallback(key_callback);
return window;
}
@ -112,7 +133,6 @@ static void draw_quad(GLuint texture)
int main(int argc, char** argv)
{
GLFWwindow windows[2];
GLuint texture;
int x, y;
@ -150,15 +170,16 @@ int main(int argc, char** argv)
glfwGetWindowPos(windows[0], &x, &y);
glfwSetWindowPos(windows[1], x + WIDTH + 50, y);
while (glfwIsWindow(windows[0]) && glfwIsWindow(windows[1]))
while (windows[0] && windows[1])
{
glfwMakeContextCurrent(windows[0]);
draw_quad(texture);
glfwSwapBuffers();
glfwMakeContextCurrent(windows[1]);
draw_quad(texture);
glfwSwapBuffers();
glfwSwapBuffers(windows[0]);
glfwSwapBuffers(windows[1]);
glfwWaitEvents();
}

18
tests/tearing.c
View File

@ -36,15 +36,16 @@
static int swap_interval;
static void set_swap_interval(int value)
static void set_swap_interval(GLFWwindow window, int interval)
{
char title[256];
swap_interval = value;
swap_interval = interval;
glfwSwapInterval(swap_interval);
sprintf(title, "Tearing detector (interval %i)", swap_interval);
glfwSetWindowTitle(glfwGetCurrentContext(), title);
glfwSetWindowTitle(window, title);
}
static void window_size_callback(GLFWwindow window, int width, int height)
@ -55,7 +56,7 @@ static void window_size_callback(GLFWwindow window, int width, int height)
static void key_callback(GLFWwindow window, int key, int action)
{
if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
set_swap_interval(!swap_interval);
set_swap_interval(window, 1 - swap_interval);
}
int main(void)
@ -69,7 +70,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "", NULL);
if (!window)
{
glfwTerminate();
@ -78,7 +79,8 @@ int main(void)
exit(EXIT_FAILURE);
}
set_swap_interval(1);
glfwMakeContextCurrent(window);
set_swap_interval(window, swap_interval);
glfwSetWindowSizeCallback(window_size_callback);
glfwSetKeyCallback(key_callback);
@ -87,14 +89,14 @@ int main(void)
glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
glMatrixMode(GL_MODELVIEW);
while (glfwIsWindow(window) == GL_TRUE)
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
position = cosf(glfwGetTime() * 4.f) * 0.75f;
glRectf(position - 0.25f, -1.f, position + 0.25f, 1.f);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwPollEvents();
}

7
tests/title.c
View File

@ -47,21 +47,22 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL);
if (!window)
{
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetWindowSizeCallback(window_size_callback);
while (glfwIsWindow(window) == GL_TRUE)
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
{
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(window);
glfwWaitEvents();
}

22
tests/windows.c
View File

@ -55,7 +55,7 @@ int main(void)
for (i = 0; i < 4; i++)
{
windows[i] = glfwOpenWindow(200, 200, GLFW_WINDOWED, titles[i], NULL);
windows[i] = glfwCreateWindow(200, 200, GLFW_WINDOWED, titles[i], NULL);
if (!windows[i])
{
fprintf(stderr, "Failed to open GLFW window: %s\n",
@ -64,12 +64,13 @@ int main(void)
exit(EXIT_FAILURE);
}
glfwSetWindowPos(windows[i], 100 + (i & 1) * 300, 100 + (i >> 1) * 300);
glfwMakeContextCurrent(windows[i]);
glClearColor((GLclampf) (i & 1),
(GLclampf) (i >> 1),
i ? 0.0 : 1.0,
0.0);
i ? 0.f : 1.f,
0.f);
glfwSetWindowPos(windows[i], 100 + (i & 1) * 300, 100 + (i >> 1) * 300);
}
while (running)
@ -78,16 +79,13 @@ int main(void)
{
glfwMakeContextCurrent(windows[i]);
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
glfwSwapBuffers(windows[i]);
if (glfwGetWindowParam(windows[i], GLFW_CLOSE_REQUESTED))
running = GL_FALSE;
}
glfwPollEvents();
for (i = 0; i < 4; i++)
{
if (!glfwIsWindow(windows[i]))
running = GL_FALSE;
}
}
glfwTerminate();