anulax
/
glfw
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Merge fix.

Browse Source
master
Camilla Berglund ago%!(EXTRA string=15 years)
parent 562242f3e2 7e2b014d81
commit 7eea9b2384
36 changed files with 663 additions and 837 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      CMakeLists.txt
  2. 2
      examples/boing.c
  3. 4
      examples/gears.c
  4. 4
      examples/heightmap.c
  5. 122
      examples/mipmaps.c
  6. BIN
      examples/mipmaps.tga
  7. 32
      examples/splitview.c
  8. 34
      examples/triangle.c
  9. 232
      examples/wave.c
  10. 20
      include/GL/glfw3.h
  11. 13
      src/cocoa/CMakeLists.txt
  12. 16
      src/cocoa/cocoa_window.m
  13. 4
      src/enable.c
  14. 2
      src/gamma.c
  15. 30
      src/input.c
  16. 23
      src/internal.h
  17. 12
      src/win32/CMakeLists.txt
  18. 1
      src/win32/platform.h
  19. 34
      src/win32/win32_gamma.c
  20. 19
      src/win32/win32_init.c
  21. 18
      src/win32/win32_window.c
  22. 53
      src/window.c
  23. 9
      src/x11/CMakeLists.txt
  24. 12
      src/x11/x11_gamma.c
  25. 8
      src/x11/x11_init.c
  26. 20
      src/x11/x11_window.c
  27. 4
      tests/accuracy.c
  28. 20
      tests/events.c
  29. 2
      tests/fsaa.c
  30. 6
      tests/fsfocus.c
  31. 4
      tests/gamma.c
  32. 4
      tests/iconify.c
  33. 6
      tests/peter.c
  34. 6
      tests/reopen.c
  35. 2
      tests/sharing.c
  36. 2
      tests/tearing.c

6
CMakeLists.txt
Unescape View File

@ -8,8 +8,7 @@ set(GLFW_VERSION_MINOR "0")
set(GLFW_VERSION_PATCH "0") set(GLFW_VERSION_PATCH "0")
set(GLFW_VERSION_EXTRA "") set(GLFW_VERSION_EXTRA "")
set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}") set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}")
set(GLFW_VERSION_FULL set(GLFW_VERSION_FULL "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
"${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
include(CheckFunctionExists) include(CheckFunctionExists)
include(CheckSymbolExists) include(CheckSymbolExists)
@ -159,8 +158,7 @@ install(FILES COPYING.txt readme.html
# Uninstall operation # Uninstall operation
#-------------------------------------------------------------------- #--------------------------------------------------------------------
configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in
${GLFW_BINARY_DIR}/cmake_uninstall.cmake ${GLFW_BINARY_DIR}/cmake_uninstall.cmake IMMEDIATE @ONLY)
IMMEDIATE @ONLY)
add_custom_target(uninstall add_custom_target(uninstall
${CMAKE_COMMAND} -P ${CMAKE_COMMAND} -P

2
examples/boing.c
Unescape View File

@ -585,7 +585,7 @@ int main( void )
exit( EXIT_FAILURE ); exit( EXIT_FAILURE );
} }
glfwSetWindowSizeCallback( window, reshape ); glfwSetWindowSizeCallback( reshape );
glfwEnable( window, GLFW_STICKY_KEYS ); glfwEnable( window, GLFW_STICKY_KEYS );
glfwSwapInterval( 1 ); glfwSwapInterval( 1 );
glfwSetTime( 0.0 ); glfwSetTime( 0.0 );

4
examples/gears.c
Unescape View File

@ -346,8 +346,8 @@ int main(int argc, char *argv[])
init(argc, argv); init(argc, argv);
// Set callback functions // Set callback functions
glfwSetWindowSizeCallback( window, reshape ); glfwSetWindowSizeCallback( reshape );
glfwSetKeyCallback( window, key ); glfwSetKeyCallback( key );
// Main loop // Main loop
while( running ) while( running )

4
examples/heightmap.c
Unescape View File

@ -597,8 +597,8 @@ int main(int argc, char** argv)
free(fragment_shader_src); free(fragment_shader_src);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
glfwSetWindowCloseCallback(window, window_close_callback); glfwSetWindowCloseCallback(window_close_callback);
glfwSetKeyCallback(window, key_callback); glfwSetKeyCallback(key_callback);
/* Register events callback */ /* Register events callback */
if (GL_TRUE != init_opengl()) if (GL_TRUE != init_opengl())

122
examples/mipmaps.c
Unescape View File

@ -1,122 +0,0 @@
//========================================================================
// This is an example program for the GLFW library
//
// It shows texture loading with mipmap generation and rendering with
// trilienar texture filtering
//========================================================================
#include <stdio.h>
#include <stdlib.h>
#include <GL/glfw.h>
int main( void )
{
int width, height, x;
double time;
GLboolean running;
GLuint textureID;
char* texturePath = "mipmaps.tga";
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Open OpenGL window
if( !glfwOpenWindow( 640, 480, 0,0,0,0, 0,0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "Trilinear interpolation" );
// Enable sticky keys
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
// Generate and bind our texture ID
glGenTextures( 1, &textureID );
glBindTexture( GL_TEXTURE_2D, textureID );
// Load texture from file into video memory, including mipmap levels
if( !glfwLoadTexture2D( texturePath, GLFW_BUILD_MIPMAPS_BIT ) )
{
fprintf( stderr, "Failed to load texture %s\n", texturePath );
glfwTerminate();
exit( EXIT_FAILURE );
}
// Use trilinear interpolation (GL_LINEAR_MIPMAP_LINEAR)
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR );
// Enable plain 2D texturing
glEnable( GL_TEXTURE_2D );
running = GL_TRUE;
while( running )
{
// Get time and mouse position
time = glfwGetTime();
glfwGetMousePos( &x, NULL );
// Get window size (may be different than the requested size)
glfwGetWindowSize( &width, &height );
height = height > 0 ? height : 1;
// Set viewport
glViewport( 0, 0, width, height );
// Clear color buffer
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f);
glClear( GL_COLOR_BUFFER_BIT );
// Select and setup the projection matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 65.0f, (GLfloat)width / (GLfloat)height, 1.0f,
50.0f );
// Select and setup the modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( 0.0f, 3.0f, -20.0f, // Eye-position
0.0f, -4.0f, -11.0f, // View-point
0.0f, 1.0f, 0.0f ); // Up-vector
// Draw a textured quad
glRotatef( 0.05f * (GLfloat)x + (GLfloat)time * 5.0f, 0.0f, 1.0f, 0.0f );
glBegin( GL_QUADS );
glTexCoord2f( -20.0f, 20.0f );
glVertex3f( -50.0f, 0.0f, -50.0f );
glTexCoord2f( 20.0f, 20.0f );
glVertex3f( 50.0f, 0.0f, -50.0f );
glTexCoord2f( 20.0f, -20.0f );
glVertex3f( 50.0f, 0.0f, 50.0f );
glTexCoord2f( -20.0f, -20.0f );
glVertex3f( -50.0f, 0.0f, 50.0f );
glEnd();
// Swap buffers
glfwSwapBuffers();
// Check if the ESC key was pressed or the window was closed
running = !glfwGetKey( GLFW_KEY_ESC ) &&
glfwGetWindowParam( GLFW_OPENED );
}
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}

BIN
examples/mipmaps.tga
View File

Binary file not shown.

32
examples/splitview.c
Unescape View File

