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.

310
examples/splitview.c
View File

@ -50,48 +50,49 @@ static int do_redraw = 1;
#define TORUS_MAJOR_RES 32
#define TORUS_MINOR_RES 32
static void drawTorus( void )
static void drawTorus(void)
{
static GLuint torus_list = 0;
int i, j, k;
double s, t, x, y, z, nx, ny, nz, scale, twopi;
if( !torus_list )
if (!torus_list)
{
// Start recording displaylist
torus_list = glGenLists( 1 );
glNewList( torus_list, GL_COMPILE_AND_EXECUTE );
torus_list = glGenLists(1);
glNewList(torus_list, GL_COMPILE_AND_EXECUTE);
// Draw torus
twopi = 2.0 * M_PI;
for( i = 0; i < TORUS_MINOR_RES; i++ )
for (i = 0; i < TORUS_MINOR_RES; i++)
{
glBegin( GL_QUAD_STRIP );
for( j = 0; j <= TORUS_MAJOR_RES; j++ )
glBegin(GL_QUAD_STRIP);
for (j = 0; j <= TORUS_MAJOR_RES; j++)
{
for( k = 1; k >= 0; k-- )
for (k = 1; k >= 0; k--)
{
s = (i + k) % TORUS_MINOR_RES + 0.5;
t = j % TORUS_MAJOR_RES;
// Calculate point on surface
x = (TORUS_MAJOR+TORUS_MINOR*cos(s*twopi/TORUS_MINOR_RES))*cos(t*twopi/TORUS_MAJOR_RES);
x = (TORUS_MAJOR + TORUS_MINOR * cos(s * twopi / TORUS_MINOR_RES)) * cos(t * twopi / TORUS_MAJOR_RES);
y = TORUS_MINOR * sin(s * twopi / TORUS_MINOR_RES);
z = (TORUS_MAJOR+TORUS_MINOR*cos(s*twopi/TORUS_MINOR_RES))*sin(t*twopi/TORUS_MAJOR_RES);
z = (TORUS_MAJOR + TORUS_MINOR * cos(s * twopi / TORUS_MINOR_RES)) * sin(t * twopi / TORUS_MAJOR_RES);
// Calculate surface normal
nx = x - TORUS_MAJOR*cos(t*twopi/TORUS_MAJOR_RES);
nx = x - TORUS_MAJOR * cos(t * twopi / TORUS_MAJOR_RES);
ny = y;
nz = z - TORUS_MAJOR*sin(t*twopi/TORUS_MAJOR_RES);
scale = 1.0 / sqrt( nx*nx + ny*ny + nz*nz );
nz = z - TORUS_MAJOR * sin(t * twopi / TORUS_MAJOR_RES);
scale = 1.0 / sqrt(nx*nx + ny*ny + nz*nz);
nx *= scale;
ny *= scale;
nz *= scale;
glNormal3f( (float)nx, (float)ny, (float)nz );
glVertex3f( (float)x, (float)y, (float)z );
glNormal3f((float) nx, (float) ny, (float) nz);
glVertex3f((float) x, (float) y, (float) z);
}
}
glEnd();
}
@ -101,7 +102,7 @@ static void drawTorus( void )
else
{
// Playback displaylist
glCallList( torus_list );
glCallList(torus_list);
}
}
@ -110,7 +111,7 @@ static void drawTorus( void )
// Draw the scene (a rotating torus)
//========================================================================
static void drawScene( void )
static void drawScene(void)
{
const GLfloat model_diffuse[4] = {1.0f, 0.8f, 0.8f, 1.0f};
const GLfloat model_specular[4] = {0.6f, 0.6f, 0.6f, 1.0f};
@ -119,17 +120,17 @@ static void drawScene( void )
glPushMatrix();
// Rotate the object
glRotatef( (GLfloat)rot_x*0.5f, 1.0f, 0.0f, 0.0f );
glRotatef( (GLfloat)rot_y*0.5f, 0.0f, 1.0f, 0.0f );
glRotatef( (GLfloat)rot_z*0.5f, 0.0f, 0.0f, 1.0f );
glRotatef((GLfloat) rot_x * 0.5f, 1.0f, 0.0f, 0.0f);
glRotatef((GLfloat) rot_y * 0.5f, 0.0f, 1.0f, 0.0f);
glRotatef((GLfloat) rot_z * 0.5f, 0.0f, 0.0f, 1.0f);
// Set model color (used for orthogonal views, lighting disabled)
glColor4fv( model_diffuse );
glColor4fv(model_diffuse);
// Set model material (used for perspective view, lighting enabled)
glMaterialfv( GL_FRONT, GL_DIFFUSE, model_diffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, model_specular );
glMaterialf( GL_FRONT, GL_SHININESS, model_shininess );
glMaterialfv(GL_FRONT, GL_DIFFUSE, model_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, model_specular);
glMaterialf(GL_FRONT, GL_SHININESS, model_shininess);
// Draw torus
drawTorus();
@ -142,55 +143,55 @@ static void drawScene( void )
// Draw a 2D grid (used for orthogonal views)
//========================================================================
static void drawGrid( float scale, int steps )
static void drawGrid(float scale, int steps)
{
int i;
int i;
float x, y;
glPushMatrix();
// Set background to some dark bluish grey
glClearColor( 0.05f, 0.05f, 0.2f, 0.0f);
glClear( GL_COLOR_BUFFER_BIT );
glClearColor(0.05f, 0.05f, 0.2f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Setup modelview matrix (flat XY view)
glLoadIdentity();
gluLookAt( 0.0, 0.0, 1.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0 );
gluLookAt(0.0, 0.0, 1.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
// We don't want to update the Z-buffer
glDepthMask( GL_FALSE );
glDepthMask(GL_FALSE);
// Set grid color
glColor3f( 0.0f, 0.5f, 0.5f );
glColor3f(0.0f, 0.5f, 0.5f);
glBegin( GL_LINES );
glBegin(GL_LINES);
// Horizontal lines
x = scale * 0.5f * (float)(steps-1);
y = -scale * 0.5f * (float)(steps-1);
for( i = 0; i < steps; i ++ )
x = scale * 0.5f * (float) (steps - 1);
y = -scale * 0.5f * (float) (steps - 1);
for (i = 0; i < steps; i++)
{
glVertex3f( -x, y, 0.0f );
glVertex3f( x, y, 0.0f );
glVertex3f(-x, y, 0.0f);
glVertex3f(x, y, 0.0f);
y += scale;
}
// Vertical lines
x = -scale * 0.5f * (float)(steps-1);
y = scale * 0.5f * (float)(steps-1);
for( i = 0; i < steps; i ++ )
x = -scale * 0.5f * (float) (steps - 1);
y = scale * 0.5f * (float) (steps - 1);
for (i = 0; i < steps; i++)
{
glVertex3f( x, -y, 0.0f );
glVertex3f( x, y, 0.0f );
glVertex3f(x, -y, 0.0f);
glVertex3f(x, y, 0.0f);
x += scale;
}
glEnd();
// Enable Z-buffer writing again
glDepthMask( GL_TRUE );
glDepthMask(GL_TRUE);
glPopMatrix();
}
@ -200,7 +201,7 @@ static void drawGrid( float scale, int steps )
// Draw all views
//========================================================================
static void drawAllViews( void )
static void drawAllViews(void)
{
const GLfloat light_position[4] = {0.0f, 8.0f, 8.0f, 1.0f};
const GLfloat light_diffuse[4] = {1.0f, 1.0f, 1.0f, 1.0f};
@ -209,145 +210,142 @@ static void drawAllViews( void )
double aspect;
// Calculate aspect of window
if( height > 0 )
{
aspect = (double)width / (double)height;
}
if (height > 0)
aspect = (double) width / (double) height;
else
{
aspect = 1.0;
}
// Clear screen
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Enable scissor test
glEnable( GL_SCISSOR_TEST );
glEnable(GL_SCISSOR_TEST);
// Enable depth test
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// ** ORTHOGONAL VIEWS **
// For orthogonal views, use wireframe rendering
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Enable line anti-aliasing
glEnable( GL_LINE_SMOOTH );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Setup orthogonal projection matrix
glMatrixMode( GL_PROJECTION );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho( -3.0*aspect, 3.0*aspect, -3.0, 3.0, 1.0, 50.0 );
glOrtho(-3.0 * aspect, 3.0 * aspect, -3.0, 3.0, 1.0, 50.0);
// Upper left view (TOP VIEW)
glViewport( 0, height/2, width/2, height/2 );
glScissor( 0, height/2, width/2, height/2 );
glMatrixMode( GL_MODELVIEW );
glViewport(0, height / 2, width / 2, height / 2);
glScissor(0, height / 2, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( 0.0f, 10.0f, 1e-3f, // Eye-position (above)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f ); // Up-vector
drawGrid( 0.5, 12 );
gluLookAt(0.0f, 10.0f, 1e-3f, // Eye-position (above)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
drawGrid(0.5, 12);
drawScene();
// Lower left view (FRONT VIEW)
glViewport( 0, 0, width/2, height/2 );
glScissor( 0, 0, width/2, height/2 );
glMatrixMode( GL_MODELVIEW );
glViewport(0, 0, width / 2, height / 2);
glScissor(0, 0, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( 0.0f, 0.0f, 10.0f, // Eye-position (in front of)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f ); // Up-vector
drawGrid( 0.5, 12 );
gluLookAt(0.0f, 0.0f, 10.0f, // Eye-position (in front of)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
drawGrid(0.5, 12);
drawScene();
// Lower right view (SIDE VIEW)
glViewport( width/2, 0, width/2, height/2 );
glScissor( width/2, 0, width/2, height/2 );
glMatrixMode( GL_MODELVIEW );
glViewport(width / 2, 0, width / 2, height / 2);
glScissor(width / 2, 0, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( 10.0f, 0.0f, 0.0f, // Eye-position (to the right)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f ); // Up-vector
drawGrid( 0.5, 12 );
gluLookAt(10.0f, 0.0f, 0.0f, // Eye-position (to the right)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
drawGrid(0.5, 12);
drawScene();
// Disable line anti-aliasing
glDisable( GL_LINE_SMOOTH );
glDisable( GL_BLEND );
glDisable(GL_LINE_SMOOTH);
glDisable(GL_BLEND);
// ** PERSPECTIVE VIEW **
// For perspective view, use solid rendering
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Enable face culling (faster rendering)
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glFrontFace( GL_CW );
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
// Setup perspective projection matrix
glMatrixMode( GL_PROJECTION );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective( 65.0f, aspect, 1.0f, 50.0f );
gluPerspective(65.0f, aspect, 1.0f, 50.0f);
// Upper right view (PERSPECTIVE VIEW)
glViewport( width/2, height/2, width/2, height/2 );
glScissor( width/2, height/2, width/2, height/2 );
glMatrixMode( GL_MODELVIEW );
glViewport(width / 2, height / 2, width / 2, height / 2);
glScissor(width / 2, height / 2, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( 3.0f, 1.5f, 3.0f, // Eye-position
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f ); // Up-vector
gluLookAt(3.0f, 1.5f, 3.0f, // Eye-position
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
// Configure and enable light source 1
glLightfv( GL_LIGHT1, GL_POSITION, light_position );
glLightfv( GL_LIGHT1, GL_AMBIENT, light_ambient );
glLightfv( GL_LIGHT1, GL_DIFFUSE, light_diffuse );
glLightfv( GL_LIGHT1, GL_SPECULAR, light_specular );
glEnable( GL_LIGHT1 );
glEnable( GL_LIGHTING );
glLightfv(GL_LIGHT1, GL_POSITION, light_position);
glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHTING);
// Draw scene
drawScene();
// Disable lighting
glDisable( GL_LIGHTING );
glDisable(GL_LIGHTING);
// Disable face culling
glDisable( GL_CULL_FACE );
glDisable(GL_CULL_FACE);
// Disable depth test
glDisable( GL_DEPTH_TEST );
glDisable(GL_DEPTH_TEST);
// Disable scissor test
glDisable( GL_SCISSOR_TEST );
glDisable(GL_SCISSOR_TEST);
// 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 );
glMatrixMode( GL_PROJECTION );
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 );
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 );
glBegin( GL_LINE_STRIP );
glVertex2i( 0, 0 );
glVertex2i( 1, 0 );
glVertex2i( 1, 1 );
glVertex2i( 0, 1 );
glVertex2i( 0, 0 );
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);
glVertex2i(1, 1);
glVertex2i(0, 1);
glVertex2i(0, 0);
glEnd();
}
}
@ -357,7 +355,7 @@ static void drawAllViews( void )
// Window size callback function
//========================================================================
static void windowSizeFun( GLFWwindow window, int w, int h )
static void windowSizeFun(GLFWwindow window, int w, int h)
{
width = w;
height = h > 0 ? h : 1;
@ -369,7 +367,7 @@ static void windowSizeFun( GLFWwindow window, int w, int h )
// Window refresh callback function
//========================================================================
static void windowRefreshFun( GLFWwindow window )
static void windowRefreshFun(GLFWwindow window)
{
do_redraw = 1;
}
@ -379,10 +377,10 @@ static void windowRefreshFun( GLFWwindow window )
// Mouse position callback function
//========================================================================
static void mousePosFun( GLFWwindow window, int x, int y )
static void mousePosFun(GLFWwindow window, int x, int y)
{
// Depending on which view was selected, rotate around different axes
switch( active_view )
switch (active_view)
{
case 1:
rot_x += y - ypos;
@ -414,25 +412,18 @@ static void mousePosFun( GLFWwindow window, int x, int y )
// Mouse button callback function
//========================================================================
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
active_view = 1;
if( xpos >= width/2 )
{
if (xpos >= width / 2)
active_view += 1;
}
if( ypos >= height/2 )
{
if (ypos >= height / 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
active_view = 0;
@ -443,51 +434,50 @@ static void mouseButtonFun( GLFWwindow window, int button, int action )
//========================================================================
// main()
// main
//========================================================================
int main( void )
int main(void)
{
GLFWwindow window;
// Initialise GLFW
if( !glfwInit() )
if (!glfwInit())
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
fprintf(stderr, "Failed to initialize GLFW\n");
exit(EXIT_FAILURE);
}
glfwOpenWindowHint(GLFW_DEPTH_BITS, 16);
// Open OpenGL window
window = glfwOpenWindow( 500, 500, GLFW_WINDOWED, "Split view demo", NULL );
window = glfwOpenWindow(500, 500, GLFW_WINDOWED, "Split view demo", NULL);
if (!window)
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
fprintf(stderr, "Failed to open GLFW window\n");
exit(EXIT_FAILURE);
}
// Enable vsync
glfwSwapInterval( 1 );
glfwSwapInterval(1);
// Enable sticky keys
glfwEnable( window, GLFW_STICKY_KEYS );
glfwEnable(window, GLFW_STICKY_KEYS);
// Enable mouse cursor (only needed for fullscreen mode)
glfwEnable( window, GLFW_MOUSE_CURSOR );
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
{
// Only redraw if we need to
if( do_redraw )
if (do_redraw)
{
// Draw all views
drawAllViews();
@ -502,12 +492,12 @@ int main( void )
glfwWaitEvents();
} // Check if the ESC key was pressed or the window was closed
while( glfwIsWindow(window) &&
glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS );
while (glfwIsWindow(window) &&
glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS);
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
exit(EXIT_SUCCESS);
}

70
examples/triangle.c
View File

@ -6,77 +6,75 @@
#include <stdio.h>
#include <stdlib.h>
#include <GL/glfw3.h>
int main( void )
int main(void)
{
int width, height, x;
double t;
GLFWwindow window;
// Initialise GLFW
if( !glfwInit() )
if (!glfwInit())
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
fprintf(stderr, "Failed to initialize GLFW\n");
exit(EXIT_FAILURE);
}
// Open a window and create its OpenGL context
window = glfwOpenWindow( 640, 480, GLFW_WINDOWED, "Spinning Triangle", NULL );
window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Spinning Triangle", NULL);
if (!window)
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
fprintf(stderr, "Failed to open GLFW window\n");
exit(EXIT_FAILURE);
}
// Ensure we can capture the escape key being pressed below
glfwEnable( window, GLFW_STICKY_KEYS );
glfwEnable(window, GLFW_STICKY_KEYS);
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
glfwSwapInterval(1);
do
{
t = glfwGetTime();
glfwGetMousePos( window, &x, NULL );
double t = glfwGetTime();
glfwGetMousePos(window, &x, NULL);
// Get window size (may be different than the requested size)
glfwGetWindowSize( window, &width, &height );
glfwGetWindowSize(window, &width, &height);
// Special case: avoid division by zero below
height = height > 0 ? height : 1;
glViewport( 0, 0, width, height );
glViewport(0, 0, width, height);
// Clear color buffer to black
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
glClear( GL_COLOR_BUFFER_BIT );
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
// Select and setup the projection matrix
glMatrixMode( GL_PROJECTION );
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 );
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 );
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.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
@ -84,12 +82,12 @@ int main( void )
glfwPollEvents();
} // Check if the ESC key was pressed or the window was closed
while( glfwIsWindow(window) &&
glfwGetKey( window, GLFW_KEY_ESC ) != GLFW_PRESS );
while (glfwIsWindow(window) &&
glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS);
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
exit(EXIT_SUCCESS);
}

524
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,33 +17,32 @@
#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
{
GLfloat x,y,z;
GLfloat r,g,b;
GLfloat x, y, z;
GLfloat r, g, b;
};
#define GRIDW 50
#define GRIDH 50
#define VERTEXNUM (GRIDW*GRIDH)
#define QUADW (GRIDW-1)
#define QUADH (GRIDH-1)
#define QUADW (GRIDW - 1)
#define QUADH (GRIDH - 1)
#define QUADNUM (QUADW*QUADH)
GLuint quad[4*QUADNUM];
GLuint quad[4 * QUADNUM];
struct Vertex vertex[VERTEXNUM];
/* The grid will look like this:
@ -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;
int x, y, p;
/* place the vertices in a grid */
for(y=0;y<GRIDH;y++)
for(x=0;x<GRIDW;x++)
// Place the vertices in a grid
for (y = 0; y < GRIDH; y++)
{
p = y*GRIDW + x;
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;
if((x%4<2)^(y%4<2))
{
vertex[p].r = 0.0;
}
else
{
vertex[p].r=1.0;
}
vertex[p].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2);
vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2);
vertex[p].z = 0;
vertex[p].g = (GLfloat)y/(GLfloat)GRIDH;
vertex[p].b = 1.f-((GLfloat)x/(GLfloat)GRIDW+(GLfloat)y/(GLfloat)GRIDH)/2.f;
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++)
for (y = 0; y < QUADH; y++)
{
p = 4*(y*QUADW + x);
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,298 +104,287 @@ 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;
int x, y;
double dx, dy, d;
for(y = 0; y<GRIDH; y++)
{
for(x = 0; x<GRIDW; x++)
for (y = 0; y < GRIDH; y++)
{
dx = (double)(x-GRIDW/2);
dy = (double)(y-GRIDH/2);
d = sqrt( dx*dx + dy*dy );
if(d < 0.1 * (double)(GRIDW/2))
{
d = d * 10.0;
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;
for (x = 0; x < GRIDW; x++)
{
dx = (double) (x - GRIDW / 2);
dy = (double) (y - GRIDH / 2);
d = sqrt(dx * dx + dy * dy);
if (d < 0.1 * (double) (GRIDW / 2))
{
d = d * 10.0;
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;
}
}
}
}
/* Draw view */
void draw_screen( void )
//========================================================================
// Draw scene
//========================================================================
void draw_scene(void)
{
/* Clear the color and depth buffers. */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* We don't want to modify the projection matrix. */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// We don't want to modify the projection matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* Move back. */
glTranslatef(0.0, 0.0, -zoom);
/* Rotate the view */
glRotatef(beta, 1.0, 0.0, 0.0);
glRotatef(alpha, 0.0, 0.0, 1.0);
// Move back
glTranslatef(0.0, 0.0, -zoom);
// 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);
glDrawElements(GL_QUADS, 4 * 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). */
glShadeModel(GL_SMOOTH);
// Use Gouraud (smooth) shading
glShadeModel(GL_SMOOTH);
/* Culling. */
//glCullFace(GL_BACK);
//glFrontFace(GL_CCW);
//glEnable(GL_CULL_FACE);
// Switch on the z-buffer
glEnable(GL_DEPTH_TEST);
/* Switch on the z-buffer. */
glEnable(GL_DEPTH_TEST);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), vertex);
glColorPointer(3, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r); // Pointer to the first color
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
glPointSize(2.0);
glPointSize(2.0);
/* Background color is black. */
glClearColor(0, 0, 0, 0);
// Background color is black
glClearColor(0, 0, 0, 0);
}
/* Modify the height of each vertex according to the pressure. */
void adjustGrid( void )
{
int pos;
int x, y;
//========================================================================
// Modify the height of each vertex according to the pressure
//========================================================================
for(y = 0; y<GRIDH; y++)
{
for(x = 0; x<GRIDW; x++)
void adjust_grid(void)
{
int pos;
int x, y;
for (y = 0; y < GRIDH; y++)
{
pos = y*GRIDW + x;
vertex[pos].z = (float) (p[x][y]*(1.0/50.0));
for (x = 0; x < GRIDW; x++)
{
pos = y * GRIDW + x;
vertex[pos].z = (float) (p[x][y] * (1.0 / 50.0));
}
}
}
}
/* Calculate wave propagation */
void calc( void )
//========================================================================
// Calculate wave propagation
//========================================================================
void calc_grid(void)
{
int x, y, x2, y2;
double time_step = dt * ANIMATION_SPEED;
int x, y, x2, y2;
double time_step = dt * ANIMATION_SPEED;
/* compute accelerations */
for(x = 0; x < GRIDW; x++)
{
x2 = (x + 1) % GRIDW;
for(y = 0; y < GRIDH; y++)
// Compute accelerations
for (x = 0; x < GRIDW; x++)
{
ax[x][y] = p[x][y] - p[x2][y];
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++)
for (y = 0; y < GRIDH; y++)
{
ay[x][y] = p[x][y] - p[x][y2];
y2 = (y + 1) % GRIDH;
for(x = 0; x < GRIDW; x++)
ay[x][y] = p[x][y] - p[x][y2];
}
}
/* compute speeds */
for(x = 0; x < GRIDW; x++)
{
for(y = 0; y < GRIDH; y++)
// Compute speeds
for (x = 0; x < GRIDW; x++)
{
vx[x][y] = vx[x][y] + ax[x][y] * time_step;
vy[x][y] = vy[x][y] + ay[x][y] * time_step;
for (y = 0; y < GRIDH; y++)
{
vx[x][y] = vx[x][y] + ax[x][y] * time_step;
vy[x][y] = vy[x][y] + ay[x][y] * time_step;
}
}
}
/* compute pressure */
for(x = 1; x < GRIDW; x++)
{
x2 = x - 1;
for(y = 1; y < GRIDH; y++)
// Compute pressure
for (x = 1; x < GRIDW; x++)
{
y2 = y - 1;
p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step;
x2 = x - 1;
for (y = 1; y < GRIDH; y++)
{
y2 = y - 1;
p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step;
}
}
}
}
/* 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;
}
if (action != GLFW_PRESS)
return;
switch(key) {
case GLFW_KEY_ESC:
running = 0;
break;
case GLFW_KEY_SPACE:
initSurface();
break;
case GLFW_KEY_LEFT:
alpha+=5;
break;
case GLFW_KEY_RIGHT:
alpha-=5;
break;
case GLFW_KEY_UP:
beta-=5;
break;
case GLFW_KEY_DOWN:
beta+=5;
break;
case GLFW_KEY_PAGEUP:
if(zoom>1) zoom-=1;
break;
case GLFW_KEY_PAGEDOWN:
zoom+=1;
break;
default:
break;
}
switch (key)
{
case GLFW_KEY_ESC:
running = 0;
break;
case GLFW_KEY_SPACE:
init_grid();
break;
case GLFW_KEY_LEFT:
alpha += 5;
break;
case GLFW_KEY_RIGHT:
alpha -= 5;
break;
case GLFW_KEY_UP:
beta -= 5;
break;
case GLFW_KEY_DOWN:
beta += 5;
break;
case GLFW_KEY_PAGEUP:
if (zoom > 1)
zoom -= 1;
break;
case GLFW_KEY_PAGEDOWN:
zoom += 1;
break;
default:
break;
}
}
/* 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;
}
if (height > 0)
ratio = (float) width / (float) height;
/* Setup viewport (Place where the stuff will appear in the main window). */
glViewport(0, 0, width, height);
// Setup viewport
glViewport(0, 0, width, height);
/*
* Change to the projection matrix and set
* our viewing volume.
*/
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, ratio, 1.0, 1024.0);
// 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;
GLFWwindow window;
double t, dt_total, t_old;
/* Initialize GLFW */
if(glfwInit() == GL_FALSE)
{
fprintf(stderr, "GLFW initialization failed\n");
exit(-1);
}
/* 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);
if (!window)
{
fprintf(stderr, "Could not open window\n");
glfwTerminate();
exit(-1);
}
glfwSwapInterval( 1 );
/* Keyboard handler */
glfwSetKeyCallback( window, handle_key_down );
glfwEnable( window, GLFW_KEY_REPEAT );
/* Window resize handler */
glfwSetWindowSizeCallback( window, handle_resize );
/* Initialize OpenGL */
setup_opengl();
/* Initialize simulation */
initVertices();
initSurface();
adjustGrid();
/* 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 )
if (!glfwInit())
{
/* Select iteration time step */
dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
dt_total -= dt;
/* Calculate wave propagation */
calc();
fprintf(stderr, "GLFW initialization failed\n");
exit(EXIT_FAILURE);
}
/* Compute height of each vertex */
adjustGrid();
window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL);
if (!window)
{
fprintf(stderr, "Could not open window\n");
exit(EXIT_FAILURE);
}
/* Draw wave grid to OpenGL display */
draw_screen();
glfwSwapInterval(1);
glfwPollEvents();
// Keyboard handler
glfwSetKeyCallback(key_callback);
glfwEnable(window, GLFW_KEY_REPEAT);
/* Still running? */
running = running && glfwIsWindow( window );
}
// Window resize handler
glfwSetWindowSizeCallback(window_resize_callback);
glfwTerminate();
// Initialize OpenGL
init_opengl();
return 0;
// Initialize simulation
init_vertices();
init_grid();
adjust_grid();
// Initialize timer
t_old = glfwGetTime() - 0.01;
while (running)
{
t = glfwGetTime();
dt_total = t - t_old;
t_old = t;
// Safety - iterate if dt_total is too large
while (dt_total > 0.f)
{
// Select iteration time step
dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
dt_total -= dt;
// Calculate wave propagation
calc_grid();
}
// Compute height of each vertex
adjust_grid();
// Draw wave grid to OpenGL display
draw_scene();
glfwPollEvents();
// Still running?
running = running && glfwIsWindow(window);
}
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);

33
src/cocoa/CMakeLists.txt
View File

@ -1,42 +1,37 @@
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_SOURCE_DIR}/src
${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR})
set(cocoa_SOURCES
cocoa_enable.m
cocoa_fullscreen.m
cocoa_gamma.m
cocoa_glext.m
cocoa_init.m
cocoa_joystick.m
cocoa_time.m
cocoa_window.m)
set(cocoa_SOURCES cocoa_enable.m
cocoa_fullscreen.m
cocoa_gamma.m
cocoa_glext.m
cocoa_init.m
cocoa_joystick.m
cocoa_time.m
cocoa_window.m)
# 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
)
CLEAN_DIRECT_OUTPUT 1
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)
if(NOT CFLAGS)
set(CFLAGS "")
set(CFLAGS "")
endif(NOT CFLAGS)
set_target_properties(libglfwShared PROPERTIES COMPILE_FLAGS "${CFLAGS} -fno-common")

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

