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

Merge fix.

Browse Source
This commit is contained in:
Camilla Berglund 2010-10-24 23:41:34 +02:00
commit 7eea9b2384
36 changed files with 656 additions and 830 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

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

2
examples/boing.c
View File

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

4
examples/gears.c
View File

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

4
examples/heightmap.c
View File

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

122
examples/mipmaps.c
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
View File

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

34
examples/triangle.c
View File

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

232
examples/wave.c
View File

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

20
include/GL/glfw3.h
View File

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

13
src/cocoa/CMakeLists.txt
View File

@ -1,6 +1,5 @@
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)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}
@ -8,8 +7,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR})
set(cocoa_SOURCES
cocoa_enable.m
set(cocoa_SOURCES cocoa_enable.m
cocoa_fullscreen.m
cocoa_gamma.m
cocoa_glext.m
@ -21,17 +19,14 @@ set(cocoa_SOURCES
# For some reason, CMake doesn't know about .m
set_source_files_properties(${cocoa_SOURCES} PROPERTIES LANGUAGE C)
set(libglfw_SOURCES
${common_SOURCES}
${cocoa_SOURCES})
set(libglfw_SOURCES ${common_SOURCES} ${cocoa_SOURCES})
add_library(libglfwStatic STATIC ${libglfw_SOURCES})
add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${GLFW_LIBRARIES})
set_target_properties(libglfwStatic libglfwShared PROPERTIES
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
get_target_property(CFLAGS libglfwShared COMPILE_FLAGS)

16
src/cocoa/cocoa_window.m
View File

@ -70,8 +70,8 @@
window->width = contentRect.size.width;
window->height = contentRect.size.height;
if (window->windowSizeCallback)
window->windowSizeCallback(window, window->width, window->height);
if (_glfwLibrary.windowSizeCallback)
_glfwLibrary.windowSizeCallback(window, window->width, window->height);
}
- (void)windowDidMove:(NSNotification *)notification
@ -95,16 +95,16 @@
{
window->iconified = GL_TRUE;
if (window->windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified);
if (_glfwLibrary.windowIconifyCallback)
_glfwLibrary.windowIconifyCallback(window, window->iconified);
}
- (void)windowDidDeminiaturize:(NSNotification *)notification
{
window->iconified = GL_FALSE;
if (window->windowIconifyCallback)
window->windowIconifyCallback(window, window->iconified);
if (_glfwLibrary.windowIconifyCallback)
_glfwLibrary.windowIconifyCallback(window, window->iconified);
}
- (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;
}
if (window->mousePosCallback)
window->mousePosCallback(window, window->mousePosX, window->mousePosY);
if (_glfwLibrary.mousePosCallback)
_glfwLibrary.mousePosCallback(window, window->mousePosX, window->mousePosY);
}
- (void)rightMouseDown:(NSEvent *)event

4
src/enable.c
View File

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

2
src/gamma.c
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)

30
src/input.c
View File

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

23
src/internal.h
View File

@ -152,18 +152,6 @@ struct _GLFWwindow
{
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
GLboolean iconified; // GL_TRUE if this window is iconified
GLboolean closeRequested; // GL_TRUE if this window should be closed
@ -223,6 +211,17 @@ struct _GLFWlibrary
_GLFWwindow* activeWindow;
_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 originalRamp;
int originalRampSize;

12
src/win32/CMakeLists.txt
View File

@ -1,7 +1,7 @@
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)
# 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_INCLUDE_DIR})
set(libglfw_SOURCES
${common_SOURCES}
set(libglfw_SOURCES ${common_SOURCES}
win32_enable.c
win32_fullscreen.c
win32_gamma.c
@ -47,8 +46,9 @@ set_target_properties(libglfwStatic libglfwShared PROPERTIES
if(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 LINK_FLAGS "-mwin32 -mno-cygwin")
set_target_properties(libglfwStatic libglfwShared PROPERTIES
COMPILE_FLAGS "-mwin32 -mno-cygwin"
LINK_FLAGS "-mwin32 -mno-cygwin")
endif(CYGWIN)
install(TARGETS libglfwStatic libglfwShared DESTINATION lib)

1
src/win32/platform.h
View File

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

34
src/win32/win32_gamma.c
View File

@ -1,11 +1,10 @@
//========================================================================
// GLFW - An OpenGL framework
// Platform: Win32/WGL
// API version: 2.7
// API version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
@ -33,35 +32,26 @@
#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)
{
return;
}
_glfw_GetDeviceGammaRamp(_glfwLibrary.Win32.desktopDC,
_glfwLibrary.gammaRamp[ramp]);
_glfw_GetDeviceGammaRamp(GetDC(GetDesktopWindow()), (WORD*) 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(_glfwLibrary.Win32.desktopDC,
_glfwLibrary.gammaRamp[ramp]);
_glfw_SetDeviceGammaRamp(GetDC(GetDesktopWindow()), (WORD*) ramp);
}

19
src/win32/win32_init.c
View File

@ -160,18 +160,9 @@ int _glfwPlatformInit(void)
_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
_glfwPlatformSaveGammaRamp(GLFW_GAMMA_ORIG);
_glfwLibrary.originalRampSize = 256;
_glfwPlatformGetGammaRamp(&_glfwLibrary.originalRamp);
_glfwInitTimer();
@ -186,11 +177,7 @@ int _glfwPlatformInit(void)
int _glfwPlatformTerminate(void)
{
// Restore the original gamma ramp
_glfwPlatformRestoreGammaRamp(GLFW_GAMMA_ORIG);
// Free the gamma ramps
free(_glfwLibrary.gammaRamp[GLFW_GAMMA_ORIG]);
free(_glfwLibrary.gammaRamp[GLFW_GAMMA_CURR]);
_glfwPlatformSetGammaRamp(&_glfwLibrary.originalRamp);
if (_glfwLibrary.Win32.classAtom)
{

18
src/win32/win32_window.c
View File

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

53
src/window.c
View File

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

9
src/x11/CMakeLists.txt
View File

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

12
src/x11/x11_gamma.c
View File

@ -33,12 +33,12 @@
#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)
@ -55,6 +55,8 @@ void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfwLibrary.X11.display,
rr->crtcs[0]);
// TODO: Handle case of original ramp size having a size other than 256
memcpy(ramp->red, gamma->red, size);
memcpy(ramp->green, gamma->green, 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)

8
src/x11/x11_init.c
View File

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

20
src/x11/x11_window.c
View File

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

4
tests/accuracy.c
View File

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

20
tests/events.c
View File

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

2
tests/fsaa.c
View File

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

6
tests/fsfocus.c
View File

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

4
tests/gamma.c
View File

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

4
tests/iconify.c
View File

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

6
tests/peter.c
View File

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

6
tests/reopen.c
View File

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

2
tests/sharing.c
View File

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

2
tests/tearing.c
View File

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