@ -92,6 +92,7 @@ static void drawTorus( void )
glVertex3f((float) x, (float) y, (float) z); glVertex3f((float) x, (float) y, (float) z);
} }
} }
glEnd(); glEnd();
} }
@ -210,13 +211,9 @@ static void drawAllViews( void )
// Calculate aspect of window // Calculate aspect of window
if (height > 0) if (height > 0)
{
aspect = (double) width / (double) height; aspect = (double) width / (double) height;
}
else else
{
aspect = 1.0; aspect = 1.0;
}
// Clear screen // Clear screen
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
@ -229,7 +226,6 @@ static void drawAllViews( void )
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL); glDepthFunc(GL_LEQUAL);
// ** ORTHOGONAL VIEWS ** // ** ORTHOGONAL VIEWS **
// For orthogonal views, use wireframe rendering // For orthogonal views, use wireframe rendering
@ -282,7 +278,6 @@ static void drawAllViews( void )
glDisable(GL_LINE_SMOOTH); glDisable(GL_LINE_SMOOTH);
glDisable(GL_BLEND); glDisable(GL_BLEND);
// ** PERSPECTIVE VIEW ** // ** PERSPECTIVE VIEW **
// For perspective view, use solid rendering // For perspective view, use solid rendering
@ -330,18 +325,21 @@ static void drawAllViews( void )
// Disable scissor test // Disable scissor test
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
// Draw a border around the active view // Draw a border around the active view
if (active_view > 0 && active_view != 2) if (active_view > 0 && active_view != 2)
{ {
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
glOrtho(0.0, 2.0, 0.0, 2.0, 0.0, 1.0); glOrtho(0.0, 2.0, 0.0, 2.0, 0.0, 1.0);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
glColor3f( 1.0f, 1.0f, 0.6f );
glTranslatef((GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f); glTranslatef((GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f);
glColor3f(1.0f, 1.0f, 0.6f);
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex2i(0, 0); glVertex2i(0, 0);
glVertex2i(1, 0); glVertex2i(1, 0);
@ -416,22 +414,15 @@ static void mousePosFun( GLFWwindow window, int x, int y )
static void mouseButtonFun(GLFWwindow window, int button, int action) static void mouseButtonFun(GLFWwindow window, int button, int action)
{ {
// Button clicked?
if ((button == GLFW_MOUSE_BUTTON_LEFT) && action == GLFW_PRESS) if ((button == GLFW_MOUSE_BUTTON_LEFT) && action == GLFW_PRESS)
{ {
// Detect which of the four views was clicked // Detect which of the four views was clicked
active_view = 1; active_view = 1;
if (xpos >= width / 2) if (xpos >= width / 2)
{
active_view += 1; active_view += 1;
}
if (ypos >= height / 2) if (ypos >= height / 2)
{
active_view += 2; active_view += 2;
} }
}
// Button released?
else if (button == GLFW_MOUSE_BUTTON_LEFT) else if (button == GLFW_MOUSE_BUTTON_LEFT)
{ {
// Deselect any previously selected view // Deselect any previously selected view
@ -443,7 +434,7 @@ static void mouseButtonFun( GLFWwindow window, int button, int action )
//======================================================================== //========================================================================
// main() // main
//======================================================================== //========================================================================
int main(void) int main(void)
@ -464,7 +455,6 @@ int main( void )
if (!window) if (!window)
{ {
fprintf(stderr, "Failed to open GLFW window\n"); fprintf(stderr, "Failed to open GLFW window\n");
glfwTerminate();
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
@ -478,10 +468,10 @@ int main( void )
glfwEnable(window, GLFW_MOUSE_CURSOR); glfwEnable(window, GLFW_MOUSE_CURSOR);
// Set callback functions // Set callback functions
glfwSetWindowSizeCallback( window, windowSizeFun ); glfwSetWindowSizeCallback(windowSizeFun);
glfwSetWindowRefreshCallback( window, windowRefreshFun ); glfwSetWindowRefreshCallback(windowRefreshFun);
glfwSetMousePosCallback( window, mousePosFun ); glfwSetMousePosCallback(mousePosFun);
glfwSetMouseButtonCallback( window, mouseButtonFun ); glfwSetMouseButtonCallback(mouseButtonFun);
// Main loop // Main loop
do do

34
examples/triangle.c
Unescape View File

@ -6,13 +6,12 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <GL/glfw3.h>
#include <GL/glfw3.h>
int main(void) int main(void)
{ {
int width, height, x; int width, height, x;
double t;
GLFWwindow window; GLFWwindow window;
// Initialise GLFW // Initialise GLFW
@ -27,8 +26,6 @@ int main( void )
if (!window) if (!window)
{ {
fprintf(stderr, "Failed to open GLFW window\n"); fprintf(stderr, "Failed to open GLFW window\n");
glfwTerminate();
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
@ -40,7 +37,7 @@ int main( void )
do do
{ {
t = glfwGetTime(); double t = glfwGetTime();
glfwGetMousePos(window, &x, NULL); glfwGetMousePos(window, &x, NULL);
// Get window size (may be different than the requested size) // Get window size (may be different than the requested size)
@ -52,31 +49,32 @@ int main( void )
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
// Clear color buffer to black // Clear color buffer to black
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
// Select and setup the projection matrix // Select and setup the projection matrix
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
gluPerspective( 65.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f ); gluPerspective(65.f, (GLfloat) width / (GLfloat) height, 1.f, 100.f);
// Select and setup the modelview matrix // Select and setup the modelview matrix
glMatrixMode( GL_MODELVIEW ); glMatrixMode( GL_MODELVIEW );
glLoadIdentity(); glLoadIdentity();
gluLookAt( 0.0f, 1.0f, 0.0f, // Eye-position gluLookAt(0.f, 1.f, 0.f, // Eye-position
0.0f, 20.0f, 0.0f, // View-point 0.f, 20.f, 0.f, // View-point
0.0f, 0.0f, 1.0f ); // Up-vector 0.f, 0.f, 1.f); // Up-vector
// Draw a rotating colorful triangle // Draw a rotating colorful triangle
glTranslatef( 0.0f, 14.0f, 0.0f ); glTranslatef(0.f, 14.f, 0.f);
glRotatef( 0.3f*(GLfloat)x + (GLfloat)t*100.0f, 0.0f, 0.0f, 1.0f ); glRotatef(0.3f * (GLfloat) x + (GLfloat) t * 100.f, 0.f, 0.f, 1.f);
glBegin(GL_TRIANGLES); glBegin(GL_TRIANGLES);
glColor3f( 1.0f, 0.0f, 0.0f ); glColor3f(1.f, 0.f, 0.f);
glVertex3f( -5.0f, 0.0f, -4.0f ); glVertex3f(-5.f, 0.f, -4.f);
glColor3f( 0.0f, 1.0f, 0.0f ); glColor3f(0.f, 1.f, 0.f);
glVertex3f( 5.0f, 0.0f, -4.0f ); glVertex3f(5.f, 0.f, -4.f);
glColor3f( 0.0f, 0.0f, 1.0f ); glColor3f(0.f, 0.f, 1.f);
glVertex3f( 0.0f, 0.0f, 6.0f ); glVertex3f(0.f, 0.f, 6.f);
glEnd(); glEnd();
// Swap buffers // Swap buffers

232
examples/wave.c
Unescape View File

@ -5,6 +5,7 @@
* Modified for GLFW by Sylvain Hellegouarch - sh@programmationworld.com * Modified for GLFW by Sylvain Hellegouarch - sh@programmationworld.com
* Modified for variable frame rate by Marcus Geelnard * Modified for variable frame rate by Marcus Geelnard
* 2003-Jan-31: Minor cleanups and speedups / MG * 2003-Jan-31: Minor cleanups and speedups / MG
* 2010-10-24: Formatting and cleanup - Camilla Berglund
*****************************************************************************/ *****************************************************************************/
#include <stdio.h> #include <stdio.h>
@ -16,17 +17,16 @@
#define M_PI 3.1415926535897932384626433832795 #define M_PI 3.1415926535897932384626433832795
#endif #endif
/* Maximum delta T to allow for differential calculations */ // Maximum delta T to allow for differential calculations
#define MAX_DELTA_T 0.01 #define MAX_DELTA_T 0.01
/* Animation speed (10.0 looks good) */ // Animation speed (10.0 looks good)
#define ANIMATION_SPEED 10.0 #define ANIMATION_SPEED 10.0
GLfloat alpha = 210.f, beta = -70.f;
GLfloat zoom = 2.f;
GLfloat alpha = 210.0f, beta = -70.0f; GLboolean running = GL_TRUE;
GLfloat zoom = 2.0f;
int running = 1;
struct Vertex struct Vertex
{ {
@ -56,47 +56,46 @@ struct Vertex vertex[VERTEXNUM];
* 0 1 2 * 0 1 2
*/ */
void initVertices( void ) //========================================================================
// Initialize grid geometry
//========================================================================
void init_vertices(void)
{ {
int x, y, p; int x, y, p;
/* place the vertices in a grid */ // Place the vertices in a grid
for (y = 0; y < GRIDH; y++) for (y = 0; y < GRIDH; y++)
{
for (x = 0; x < GRIDW; x++) for (x = 0; x < GRIDW; x++)
{ {
p = y * GRIDW + x; p = y * GRIDW + x;
//vertex[p].x = (-GRIDW/2)+x+sin(2.0*M_PI*(double)y/(double)GRIDH);
//vertex[p].y = (-GRIDH/2)+y+cos(2.0*M_PI*(double)x/(double)GRIDW);
vertex[p].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2); vertex[p].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2);
vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2); vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2);
vertex[p].z = 0;//sin(d*M_PI); vertex[p].z = 0;
//vertex[p].r = (GLfloat)x/(GLfloat)GRIDW;
//vertex[p].g = (GLfloat)y/(GLfloat)GRIDH;
//vertex[p].b = 1.0-((GLfloat)x/(GLfloat)GRIDW+(GLfloat)y/(GLfloat)GRIDH)/2.0;
if ((x % 4 < 2) ^ (y % 4 < 2)) if ((x % 4 < 2) ^ (y % 4 < 2))
{
vertex[p].r = 0.0; vertex[p].r = 0.0;
}
else else
{
vertex[p].r = 1.0; vertex[p].r = 1.0;
}
vertex[p].g = (GLfloat) y / (GLfloat) GRIDH; vertex[p].g = (GLfloat) y / (GLfloat) GRIDH;
vertex[p].b = 1.f - ((GLfloat) x / (GLfloat) GRIDW + (GLfloat) y / (GLfloat) GRIDH) / 2.f; vertex[p].b = 1.f - ((GLfloat) x / (GLfloat) GRIDW + (GLfloat) y / (GLfloat) GRIDH) / 2.f;
} }
}
for (y = 0; y < QUADH; y++) for (y = 0; y < QUADH; y++)
{
for (x = 0; x < QUADW; x++) for (x = 0; x < QUADW; x++)
{ {
p = 4 * (y * QUADW + x); p = 4 * (y * QUADW + x);
/* first quad */ quad[p + 0] = y * GRIDW + x; // Some point
quad[p+0] = y *GRIDW+x; /* some point */ quad[p + 1] = y * GRIDW + x + 1; // Neighbor at the right side
quad[p+1] = y *GRIDW+x+1; /* neighbor at the right side */ quad[p + 2] = (y + 1) * GRIDW + x + 1; // Upper right neighbor
quad[p+2] = (y+1)*GRIDW+x+1; /* upper right neighbor */ quad[p + 3] = (y + 1) * GRIDW + x; // Upper neighbor
quad[p+3] = (y+1)*GRIDW+x; /* upper neighbor */ }
} }
} }
@ -105,9 +104,11 @@ double p[GRIDW][GRIDH];
double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH]; double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH];
double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH]; double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH];
//========================================================================
// Initialize grid
//========================================================================
void init_grid(void)
void initSurface( void )
{ {
int x, y; int x, y;
double dx, dy, d; double dx, dy, d;
@ -125,9 +126,8 @@ void initSurface( void )
p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0; p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0;
} }
else else
{
p[x][y] = 0.0; p[x][y] = 0.0;
}
vx[x][y] = 0.0; vx[x][y] = 0.0;
vy[x][y] = 0.0; vy[x][y] = 0.0;
} }
@ -135,57 +135,60 @@ void initSurface( void )
} }
/* Draw view */ //========================================================================
void draw_screen( void ) // Draw scene
//========================================================================
void draw_scene(void)
{ {
/* Clear the color and depth buffers. */ // Clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* We don't want to modify the projection matrix. */ // We don't want to modify the projection matrix
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
/* Move back. */ // Move back
glTranslatef(0.0, 0.0, -zoom); glTranslatef(0.0, 0.0, -zoom);
/* Rotate the view */ // Rotate the view
glRotatef(beta, 1.0, 0.0, 0.0); glRotatef(beta, 1.0, 0.0, 0.0);
glRotatef(alpha, 0.0, 0.0, 1.0); glRotatef(alpha, 0.0, 0.0, 1.0);
//glDrawArrays(GL_POINTS,0,VERTEXNUM); /* Points only */
glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad); glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad);
//glDrawElements(GL_LINES, QUADNUM, GL_UNSIGNED_INT, quad);
glfwSwapBuffers(); glfwSwapBuffers();
} }
/* Initialize OpenGL */ //========================================================================
void setup_opengl( void ) // Initialize Miscellaneous OpenGL state
//========================================================================
void init_opengl(void)
{ {
/* Our shading model--Gouraud (smooth). */ // Use Gouraud (smooth) shading
glShadeModel(GL_SMOOTH); glShadeModel(GL_SMOOTH);
/* Culling. */ // Switch on the z-buffer
//glCullFace(GL_BACK);
//glFrontFace(GL_CCW);
//glEnable(GL_CULL_FACE);
/* Switch on the z-buffer. */
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3/*3 components per vertex (x,y,z)*/, GL_FLOAT, sizeof(struct Vertex), vertex); glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), vertex);
glColorPointer(3/*3 components per vertex (r,g,b)*/, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r); //Pointer to the first color glColorPointer(3, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r); // Pointer to the first color
glPointSize(2.0); glPointSize(2.0);
/* Background color is black. */ // Background color is black
glClearColor(0, 0, 0, 0); glClearColor(0, 0, 0, 0);
} }
/* Modify the height of each vertex according to the pressure. */ //========================================================================
void adjustGrid( void ) // Modify the height of each vertex according to the pressure
//========================================================================
void adjust_grid(void)
{ {
int pos; int pos;
int x, y; int x, y;
@ -201,32 +204,31 @@ void adjustGrid( void )
} }
/* Calculate wave propagation */ //========================================================================
void calc( void ) // Calculate wave propagation
//========================================================================
void calc_grid(void)
{ {
int x, y, x2, y2; int x, y, x2, y2;
double time_step = dt * ANIMATION_SPEED; double time_step = dt * ANIMATION_SPEED;
/* compute accelerations */ // Compute accelerations
for (x = 0; x < GRIDW; x++) for (x = 0; x < GRIDW; x++)
{ {
x2 = (x + 1) % GRIDW; x2 = (x + 1) % GRIDW;
for(y = 0; y < GRIDH; y++) for(y = 0; y < GRIDH; y++)
{
ax[x][y] = p[x][y] - p[x2][y]; ax[x][y] = p[x][y] - p[x2][y];
} }
}
for (y = 0; y < GRIDH; y++) for (y = 0; y < GRIDH; y++)
{ {
y2 = (y + 1) % GRIDH; y2 = (y + 1) % GRIDH;
for(x = 0; x < GRIDW; x++) for(x = 0; x < GRIDW; x++)
{
ay[x][y] = p[x][y] - p[x][y2]; ay[x][y] = p[x][y] - p[x][y2];
} }
}
/* compute speeds */ // Compute speeds
for (x = 0; x < GRIDW; x++) for (x = 0; x < GRIDW; x++)
{ {
for (y = 0; y < GRIDH; y++) for (y = 0; y < GRIDH; y++)
@ -236,7 +238,7 @@ void calc( void )
} }
} }
/* compute pressure */ // Compute pressure
for (x = 1; x < GRIDW; x++) for (x = 1; x < GRIDW; x++)
{ {
x2 = x - 1; x2 = x - 1;
@ -249,20 +251,22 @@ void calc( void )
} }
/* Handle key strokes */ //========================================================================
void handle_key_down(GLFWwindow window, int key, int action) // Handle key strokes
//========================================================================
void key_callback(GLFWwindow window, int key, int action)
{ {
if (action != GLFW_PRESS) if (action != GLFW_PRESS)
{
return; return;
}
switch(key) { switch (key)
{
case GLFW_KEY_ESC: case GLFW_KEY_ESC:
running = 0; running = 0;
break; break;
case GLFW_KEY_SPACE: case GLFW_KEY_SPACE:
initSurface(); init_grid();
break; break;
case GLFW_KEY_LEFT: case GLFW_KEY_LEFT:
alpha += 5; alpha += 5;
@ -277,7 +281,8 @@ void handle_key_down(GLFWwindow window, int key, int action)
beta += 5; beta += 5;
break; break;
case GLFW_KEY_PAGEUP: case GLFW_KEY_PAGEUP:
if(zoom>1) zoom-=1; if (zoom > 1)
zoom -= 1;
break; break;
case GLFW_KEY_PAGEDOWN: case GLFW_KEY_PAGEDOWN:
zoom += 1; zoom += 1;
@ -288,115 +293,98 @@ void handle_key_down(GLFWwindow window, int key, int action)
} }
/* Callback function for window resize events */ //========================================================================
void handle_resize( GLFWwindow window, int width, int height ) // Callback function for window resize events
//========================================================================
void window_resize_callback(GLFWwindow window, int width, int height)
{ {
float ratio = 1.0f; float ratio = 1.f;
if (height > 0) if (height > 0)
{
ratio = (float) width / (float) height; ratio = (float) width / (float) height;
}
/* Setup viewport (Place where the stuff will appear in the main window). */ // Setup viewport
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
/* // Change to the projection matrix and set our viewing volume
* Change to the projection matrix and set
* our viewing volume.
*/
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
gluPerspective(60.0, ratio, 1.0, 1024.0); gluPerspective(60.0, ratio, 1.0, 1024.0);
} }
/* Program entry point */ //========================================================================
// main
//========================================================================
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
/* Dimensions of our window. */
int width, height;
/* Style of our window. */
int mode;
/* Frame time */
double t, t_old, dt_total;
GLFWwindow window; GLFWwindow window;
double t, dt_total, t_old;
/* Initialize GLFW */ if (!glfwInit())
if(glfwInit() == GL_FALSE)
{ {
fprintf(stderr, "GLFW initialization failed\n"); fprintf(stderr, "GLFW initialization failed\n");
exit(-1); exit(EXIT_FAILURE);
} }
/* Desired window properties */ window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL);
width = 640;
height = 480;
mode = GLFW_WINDOWED;
glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
/* Open window */
window = glfwOpenWindow(width, height, mode, "Wave Simulation", NULL);
if (!window) if (!window)
{ {
fprintf(stderr, "Could not open window\n"); fprintf(stderr, "Could not open window\n");
glfwTerminate(); exit(EXIT_FAILURE);
exit(-1);
} }
glfwSwapInterval(1); glfwSwapInterval(1);
/* Keyboard handler */ // Keyboard handler
glfwSetKeyCallback( window, handle_key_down ); glfwSetKeyCallback(key_callback);
glfwEnable(window, GLFW_KEY_REPEAT); glfwEnable(window, GLFW_KEY_REPEAT);
/* Window resize handler */ // Window resize handler
glfwSetWindowSizeCallback( window, handle_resize ); glfwSetWindowSizeCallback(window_resize_callback);
/* Initialize OpenGL */ // Initialize OpenGL
setup_opengl(); init_opengl();
/* Initialize simulation */ // Initialize simulation
initVertices(); init_vertices();
initSurface(); init_grid();
adjustGrid(); adjust_grid();
/* Initialize timer */ // Initialize timer
t_old = glfwGetTime() - 0.01; t_old = glfwGetTime() - 0.01;
/* Main loop */
while (running) while (running)
{ {
/* Timing */
t = glfwGetTime(); t = glfwGetTime();
dt_total = t - t_old; dt_total = t - t_old;
t_old = t; t_old = t;
/* Safety - iterate if dt_total is too large */ // Safety - iterate if dt_total is too large
while( dt_total > 0.0f ) while (dt_total > 0.f)
{ {
/* Select iteration time step */ // Select iteration time step
dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total; dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
dt_total -= dt; dt_total -= dt;
/* Calculate wave propagation */ // Calculate wave propagation
calc(); calc_grid();
} }
/* Compute height of each vertex */ // Compute height of each vertex
adjustGrid(); adjust_grid();
/* Draw wave grid to OpenGL display */ // Draw wave grid to OpenGL display
draw_screen(); draw_scene();
glfwPollEvents(); glfwPollEvents();
/* Still running? */ // Still running?
running = running && glfwIsWindow(window); running = running && glfwIsWindow(window);
} }
glfwTerminate(); exit(EXIT_SUCCESS);
return 0;
} }