8
src/enable.c
View File

@ -54,11 +54,11 @@ static void enableMouseCursor(_GLFWwindow* window)
window->mousePosX = centerPosX;
window->mousePosY = centerPosY;
if (window->mousePosCallback)
if (_glfwLibrary.mousePosCallback)
{
window->mousePosCallback(window,
window->mousePosX,
window->mousePosY);
_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)

32
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,12 +228,17 @@ 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)
cbfun(window, window->mousePosX, window->mousePosY);
{
_GLFWwindow* window;
for (window = _glfwLibrary.windowListHead; window; window = window->next)
cbfun(window, window->mousePosX, window->mousePosY);
}
}
@ -241,7 +246,7 @@ GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun)
// 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;

44
src/win32/CMakeLists.txt
View File

@ -1,8 +1,8 @@
if(CYGWIN)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
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
# flag added in the Modules/Platform/CYGWIN.cmake file of the
@ -19,36 +19,36 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR})
set(libglfw_SOURCES
${common_SOURCES}
win32_enable.c
win32_fullscreen.c
win32_gamma.c
win32_glext.c
win32_init.c
win32_joystick.c
win32_time.c
win32_window.c
win32_dllmain.c)
set(libglfw_SOURCES ${common_SOURCES}
win32_enable.c
win32_fullscreen.c
win32_gamma.c
win32_glext.c
win32_init.c
win32_joystick.c
win32_time.c
win32_window.c
win32_dllmain.c)
add_library(libglfwStatic STATIC ${libglfw_SOURCES})
add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${OPENGL_gl_LIBRARY})
set_target_properties(libglfwShared PROPERTIES
DEFINE_SYMBOL GLFW_BUILD_DLL
PREFIX ""
IMPORT_PREFIX ""
IMPORT_SUFFIX "dll.lib")
DEFINE_SYMBOL GLFW_BUILD_DLL
PREFIX ""
IMPORT_PREFIX ""
IMPORT_SUFFIX "dll.lib")
set_target_properties(libglfwStatic libglfwShared PROPERTIES
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw)
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw)
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)
{

22
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,11 +879,11 @@ 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,
window->mousePosX,
window->mousePosY);
_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;
}