20
include/GL/glfw3.h
Unescape View File

@ -442,11 +442,11 @@ GLFWAPI void glfwRestoreWindow(GLFWwindow window);
GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param); GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param);
GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer); GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer);
GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window); GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window);
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun); GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun);
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun); GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun);
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun); GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun);
GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun); GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun);
GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun); GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun);
/* Event handling */ /* Event handling */
GLFWAPI void glfwPollEvents(void); GLFWAPI void glfwPollEvents(void);
@ -458,11 +458,11 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow window, int button);
GLFWAPI void glfwGetMousePos(GLFWwindow window, int* xpos, int* ypos); GLFWAPI void glfwGetMousePos(GLFWwindow window, int* xpos, int* ypos);
GLFWAPI void glfwSetMousePos(GLFWwindow window, int xpos, int ypos); GLFWAPI void glfwSetMousePos(GLFWwindow window, int xpos, int ypos);
GLFWAPI void glfwGetScrollOffset(GLFWwindow window, int* x, int* y); GLFWAPI void glfwGetScrollOffset(GLFWwindow window, int* x, int* y);
GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun); GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun);
GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun); GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun);
GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun); GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun);
GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun); GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun);
GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun); GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun);
/* Joystick input */ /* Joystick input */
GLFWAPI int glfwGetJoystickParam(int joy, int param); GLFWAPI int glfwGetJoystickParam(int joy, int param);

13
src/cocoa/CMakeLists.txt
Unescape View File

@ -1,6 +1,5 @@
configure_file( configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY) ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
include_directories(${CMAKE_CURRENT_SOURCE_DIR} include_directories(${CMAKE_CURRENT_SOURCE_DIR}
@ -8,8 +7,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_BINARY_DIR}/src ${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR}) ${GLFW_INCLUDE_DIR})
set(cocoa_SOURCES set(cocoa_SOURCES cocoa_enable.m
cocoa_enable.m
cocoa_fullscreen.m cocoa_fullscreen.m
cocoa_gamma.m cocoa_gamma.m
cocoa_glext.m cocoa_glext.m
@ -21,17 +19,14 @@ set(cocoa_SOURCES
# For some reason, CMake doesn't know about .m # For some reason, CMake doesn't know about .m
set_source_files_properties(${cocoa_SOURCES} PROPERTIES LANGUAGE C) set_source_files_properties(${cocoa_SOURCES} PROPERTIES LANGUAGE C)
set(libglfw_SOURCES set(libglfw_SOURCES ${common_SOURCES} ${cocoa_SOURCES})
${common_SOURCES}
${cocoa_SOURCES})
add_library(libglfwStatic STATIC ${libglfw_SOURCES}) add_library(libglfwStatic STATIC ${libglfw_SOURCES})
add_library(libglfwShared SHARED ${libglfw_SOURCES}) add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${GLFW_LIBRARIES}) target_link_libraries(libglfwShared ${GLFW_LIBRARIES})
set_target_properties(libglfwStatic libglfwShared PROPERTIES set_target_properties(libglfwStatic libglfwShared PROPERTIES
CLEAN_DIRECT_OUTPUT 1 CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw OUTPUT_NAME glfw)
)
# Append -fno-common to the compile flags to work around a bug in the Apple GCC # Append -fno-common to the compile flags to work around a bug in the Apple GCC
get_target_property(CFLAGS libglfwShared COMPILE_FLAGS) get_target_property(CFLAGS libglfwShared COMPILE_FLAGS)

16
src/cocoa/cocoa_window.m
Unescape View File

@ -70,8 +70,8 @@
window->width = contentRect.size.width; window->width = contentRect.size.width;
window->height = contentRect.size.height; window->height = contentRect.size.height;
if (window->windowSizeCallback) if (_glfwLibrary.windowSizeCallback)
window->windowSizeCallback(window, window->width, window->height); _glfwLibrary.windowSizeCallback(window, window->width, window->height);
} }
- (void)windowDidMove:(NSNotification *)notification - (void)windowDidMove:(NSNotification *)notification
@ -95,16 +95,16 @@
{ {
window->iconified = GL_TRUE; window->iconified = GL_TRUE;
if (window->windowIconifyCallback) if (_glfwLibrary.windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified); _glfwLibrary.windowIconifyCallback(window, window->iconified);
} }
- (void)windowDidDeminiaturize:(NSNotification *)notification - (void)windowDidDeminiaturize:(NSNotification *)notification
{ {
window->iconified = GL_FALSE; window->iconified = GL_FALSE;
if (window->windowIconifyCallback) if (_glfwLibrary.windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified); _glfwLibrary.windowIconifyCallback(window, window->iconified);
} }
- (void)windowDidBecomeKey:(NSNotification *)notification - (void)windowDidBecomeKey:(NSNotification *)notification
@ -362,8 +362,8 @@ static int convertMacKeyCode(unsigned int macKeyCode)
window->mousePosY = [[window->NS.window contentView] bounds].size.height - p.y; window->mousePosY = [[window->NS.window contentView] bounds].size.height - p.y;
} }
if (window->mousePosCallback) if (_glfwLibrary.mousePosCallback)
window->mousePosCallback(window, window->mousePosX, window->mousePosY); _glfwLibrary.mousePosCallback(window, window->mousePosX, window->mousePosY);
} }
- (void)rightMouseDown:(NSEvent *)event - (void)rightMouseDown:(NSEvent *)event