55
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)
cbfun(window, window->width, window->height);
{
_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;
}

31
src/x11/CMakeLists.txt
View File

@ -1,32 +1,29 @@
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_SOURCE_DIR}/src
${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR})
set(libglfw_SOURCES
${common_SOURCES}
x11_enable.c
x11_fullscreen.c
x11_gamma.c
x11_glext.c
x11_init.c
x11_joystick.c
x11_keysym2unicode.c
x11_time.c
x11_window.c)
set(libglfw_SOURCES ${common_SOURCES}
x11_enable.c
x11_fullscreen.c
x11_gamma.c
x11_glext.c
x11_init.c
x11_joystick.c
x11_keysym2unicode.c
x11_time.c
x11_window.c)
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
)
CLEAN_DIRECT_OUTPUT 1
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
;

28
src/x11/x11_window.c
View File

@ -1197,11 +1197,11 @@ static void processSingleEvent(void)
window->X11.cursorPosY = event.xmotion.y;
window->X11.mouseMoved = GL_TRUE;
if (window->mousePosCallback)
if (_glfwLibrary.mousePosCallback)
{
window->mousePosCallback(window,
window->mousePosX,
window->mousePosY);
_glfwLibrary.mousePosCallback(window,
window->mousePosX,
window->mousePosY);
}
}
break;
@ -1224,11 +1224,11 @@ static void processSingleEvent(void)
window->width = event.xconfigure.width;
window->height = event.xconfigure.height;
if (window->windowSizeCallback)
if (_glfwLibrary.windowSizeCallback)
{
window->windowSizeCallback(window,
window->width,
window->height);
_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);