4
src/enable.c
Unescape View File

@ -54,9 +54,9 @@ static void enableMouseCursor(_GLFWwindow* window)
window->mousePosX = centerPosX; window->mousePosX = centerPosX;
window->mousePosY = centerPosY; window->mousePosY = centerPosY;
if (window->mousePosCallback) if (_glfwLibrary.mousePosCallback)
{ {
window->mousePosCallback(window, _glfwLibrary.mousePosCallback(window,
window->mousePosX, window->mousePosX,
window->mousePosY); window->mousePosY);
} }

2
src/gamma.c
Unescape View File

@ -82,7 +82,7 @@ GLFWAPI void glfwSetGammaFormula(float gamma, float blacklevel, float gain)
//======================================================================== //========================================================================
// Return the currently set gamma ramp // Return the cached currently set gamma ramp
//======================================================================== //========================================================================
GLFWAPI void glfwGetGammaRamp(GLFWgammaramp* ramp) GLFWAPI void glfwGetGammaRamp(GLFWgammaramp* ramp)

30
src/input.c
Unescape View File

@ -171,7 +171,7 @@ GLFWAPI void glfwGetScrollOffset(GLFWwindow window, int* x, int* y)
// Set callback function for keyboard input // Set callback function for keyboard input
//======================================================================== //========================================================================
GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun) GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -179,7 +179,7 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun)
return; return;
} }
window->keyCallback = cbfun; _glfwLibrary.keyCallback = cbfun;
} }
@ -187,7 +187,7 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun)
// Set callback function for character input // Set callback function for character input
//======================================================================== //========================================================================
GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun) GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -195,7 +195,7 @@ GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun)
return; return;
} }
window->charCallback = cbfun; _glfwLibrary.charCallback = cbfun;
} }
@ -203,7 +203,7 @@ GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun)
// Set callback function for mouse clicks // Set callback function for mouse clicks
//======================================================================== //========================================================================
GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun) GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -211,7 +211,7 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cb
return; return;
} }
window->mouseButtonCallback = cbfun; _glfwLibrary.mouseButtonCallback = cbfun;
} }
@ -219,7 +219,7 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cb
// Set callback function for mouse moves // Set callback function for mouse moves
//======================================================================== //========================================================================
GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun) GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -228,20 +228,25 @@ GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun)
} }
// Set callback function // Set callback function
window->mousePosCallback = cbfun; _glfwLibrary.mousePosCallback = cbfun;
// Call the callback function to let the application know the current // Call the callback function to let the application know the current
// mouse position // mouse position
if (cbfun) if (cbfun)
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
cbfun(window, window->mousePosX, window->mousePosY); cbfun(window, window->mousePosX, window->mousePosY);
} }
}
//======================================================================== //========================================================================
// Set callback function for scroll events // Set callback function for scroll events
//======================================================================== //========================================================================
GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun) GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -250,11 +255,6 @@ GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun)
} }
// Set callback function // Set callback function
window->scrollCallback = cbfun; _glfwLibrary.scrollCallback = cbfun;
// Call the callback function to let the application know the current
// scroll offset
if (cbfun)
cbfun(window, window->scrollX, window->scrollY);
} }

23
src/internal.h
Unescape View File

@ -152,18 +152,6 @@ struct _GLFWwindow
{ {
struct _GLFWwindow* next; struct _GLFWwindow* next;
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWwindowfocusfun windowFocusCallback;
GLFWwindowiconifyfun windowIconifyCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWscrollfun scrollCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// Window settings and state // Window settings and state
GLboolean iconified; // GL_TRUE if this window is iconified GLboolean iconified; // GL_TRUE if this window is iconified
GLboolean closeRequested; // GL_TRUE if this window should be closed GLboolean closeRequested; // GL_TRUE if this window should be closed
@ -223,6 +211,17 @@ struct _GLFWlibrary
_GLFWwindow* activeWindow; _GLFWwindow* activeWindow;
_GLFWwindow* cursorLockWindow; _GLFWwindow* cursorLockWindow;
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWwindowfocusfun windowFocusCallback;
GLFWwindowiconifyfun windowIconifyCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWscrollfun scrollCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
GLFWgammaramp currentRamp; GLFWgammaramp currentRamp;
GLFWgammaramp originalRamp; GLFWgammaramp originalRamp;
int originalRampSize; int originalRampSize;

12
src/win32/CMakeLists.txt
Unescape View File

@ -1,7 +1,7 @@
if(CYGWIN) if(CYGWIN)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY) ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
# These lines are intended to remove the --export-all-symbols # These lines are intended to remove the --export-all-symbols
@ -19,8 +19,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_BINARY_DIR}/src ${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR}) ${GLFW_INCLUDE_DIR})
set(libglfw_SOURCES set(libglfw_SOURCES ${common_SOURCES}
${common_SOURCES}
win32_enable.c win32_enable.c
win32_fullscreen.c win32_fullscreen.c
win32_gamma.c win32_gamma.c
@ -47,8 +46,9 @@ set_target_properties(libglfwStatic libglfwShared PROPERTIES
if(CYGWIN) if(CYGWIN)
# Build for the regular Win32 environment (not Cygwin) # Build for the regular Win32 environment (not Cygwin)
set_target_properties(libglfwStatic libglfwShared PROPERTIES COMPILE_FLAGS "-mwin32 -mno-cygwin") set_target_properties(libglfwStatic libglfwShared PROPERTIES
set_target_properties(libglfwStatic libglfwShared PROPERTIES LINK_FLAGS "-mwin32 -mno-cygwin") COMPILE_FLAGS "-mwin32 -mno-cygwin"
LINK_FLAGS "-mwin32 -mno-cygwin")
endif(CYGWIN) endif(CYGWIN)
install(TARGETS libglfwStatic libglfwShared DESTINATION lib) install(TARGETS libglfwStatic libglfwShared DESTINATION lib)

1
src/win32/platform.h
Unescape View File

@ -270,7 +270,6 @@ typedef struct _GLFWlibraryWin32
ATOM classAtom; // Window class atom ATOM classAtom; // Window class atom
HHOOK keyboardHook; // Keyboard hook handle HHOOK keyboardHook; // Keyboard hook handle
DWORD foregroundLockTimeout; DWORD foregroundLockTimeout;
HDC desktopDC;
// Default monitor // Default monitor
struct { struct {

34
src/win32/win32_gamma.c
Unescape View File

@ -1,11 +1,10 @@
//======================================================================== //========================================================================
// GLFW - An OpenGL framework // GLFW - An OpenGL framework
// Platform: Win32/WGL // Platform: Win32/WGL
// API version: 2.7 // API version: 3.0
// WWW: http://www.glfw.org/ // WWW: http://www.glfw.org/
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
// //
// This software is provided 'as-is', without any express or implied // This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages // warranty. In no event will the authors be held liable for any damages
@ -33,35 +32,26 @@
#include <limits.h> #include <limits.h>
//************************************************************************ //////////////////////////////////////////////////////////////////////////
//**** GLFW internal functions **** ////// GLFW platform API //////
//************************************************************************ //////////////////////////////////////////////////////////////////////////
//======================================================================== //========================================================================
// Save the gamma ramp to our internal copy // Retrieve the currently set gamma ramp
//======================================================================== //========================================================================
void _glfwPlatformSaveGammaRamp(int ramp) void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
{ {
if (!_glfwLibrary.gammaSize) _glfw_GetDeviceGammaRamp(GetDC(GetDesktopWindow()), (WORD*) ramp);
{
return;
}
_glfw_GetDeviceGammaRamp(_glfwLibrary.Win32.desktopDC,
_glfwLibrary.gammaRamp[ramp]);
} }
//======================================================================== //========================================================================
// Restore the gamma ramp to our internal copy of the gamma ramp // Push the specified gamma ramp to the monitor
//======================================================================== //========================================================================
void _glfwPlatformRestoreGammaRamp(int ramp) void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp)
{
if (!_glfwLibrary.gammaSize)
{ {
return; _glfw_SetDeviceGammaRamp(GetDC(GetDesktopWindow()), (WORD*) ramp);
}
_glfw_SetDeviceGammaRamp(_glfwLibrary.Win32.desktopDC,
_glfwLibrary.gammaRamp[ramp]);
} }

19
src/win32/win32_init.c
Unescape View File

@ -160,18 +160,9 @@ int _glfwPlatformInit(void)
_glfwLibrary.Win32.instance = GetModuleHandle(NULL); _glfwLibrary.Win32.instance = GetModuleHandle(NULL);
// Initialise the internal gamma ramp
_glfwLibrary.gammaSize = 256;
_glfwLibrary.gammaRamp[GLFW_GAMMA_ORIG] =
malloc(256 * sizeof(unsigned short) * 3);
_glfwLibrary.gammaRamp[GLFW_GAMMA_CURR] =
malloc(256 * sizeof(unsigned short) * 3);
// Get the desktop DC
_glfwLibrary.Win32.desktopDC = GetDC(GetDesktopWindow());
// Save the original gamma ramp // Save the original gamma ramp
_glfwPlatformSaveGammaRamp(GLFW_GAMMA_ORIG); _glfwLibrary.originalRampSize = 256;
_glfwPlatformGetGammaRamp(&_glfwLibrary.originalRamp);
_glfwInitTimer(); _glfwInitTimer();
@ -186,11 +177,7 @@ int _glfwPlatformInit(void)
int _glfwPlatformTerminate(void) int _glfwPlatformTerminate(void)
{ {
// Restore the original gamma ramp // Restore the original gamma ramp
_glfwPlatformRestoreGammaRamp(GLFW_GAMMA_ORIG); _glfwPlatformSetGammaRamp(&_glfwLibrary.originalRamp);
// Free the gamma ramps
free(_glfwLibrary.gammaRamp[GLFW_GAMMA_ORIG]);
free(_glfwLibrary.gammaRamp[GLFW_GAMMA_CURR]);
if (_glfwLibrary.Win32.classAtom) if (_glfwLibrary.Win32.classAtom)
{ {

18
src/win32/win32_window.c
Unescape View File

@ -713,8 +713,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
{ {
window->iconified = iconified; window->iconified = iconified;
if (window->windowIconifyCallback) if (_glfwLibrary.windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified); _glfwLibrary.windowIconifyCallback(window, window->iconified);
} }
return 0; return 0;
@ -756,7 +756,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
{ {
_glfwInputKey(window, translateKey(wParam, lParam), GLFW_PRESS); _glfwInputKey(window, translateKey(wParam, lParam), GLFW_PRESS);
if (window->charCallback) if (_glfwLibrary.charCallback)
translateChar(window, (DWORD) wParam, (DWORD) lParam); translateChar(window, (DWORD) wParam, (DWORD) lParam);
return 0; return 0;
@ -879,9 +879,9 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
window->Win32.oldMouseY = newMouseY; window->Win32.oldMouseY = newMouseY;
window->Win32.mouseMoved = GL_TRUE; window->Win32.mouseMoved = GL_TRUE;
if (window->mousePosCallback) if (_glfwLibrary.mousePosCallback)
{ {
window->mousePosCallback(window, _glfwLibrary.mousePosCallback(window,
window->mousePosX, window->mousePosX,
window->mousePosY); window->mousePosY);
} }
@ -917,8 +917,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
ClipCursor(&ClipWindowRect); ClipCursor(&ClipWindowRect);
} }
if (window->windowSizeCallback) if (_glfwLibrary.windowSizeCallback)
window->windowSizeCallback(window, window->width, window->height); _glfwLibrary.windowSizeCallback(window, window->width, window->height);
return 0; return 0;
} }
@ -941,8 +941,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
// Was the window contents damaged? // Was the window contents damaged?
case WM_PAINT: case WM_PAINT:
{ {
if (window->windowRefreshCallback) if (_glfwLibrary.windowRefreshCallback)
window->windowRefreshCallback(window); _glfwLibrary.windowRefreshCallback(window);
break; break;
} }

53
src/window.c
Unescape View File

@ -55,8 +55,8 @@ static void closeFlaggedWindows(void)
for (window = _glfwLibrary.windowListHead; window; ) for (window = _glfwLibrary.windowListHead; window; )
{ {
if (window->closeRequested && window->windowCloseCallback) if (window->closeRequested && _glfwLibrary.windowCloseCallback)
window->closeRequested = window->windowCloseCallback(window); window->closeRequested = _glfwLibrary.windowCloseCallback(window);
if (window->closeRequested) if (window->closeRequested)
{ {
@ -144,8 +144,8 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
} }
// Call user callback function // Call user callback function
if (window->keyCallback && (window->keyRepeat || !keyrepeat)) if (_glfwLibrary.keyCallback && (window->keyRepeat || !keyrepeat))
window->keyCallback(window, key, action); _glfwLibrary.keyCallback(window, key, action);
} }
@ -159,8 +159,8 @@ void _glfwInputChar(_GLFWwindow* window, int character)
if (!((character >= 32 && character <= 126) || character >= 160)) if (!((character >= 32 && character <= 126) || character >= 160))
return; return;
if (window->charCallback) if (_glfwLibrary.charCallback)
window->charCallback(window, character); _glfwLibrary.charCallback(window, character);
} }
@ -173,8 +173,8 @@ void _glfwInputScroll(_GLFWwindow* window, int x, int y)
window->scrollX += x; window->scrollX += x;
window->scrollY += y; window->scrollY += y;
if (window->scrollCallback) if (_glfwLibrary.scrollCallback)
window->scrollCallback(window, x, y); _glfwLibrary.scrollCallback(window, x, y);
} }
@ -193,8 +193,8 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
else else
window->mouseButton[button] = (char) action; window->mouseButton[button] = (char) action;
if (window->mouseButtonCallback) if (_glfwLibrary.mouseButtonCallback)
window->mouseButtonCallback(window, button, action); _glfwLibrary.mouseButtonCallback(window, button, action);
} }
@ -210,8 +210,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
{ {
_glfwLibrary.activeWindow = window; _glfwLibrary.activeWindow = window;
if (window->windowFocusCallback) if (_glfwLibrary.windowFocusCallback)
window->windowFocusCallback(window, activated); _glfwLibrary.windowFocusCallback(window, activated);
} }
} }
else else
@ -236,8 +236,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
_glfwLibrary.activeWindow = NULL; _glfwLibrary.activeWindow = NULL;
if (window->windowFocusCallback) if (_glfwLibrary.windowFocusCallback)
window->windowFocusCallback(window, activated); _glfwLibrary.windowFocusCallback(window, activated);
} }
} }
} }
@ -1076,7 +1076,7 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window)
// Set callback function for window size changes // Set callback function for window size changes
//======================================================================== //========================================================================
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun) GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -1084,19 +1084,24 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfu
return; return;
} }
window->windowSizeCallback = cbfun; _glfwLibrary.windowSizeCallback = cbfun;
// Call the callback function to let the application know the current // Call the callback function to let the application know the current
// window size // window size
if (cbfun) if (cbfun)
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
cbfun(window, window->width, window->height); cbfun(window, window->width, window->height);
} }
}
//======================================================================== //========================================================================
// Set callback function for window close events // Set callback function for window close events
//======================================================================== //========================================================================
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun) GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -1104,7 +1109,7 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cb
return; return;
} }
window->windowCloseCallback = cbfun; _glfwLibrary.windowCloseCallback = cbfun;
} }
@ -1112,7 +1117,7 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cb
// Set callback function for window refresh events // Set callback function for window refresh events
//======================================================================== //========================================================================
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun) GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -1120,7 +1125,7 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfu
return; return;
} }
window->windowRefreshCallback = cbfun; _glfwLibrary.windowRefreshCallback = cbfun;
} }
@ -1128,7 +1133,7 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfu
// Set callback function for window focus events // Set callback function for window focus events
//======================================================================== //========================================================================
GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun) GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -1136,7 +1141,7 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cb
return; return;
} }
window->windowFocusCallback = cbfun; _glfwLibrary.windowFocusCallback = cbfun;
} }
@ -1144,7 +1149,7 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cb
// Set callback function for window iconification events // Set callback function for window iconification events
//======================================================================== //========================================================================
GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun) GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun)
{ {
if (!_glfwInitialized) if (!_glfwInitialized)
{ {
@ -1152,7 +1157,7 @@ GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfu
return; return;
} }
window->windowIconifyCallback = cbfun; _glfwLibrary.windowIconifyCallback = cbfun;
} }

9
src/x11/CMakeLists.txt
Unescape View File

@ -1,6 +1,5 @@
configure_file( configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY) ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
include_directories(${CMAKE_CURRENT_SOURCE_DIR} include_directories(${CMAKE_CURRENT_SOURCE_DIR}
@ -8,8 +7,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_BINARY_DIR}/src ${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR}) ${GLFW_INCLUDE_DIR})
set(libglfw_SOURCES set(libglfw_SOURCES ${common_SOURCES}
${common_SOURCES}
x11_enable.c x11_enable.c
x11_fullscreen.c x11_fullscreen.c
x11_gamma.c x11_gamma.c
@ -25,8 +23,7 @@ add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${GLFW_LIBRARIES}) target_link_libraries(libglfwShared ${GLFW_LIBRARIES})
set_target_properties(libglfwStatic libglfwShared PROPERTIES set_target_properties(libglfwStatic libglfwShared PROPERTIES
CLEAN_DIRECT_OUTPUT 1 CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw OUTPUT_NAME glfw)
)
install(TARGETS libglfwStatic libglfwShared DESTINATION lib) install(TARGETS libglfwStatic libglfwShared DESTINATION lib)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc DESTINATION lib/pkgconfig) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc DESTINATION lib/pkgconfig)

12
src/x11/x11_gamma.c
Unescape View File

@ -33,12 +33,12 @@
#include <string.h> #include <string.h>
//************************************************************************ //////////////////////////////////////////////////////////////////////////
//**** GLFW internal functions **** ////// GLFW platform API //////
//************************************************************************ //////////////////////////////////////////////////////////////////////////
//======================================================================== //========================================================================
// Save the original gamma ramp so that we can restore it later // Retrieve the currently set gamma ramp
//======================================================================== //========================================================================
void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp) void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
@ -55,6 +55,8 @@ void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfwLibrary.X11.display, XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfwLibrary.X11.display,
rr->crtcs[0]); rr->crtcs[0]);
// TODO: Handle case of original ramp size having a size other than 256
memcpy(ramp->red, gamma->red, size); memcpy(ramp->red, gamma->red, size);
memcpy(ramp->green, gamma->green, size); memcpy(ramp->green, gamma->green, size);
memcpy(ramp->blue, gamma->blue, size); memcpy(ramp->blue, gamma->blue, size);
@ -78,7 +80,7 @@ void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
//======================================================================== //========================================================================
// Make the specified gamma ramp current // Push the specified gamma ramp to the monitor
//======================================================================== //========================================================================
void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp) void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp)

8
src/x11/x11_init.c
Unescape View File

@ -176,7 +176,7 @@ static void initGammaRamp(void)
#endif /*_GLFW_HAS_XF86VIDMODE*/ #endif /*_GLFW_HAS_XF86VIDMODE*/
if (!_glfwLibrary.originalRampSize) if (!_glfwLibrary.originalRampSize)
fprintf(stderr, "Gamma ramp setting unsupported\n"); fprintf(stderr, "No supported gamma ramp API found\n");
// Save the original gamma ramp // Save the original gamma ramp
_glfwPlatformGetGammaRamp(&_glfwLibrary.originalRamp); _glfwPlatformGetGammaRamp(&_glfwLibrary.originalRamp);
@ -310,14 +310,14 @@ const char* _glfwPlatformGetVersionString(void)
#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT) #elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
" glXGetProcAddressEXT" " glXGetProcAddressEXT"
#elif defined(_GLFW_DLOPEN_LIBGL) #elif defined(_GLFW_DLOPEN_LIBGL)
" dlopen(libGL)" " dlsym(libGL)"
#else #else
" (no OpenGL extension support)" " (no OpenGL extension support)"
#endif #endif
#if defined(_GLFW_USE_LINUX_JOYSTICKS) #if defined(_GLFW_USE_LINUX_JOYSTICKS)
" Linux joystick API" " Linux-joystick-API"
#else #else
" (no joystick support)" " no-joystick-support"
#endif #endif
; ;

20
src/x11/x11_window.c
Unescape View File

@ -1197,9 +1197,9 @@ static void processSingleEvent(void)
window->X11.cursorPosY = event.xmotion.y; window->X11.cursorPosY = event.xmotion.y;
window->X11.mouseMoved = GL_TRUE; window->X11.mouseMoved = GL_TRUE;
if (window->mousePosCallback) if (_glfwLibrary.mousePosCallback)
{ {
window->mousePosCallback(window, _glfwLibrary.mousePosCallback(window,
window->mousePosX, window->mousePosX,
window->mousePosY); window->mousePosY);
} }
@ -1224,9 +1224,9 @@ static void processSingleEvent(void)
window->width = event.xconfigure.width; window->width = event.xconfigure.width;
window->height = event.xconfigure.height; window->height = event.xconfigure.height;
if (window->windowSizeCallback) if (_glfwLibrary.windowSizeCallback)
{ {
window->windowSizeCallback(window, _glfwLibrary.windowSizeCallback(window,
window->width, window->width,
window->height); window->height);
} }
@ -1288,8 +1288,8 @@ static void processSingleEvent(void)
window->iconified = GL_FALSE; window->iconified = GL_FALSE;
if (window->windowIconifyCallback) if (_glfwLibrary.windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified); _glfwLibrary.windowIconifyCallback(window, window->iconified);
break; break;
} }
@ -1306,8 +1306,8 @@ static void processSingleEvent(void)
window->iconified = GL_TRUE; window->iconified = GL_TRUE;
if (window->windowIconifyCallback) if (_glfwLibrary.windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified); _glfwLibrary.windowIconifyCallback(window, window->iconified);
break; break;
} }
@ -1358,8 +1358,8 @@ static void processSingleEvent(void)
return; return;
} }
if (window->windowRefreshCallback) if (_glfwLibrary.windowRefreshCallback)
window->windowRefreshCallback(window); _glfwLibrary.windowRefreshCallback(window);
break; break;
} }

4
tests/accuracy.c
Unescape View File

@ -74,8 +74,8 @@ int main(void)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
glfwSetMousePosCallback(window, mouse_position_callback); glfwSetMousePosCallback(mouse_position_callback);
glfwSetWindowSizeCallback(window, window_size_callback); glfwSetWindowSizeCallback(window_size_callback);
glfwSwapInterval(1); glfwSwapInterval(1);
glClearColor(0, 0, 0, 0); glClearColor(0, 0, 0, 0);

20
tests/events.c
Unescape View File

@ -303,16 +303,16 @@ int main(void)
glfwSwapInterval(1); glfwSwapInterval(1);
glfwSetWindowSizeCallback(window, window_size_callback); glfwSetWindowSizeCallback(window_size_callback);
glfwSetWindowCloseCallback(window, window_close_callback); glfwSetWindowCloseCallback(window_close_callback);
glfwSetWindowRefreshCallback(window, window_refresh_callback); glfwSetWindowRefreshCallback(window_refresh_callback);
glfwSetWindowFocusCallback(window, window_focus_callback); glfwSetWindowFocusCallback(window_focus_callback);
glfwSetWindowIconifyCallback(window, window_iconify_callback); glfwSetWindowIconifyCallback(window_iconify_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback); glfwSetMouseButtonCallback(mouse_button_callback);
glfwSetMousePosCallback(window, mouse_position_callback); glfwSetMousePosCallback(mouse_position_callback);
glfwSetScrollCallback(window, scroll_callback); glfwSetScrollCallback(scroll_callback);
glfwSetKeyCallback(window, key_callback); glfwSetKeyCallback(key_callback);
glfwSetCharCallback(window, char_callback); glfwSetCharCallback(char_callback);
printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled"); printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled");
printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled"); printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled");

2
tests/fsaa.c
Unescape View File

@ -65,7 +65,7 @@ int main(void)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
glfwSetWindowSizeCallback(window, window_size_callback); glfwSetWindowSizeCallback(window_size_callback);
glfwSwapInterval(1); glfwSwapInterval(1);
samples = glfwGetWindowParam(window, GLFW_FSAA_SAMPLES); samples = glfwGetWindowParam(window, GLFW_FSAA_SAMPLES);

6
tests/fsfocus.c
Unescape View File

@ -93,9 +93,9 @@ int main(void)
glfwSwapInterval(1); glfwSwapInterval(1);
glfwEnable(window, GLFW_MOUSE_CURSOR); glfwEnable(window, GLFW_MOUSE_CURSOR);
glfwSetWindowFocusCallback(window, window_focus_callback); glfwSetWindowFocusCallback(window_focus_callback);
glfwSetKeyCallback(window, window_key_callback); glfwSetKeyCallback(window_key_callback);
glfwSetWindowCloseCallback(window, window_close_callback); glfwSetWindowCloseCallback(window_close_callback);
while (running && glfwIsWindow(window) == GL_TRUE) while (running && glfwIsWindow(window) == GL_TRUE)
{ {

4
tests/gamma.c
Unescape View File

@ -149,8 +149,8 @@ int main(int argc, char** argv)
ggamma, ggain, gblacklevel); ggamma, ggain, gblacklevel);
glfwSwapInterval(1); glfwSwapInterval(1);
glfwSetKeyCallback(window, key_callback); glfwSetKeyCallback(key_callback);
glfwSetWindowSizeCallback(window, size_callback); glfwSetWindowSizeCallback(size_callback);
glEnable(GL_SCISSOR_TEST); glEnable(GL_SCISSOR_TEST);

4
tests/iconify.c
Unescape View File

@ -119,8 +119,8 @@ int main(int argc, char** argv)
} }
glfwSwapInterval(1); glfwSwapInterval(1);
glfwSetKeyCallback(window, key_callback); glfwSetKeyCallback(key_callback);
glfwSetWindowSizeCallback(window, size_callback); glfwSetWindowSizeCallback(size_callback);
glEnable(GL_SCISSOR_TEST); glEnable(GL_SCISSOR_TEST);

6
tests/peter.c
Unescape View File

@ -96,9 +96,9 @@ static GLboolean open_window(void)
glfwGetMousePos(window_handle, &x, &y); glfwGetMousePos(window_handle, &x, &y);
printf("Mouse position: %i %i\n", x, y); printf("Mouse position: %i %i\n", x, y);
glfwSetWindowSizeCallback(window_handle, window_size_callback); glfwSetWindowSizeCallback(window_size_callback);
glfwSetMousePosCallback(window_handle, mouse_position_callback); glfwSetMousePosCallback(mouse_position_callback);
glfwSetKeyCallback(window_handle, key_callback); glfwSetKeyCallback(key_callback);
glfwSwapInterval(1); glfwSwapInterval(1);
return GL_TRUE; return GL_TRUE;

6
tests/reopen.c
Unescape View File

@ -91,9 +91,9 @@ static int open_window(int width, int height, int mode)
return 0; return 0;
} }
glfwSetWindowSizeCallback(window_handle, window_size_callback); glfwSetWindowSizeCallback(window_size_callback);
glfwSetWindowCloseCallback(window_handle, window_close_callback); glfwSetWindowCloseCallback(window_close_callback);
glfwSetKeyCallback(window_handle, key_callback); glfwSetKeyCallback(key_callback);
glfwSwapInterval(1); glfwSwapInterval(1);
printf("Opening %s mode window took %0.3f seconds\n", printf("Opening %s mode window took %0.3f seconds\n",

2
tests/sharing.c
Unescape View File

@ -49,7 +49,7 @@ static GLFWwindow open_window(const char* title, GLFWwindow share)
if (!window) if (!window)
return NULL; return NULL;
glfwSetKeyCallback(window, key_callback); glfwSetKeyCallback(key_callback);
glfwSwapInterval(1); glfwSwapInterval(1);
return window; return window;

2
tests/tearing.c
Unescape View File

@ -59,7 +59,7 @@ int main(void)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
glfwSetWindowSizeCallback(window, window_size_callback); glfwSetWindowSizeCallback(window_size_callback);
glfwSwapInterval(1); glfwSwapInterval(1);
glClearColor(0.f, 0.f, 0.f, 0.f); glClearColor(0.f, 0.f, 0.f, 0.f);

Write Preview
Loading…
Cancel
Save