Zengtudor/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-14 06:23:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://glfw.git.sourceforge.net/gitroot/glfw/glfw

Browse Source
This commit is contained in:
Camilla Berglund 2010-10-24 18:31:43 +02:00
commit 37d366dc9f
11 changed files with 497 additions and 651 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_PATCH "0")
set(GLFW_VERSION_EXTRA "") set(GLFW_VERSION_EXTRA "")
set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}") set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}")
set(GLFW_VERSION_FULL set(GLFW_VERSION_FULL "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
"${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
include(CheckFunctionExists) include(CheckFunctionExists)
include(CheckSymbolExists) include(CheckSymbolExists)
@ -159,8 +158,7 @@ install(FILES COPYING.txt readme.html
# Uninstall operation # Uninstall operation
#-------------------------------------------------------------------- #--------------------------------------------------------------------
configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in
${GLFW_BINARY_DIR}/cmake_uninstall.cmake ${GLFW_BINARY_DIR}/cmake_uninstall.cmake IMMEDIATE @ONLY)
IMMEDIATE @ONLY)
add_custom_target(uninstall add_custom_target(uninstall
${CMAKE_COMMAND} -P ${CMAKE_COMMAND} -P

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

70
examples/triangle.c
View File

@ -6,77 +6,75 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <GL/glfw3.h> #include <GL/glfw3.h>
int main(void)
int main( void )
{ {
int width, height, x; int width, height, x;
double t;
GLFWwindow window; GLFWwindow window;
// Initialise GLFW // Initialise GLFW
if( !glfwInit() ) if (!glfwInit())
{ {
fprintf( stderr, "Failed to initialize GLFW\n" ); fprintf(stderr, "Failed to initialize GLFW\n");
exit( EXIT_FAILURE ); exit(EXIT_FAILURE);
} }
// Open a window and create its OpenGL context // 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) if (!window)
{ {
fprintf( stderr, "Failed to open GLFW window\n" ); fprintf(stderr, "Failed to open GLFW window\n");
exit(EXIT_FAILURE);
glfwTerminate();
exit( EXIT_FAILURE );
} }
// Ensure we can capture the escape key being pressed below // 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) // Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 ); glfwSwapInterval(1);
do do
{ {
t = glfwGetTime(); double t = glfwGetTime();
glfwGetMousePos( window, &x, NULL ); glfwGetMousePos(window, &x, NULL);
// Get window size (may be different than the requested size) // Get window size (may be different than the requested size)
glfwGetWindowSize( window, &width, &height ); glfwGetWindowSize(window, &width, &height);
// Special case: avoid division by zero below // Special case: avoid division by zero below
height = height > 0 ? height : 1; height = height > 0 ? height : 1;
glViewport( 0, 0, width, height ); glViewport(0, 0, width, height);
// Clear color buffer to black // Clear color buffer to black
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glClearColor(0.f, 0.f, 0.f, 0.f);
glClear( GL_COLOR_BUFFER_BIT ); glClear(GL_COLOR_BUFFER_BIT);
// Select and setup the projection matrix // Select and setup the projection matrix
glMatrixMode( GL_PROJECTION ); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
gluPerspective( 65.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f ); gluPerspective(65.f, (GLfloat) width / (GLfloat) height, 1.f, 100.f);
// Select and setup the modelview matrix // Select and setup the modelview matrix
glMatrixMode( GL_MODELVIEW ); glMatrixMode( GL_MODELVIEW );
glLoadIdentity(); glLoadIdentity();
gluLookAt( 0.0f, 1.0f, 0.0f, // Eye-position gluLookAt(0.f, 1.f, 0.f, // Eye-position
0.0f, 20.0f, 0.0f, // View-point 0.f, 20.f, 0.f, // View-point
0.0f, 0.0f, 1.0f ); // Up-vector 0.f, 0.f, 1.f); // Up-vector
// Draw a rotating colorful triangle // Draw a rotating colorful triangle
glTranslatef( 0.0f, 14.0f, 0.0f ); glTranslatef(0.f, 14.f, 0.f);
glRotatef( 0.3f*(GLfloat)x + (GLfloat)t*100.0f, 0.0f, 0.0f, 1.0f ); glRotatef(0.3f * (GLfloat) x + (GLfloat) t * 100.f, 0.f, 0.f, 1.f);
glBegin( GL_TRIANGLES );
glColor3f( 1.0f, 0.0f, 0.0f ); glBegin(GL_TRIANGLES);
glVertex3f( -5.0f, 0.0f, -4.0f ); glColor3f(1.f, 0.f, 0.f);
glColor3f( 0.0f, 1.0f, 0.0f ); glVertex3f(-5.f, 0.f, -4.f);
glVertex3f( 5.0f, 0.0f, -4.0f ); glColor3f(0.f, 1.f, 0.f);
glColor3f( 0.0f, 0.0f, 1.0f ); glVertex3f(5.f, 0.f, -4.f);
glVertex3f( 0.0f, 0.0f, 6.0f ); glColor3f(0.f, 0.f, 1.f);
glVertex3f(0.f, 0.f, 6.f);
glEnd(); glEnd();
// Swap buffers // Swap buffers
@ -84,12 +82,12 @@ int main( void )
glfwPollEvents(); glfwPollEvents();
} // Check if the ESC key was pressed or the window was closed } // Check if the ESC key was pressed or the window was closed
while( glfwIsWindow(window) && while (glfwIsWindow(window) &&
glfwGetKey( window, GLFW_KEY_ESC ) != GLFW_PRESS ); glfwGetKey(window, GLFW_KEY_ESC) != GLFW_PRESS);
// Close OpenGL window and terminate GLFW // Close OpenGL window and terminate GLFW
glfwTerminate(); 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 GLFW by Sylvain Hellegouarch - sh@programmationworld.com
* Modified for variable frame rate by Marcus Geelnard * Modified for variable frame rate by Marcus Geelnard
* 2003-Jan-31: Minor cleanups and speedups / MG * 2003-Jan-31: Minor cleanups and speedups / MG
* 2010-10-24: Formatting and cleanup - Camilla Berglund
*****************************************************************************/ *****************************************************************************/
#include <stdio.h> #include <stdio.h>
@ -16,33 +17,32 @@
#define M_PI 3.1415926535897932384626433832795 #define M_PI 3.1415926535897932384626433832795
#endif #endif
/* Maximum delta T to allow for differential calculations */ // Maximum delta T to allow for differential calculations
#define MAX_DELTA_T 0.01 #define MAX_DELTA_T 0.01
/* Animation speed (10.0 looks good) */ // Animation speed (10.0 looks good)
#define ANIMATION_SPEED 10.0 #define ANIMATION_SPEED 10.0
GLfloat alpha = 210.f, beta = -70.f;
GLfloat zoom = 2.f;
GLfloat alpha = 210.0f, beta = -70.0f; GLboolean running = GL_TRUE;
GLfloat zoom = 2.0f;
int running = 1;
struct Vertex struct Vertex
{ {
GLfloat x,y,z; GLfloat x, y, z;
GLfloat r,g,b; GLfloat r, g, b;
}; };
#define GRIDW 50 #define GRIDW 50
#define GRIDH 50 #define GRIDH 50
#define VERTEXNUM (GRIDW*GRIDH) #define VERTEXNUM (GRIDW*GRIDH)
#define QUADW (GRIDW-1) #define QUADW (GRIDW - 1)
#define QUADH (GRIDH-1) #define QUADH (GRIDH - 1)
#define QUADNUM (QUADW*QUADH) #define QUADNUM (QUADW*QUADH)
GLuint quad[4*QUADNUM]; GLuint quad[4 * QUADNUM];
struct Vertex vertex[VERTEXNUM]; struct Vertex vertex[VERTEXNUM];
/* The grid will look like this: /* The grid will look like this:
@ -56,47 +56,46 @@ struct Vertex vertex[VERTEXNUM];
* 0 1 2 * 0 1 2
*/ */
void initVertices( void ) //========================================================================
// Initialize grid geometry
//========================================================================
void init_vertices(void)
{ {
int x,y,p; int x, y, p;
/* place the vertices in a grid */ // Place the vertices in a grid
for(y=0;y<GRIDH;y++) for (y = 0; y < GRIDH; y++)
for(x=0;x<GRIDW;x++)
{ {
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].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2);
//vertex[p].y = (-GRIDH/2)+y+cos(2.0*M_PI*(double)x/(double)GRIDW); vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2);
vertex[p].x = (GLfloat)(x-GRIDW/2)/(GLfloat)(GRIDW/2); vertex[p].z = 0;
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].g = (GLfloat)y/(GLfloat)GRIDH; if ((x % 4 < 2) ^ (y % 4 < 2))
vertex[p].b = 1.f-((GLfloat)x/(GLfloat)GRIDW+(GLfloat)y/(GLfloat)GRIDH)/2.f; 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 (y = 0; y < QUADH; y++)
for(x=0;x<QUADW;x++)
{ {
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+0] = y *GRIDW+x; /* some point */ quad[p + 1] = y * GRIDW + x + 1; // Neighbor at the right side
quad[p+1] = y *GRIDW+x+1; /* neighbor at the right side */ quad[p + 2] = (y + 1) * GRIDW + x + 1; // Upper right neighbor
quad[p+2] = (y+1)*GRIDW+x+1; /* upper right neighbor */ quad[p + 3] = (y + 1) * GRIDW + x; // Upper neighbor
quad[p+3] = (y+1)*GRIDW+x; /* upper neighbor */ }
} }
} }
@ -105,298 +104,287 @@ double p[GRIDW][GRIDH];
double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH]; double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH];
double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH]; double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH];
//========================================================================
// Initialize grid
//========================================================================
void init_grid(void)
void initSurface( void )
{ {
int x, y; int x, y;
double dx, dy, d; double dx, dy, d;
for(y = 0; y<GRIDH; y++) for (y = 0; y < GRIDH; y++)
{
for(x = 0; x<GRIDW; x++)
{ {
dx = (double)(x-GRIDW/2); for (x = 0; x < GRIDW; x++)
dy = (double)(y-GRIDH/2); {
d = sqrt( dx*dx + dy*dy ); dx = (double) (x - GRIDW / 2);
if(d < 0.1 * (double)(GRIDW/2)) dy = (double) (y - GRIDH / 2);
{ d = sqrt(dx * dx + dy * dy);
d = d * 10.0; if (d < 0.1 * (double) (GRIDW / 2))
p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0; {
} d = d * 10.0;
else p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0;
{ }
p[x][y] = 0.0; else
} p[x][y] = 0.0;
vx[x][y] = 0.0;
vy[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. */ // Clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* We don't want to modify the projection matrix. */ // We don't want to modify the projection matrix
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
/* Move back. */ // Move back
glTranslatef(0.0, 0.0, -zoom); glTranslatef(0.0, 0.0, -zoom);
/* Rotate the view */ // Rotate the view
glRotatef(beta, 1.0, 0.0, 0.0); glRotatef(beta, 1.0, 0.0, 0.0);
glRotatef(alpha, 0.0, 0.0, 1.0); glRotatef(alpha, 0.0, 0.0, 1.0);
//glDrawArrays(GL_POINTS,0,VERTEXNUM); /* Points only */ glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad);
glDrawElements(GL_QUADS, 4*QUADNUM, GL_UNSIGNED_INT, quad);
//glDrawElements(GL_LINES, QUADNUM, GL_UNSIGNED_INT, quad);
glfwSwapBuffers(); glfwSwapBuffers();
} }
/* Initialize OpenGL */ //========================================================================
void setup_opengl( void ) // Initialize Miscellaneous OpenGL state
//========================================================================
void init_opengl(void)
{ {
/* Our shading model--Gouraud (smooth). */ // Use Gouraud (smooth) shading
glShadeModel(GL_SMOOTH); glShadeModel(GL_SMOOTH);
/* Culling. */ // Switch on the z-buffer
//glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST);
//glFrontFace(GL_CCW);
//glEnable(GL_CULL_FACE);
/* Switch on the z-buffer. */ glEnableClientState(GL_VERTEX_ARRAY);
glEnable(GL_DEPTH_TEST); 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); glPointSize(2.0);
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);
/* Background color is black. */ // Background color is black
glClearColor(0, 0, 0, 0); glClearColor(0, 0, 0, 0);
} }
/* Modify the height of each vertex according to the pressure. */ //========================================================================
void adjustGrid( void ) // Modify the height of each vertex according to the pressure
{ //========================================================================
int pos;
int x, y;
for(y = 0; y<GRIDH; y++) void adjust_grid(void)
{ {
for(x = 0; x<GRIDW; x++) int pos;
int x, y;
for (y = 0; y < GRIDH; y++)
{ {
pos = y*GRIDW + x; for (x = 0; x < GRIDW; x++)
vertex[pos].z = (float) (p[x][y]*(1.0/50.0)); {
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; int x, y, x2, y2;
double time_step = dt * ANIMATION_SPEED; double time_step = dt * ANIMATION_SPEED;
/* compute accelerations */ // Compute accelerations
for(x = 0; x < GRIDW; x++) for (x = 0; x < GRIDW; x++)
{
x2 = (x + 1) % GRIDW;
for(y = 0; y < GRIDH; y++)
{ {
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++) 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]; 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 (x = 0; x < GRIDW; x++)
{
for(y = 0; y < GRIDH; y++)
{ {
vx[x][y] = vx[x][y] + ax[x][y] * time_step; for (y = 0; y < GRIDH; y++)
vy[x][y] = vy[x][y] + ay[x][y] * time_step; {
vx[x][y] = vx[x][y] + ax[x][y] * time_step;
vy[x][y] = vy[x][y] + ay[x][y] * time_step;
}
} }
}
/* compute pressure */ // Compute pressure
for(x = 1; x < GRIDW; x++) for (x = 1; x < GRIDW; x++)
{
x2 = x - 1;
for(y = 1; y < GRIDH; y++)
{ {
y2 = y - 1; x2 = x - 1;
p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step; 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 ) if (action != GLFW_PRESS)
{ return;
return;
}
switch(key) { switch (key)
case GLFW_KEY_ESC: {
running = 0; case GLFW_KEY_ESC:
break; running = 0;
case GLFW_KEY_SPACE: break;
initSurface(); case GLFW_KEY_SPACE:
break; init_grid();
case GLFW_KEY_LEFT: break;
alpha+=5; case GLFW_KEY_LEFT:
break; alpha += 5;
case GLFW_KEY_RIGHT: break;
alpha-=5; case GLFW_KEY_RIGHT:
break; alpha -= 5;
case GLFW_KEY_UP: break;
beta-=5; case GLFW_KEY_UP:
break; beta -= 5;
case GLFW_KEY_DOWN: break;
beta+=5; case GLFW_KEY_DOWN:
break; beta += 5;
case GLFW_KEY_PAGEUP: break;
if(zoom>1) zoom-=1; case GLFW_KEY_PAGEUP:
break; if (zoom > 1)
case GLFW_KEY_PAGEDOWN: zoom -= 1;
zoom+=1; break;
break; case GLFW_KEY_PAGEDOWN:
default: zoom += 1;
break; 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 ) if (height > 0)
{ ratio = (float) width / (float) height;
ratio = (float) width / (float) height;
}
/* Setup viewport (Place where the stuff will appear in the main window). */ // Setup viewport
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
/* // Change to the projection matrix and set our viewing volume
* Change to the projection matrix and set glMatrixMode(GL_PROJECTION);
* our viewing volume. glLoadIdentity();
*/ gluPerspective(60.0, ratio, 1.0, 1024.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, ratio, 1.0, 1024.0);
} }
/* Program entry point */ //========================================================================
// main
//========================================================================
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
/* Dimensions of our window. */ GLFWwindow window;
int width, height; double t, dt_total, t_old;
/* Style of our window. */
int mode;
/* Frame time */
double t, t_old, dt_total;
GLFWwindow window;
/* Initialize GLFW */ if (!glfwInit())
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 )
{ {
/* Select iteration time step */ fprintf(stderr, "GLFW initialization failed\n");
dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total; exit(EXIT_FAILURE);
dt_total -= dt;
/* Calculate wave propagation */
calc();
} }
/* Compute height of each vertex */ window = glfwOpenWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL);
adjustGrid(); if (!window)
{
fprintf(stderr, "Could not open window\n");
exit(EXIT_FAILURE);
}
/* Draw wave grid to OpenGL display */ glfwSwapInterval(1);
draw_screen();
glfwPollEvents(); // Keyboard handler
glfwSetKeyCallback(window, key_callback);
glfwEnable(window, GLFW_KEY_REPEAT);
/* Still running? */ // Window resize handler
running = running && glfwIsWindow( window ); glfwSetWindowSizeCallback(window, 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);
} }

31
src/cocoa/CMakeLists.txt
View File

@ -1,41 +1,36 @@
configure_file( configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
include_directories(${CMAKE_CURRENT_SOURCE_DIR} include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_SOURCE_DIR}/src ${GLFW_SOURCE_DIR}/src
${GLFW_BINARY_DIR}/src ${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR}) ${GLFW_INCLUDE_DIR})
set(cocoa_SOURCES set(cocoa_SOURCES cocoa_enable.m
cocoa_enable.m cocoa_fullscreen.m
cocoa_fullscreen.m cocoa_glext.m
cocoa_glext.m cocoa_init.m
cocoa_init.m cocoa_joystick.m
cocoa_joystick.m cocoa_time.m
cocoa_time.m cocoa_window.m)
cocoa_window.m)
# For some reason, CMake doesn't know about .m # For some reason, CMake doesn't know about .m
set_source_files_properties(${cocoa_SOURCES} PROPERTIES LANGUAGE C) set_source_files_properties(${cocoa_SOURCES} PROPERTIES LANGUAGE C)
set(libglfw_SOURCES set(libglfw_SOURCES ${common_SOURCES} ${cocoa_SOURCES})
${common_SOURCES}
${cocoa_SOURCES})
add_library(libglfwStatic STATIC ${libglfw_SOURCES}) add_library(libglfwStatic STATIC ${libglfw_SOURCES})
add_library(libglfwShared SHARED ${libglfw_SOURCES}) add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${GLFW_LIBRARIES}) target_link_libraries(libglfwShared ${GLFW_LIBRARIES})
set_target_properties(libglfwStatic libglfwShared PROPERTIES set_target_properties(libglfwStatic libglfwShared PROPERTIES
CLEAN_DIRECT_OUTPUT 1 CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw OUTPUT_NAME glfw)
)
# Append -fno-common to the compile flags to work around a bug in the Apple GCC # Append -fno-common to the compile flags to work around a bug in the Apple GCC
get_target_property(CFLAGS libglfwShared COMPILE_FLAGS) get_target_property(CFLAGS libglfwShared COMPILE_FLAGS)
if(NOT CFLAGS) if(NOT CFLAGS)
set(CFLAGS "") set(CFLAGS "")
endif(NOT CFLAGS) endif(NOT CFLAGS)
set_target_properties(libglfwShared PROPERTIES COMPILE_FLAGS "${CFLAGS} -fno-common") set_target_properties(libglfwShared PROPERTIES COMPILE_FLAGS "${CFLAGS} -fno-common")

44
src/win32/CMakeLists.txt
View File

@ -1,8 +1,8 @@
if(CYGWIN) if(CYGWIN)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY) ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
# These lines are intended to remove the --export-all-symbols # These lines are intended to remove the --export-all-symbols
# flag added in the Modules/Platform/CYGWIN.cmake file of the # 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_BINARY_DIR}/src
${GLFW_INCLUDE_DIR}) ${GLFW_INCLUDE_DIR})
set(libglfw_SOURCES set(libglfw_SOURCES ${common_SOURCES}
${common_SOURCES} win32_enable.c
win32_enable.c win32_fullscreen.c
win32_fullscreen.c win32_gamma.c
win32_gamma.c win32_glext.c
win32_glext.c win32_init.c
win32_init.c win32_joystick.c
win32_joystick.c win32_time.c
win32_time.c win32_window.c
win32_window.c win32_dllmain.c)
win32_dllmain.c)
add_library(libglfwStatic STATIC ${libglfw_SOURCES}) add_library(libglfwStatic STATIC ${libglfw_SOURCES})
add_library(libglfwShared SHARED ${libglfw_SOURCES}) add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${OPENGL_gl_LIBRARY}) target_link_libraries(libglfwShared ${OPENGL_gl_LIBRARY})
set_target_properties(libglfwShared PROPERTIES set_target_properties(libglfwShared PROPERTIES
DEFINE_SYMBOL GLFW_BUILD_DLL DEFINE_SYMBOL GLFW_BUILD_DLL
PREFIX "" PREFIX ""
IMPORT_PREFIX "" IMPORT_PREFIX ""
IMPORT_SUFFIX "dll.lib") IMPORT_SUFFIX "dll.lib")
set_target_properties(libglfwStatic libglfwShared PROPERTIES set_target_properties(libglfwStatic libglfwShared PROPERTIES
CLEAN_DIRECT_OUTPUT 1 CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw) OUTPUT_NAME glfw)
if(CYGWIN) if(CYGWIN)
# Build for the regular Win32 environment (not Cygwin) # Build for the regular Win32 environment (not Cygwin)
set_target_properties(libglfwStatic libglfwShared PROPERTIES COMPILE_FLAGS "-mwin32 -mno-cygwin") set_target_properties(libglfwStatic libglfwShared PROPERTIES
set_target_properties(libglfwStatic libglfwShared PROPERTIES LINK_FLAGS "-mwin32 -mno-cygwin") COMPILE_FLAGS "-mwin32 -mno-cygwin"
LINK_FLAGS "-mwin32 -mno-cygwin")
endif(CYGWIN) endif(CYGWIN)
install(TARGETS libglfwStatic libglfwShared DESTINATION lib) install(TARGETS libglfwStatic libglfwShared DESTINATION lib)

31
src/x11/CMakeLists.txt
View File

@ -1,32 +1,29 @@
configure_file( configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake
${CMAKE_CURRENT_SOURCE_DIR}/libglfw.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc @ONLY)
include_directories(${CMAKE_CURRENT_SOURCE_DIR} include_directories(${CMAKE_CURRENT_SOURCE_DIR}
${GLFW_SOURCE_DIR}/src ${GLFW_SOURCE_DIR}/src
${GLFW_BINARY_DIR}/src ${GLFW_BINARY_DIR}/src
${GLFW_INCLUDE_DIR}) ${GLFW_INCLUDE_DIR})
set(libglfw_SOURCES set(libglfw_SOURCES ${common_SOURCES}
${common_SOURCES} x11_enable.c
x11_enable.c x11_fullscreen.c
x11_fullscreen.c x11_gamma.c
x11_gamma.c x11_glext.c
x11_glext.c x11_init.c
x11_init.c x11_joystick.c
x11_joystick.c x11_keysym2unicode.c
x11_keysym2unicode.c x11_time.c
x11_time.c x11_window.c)
x11_window.c)
add_library(libglfwStatic STATIC ${libglfw_SOURCES}) add_library(libglfwStatic STATIC ${libglfw_SOURCES})
add_library(libglfwShared SHARED ${libglfw_SOURCES}) add_library(libglfwShared SHARED ${libglfw_SOURCES})
target_link_libraries(libglfwShared ${GLFW_LIBRARIES}) target_link_libraries(libglfwShared ${GLFW_LIBRARIES})
set_target_properties(libglfwStatic libglfwShared PROPERTIES set_target_properties(libglfwStatic libglfwShared PROPERTIES
CLEAN_DIRECT_OUTPUT 1 CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME glfw OUTPUT_NAME glfw)
)
install(TARGETS libglfwStatic libglfwShared DESTINATION lib) install(TARGETS libglfwStatic libglfwShared DESTINATION lib)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc DESTINATION lib/pkgconfig) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libglfw.pc DESTINATION lib/pkgconfig)

2
src/x11/x11_gamma.c
View File

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

8
src/x11/x11_init.c
View File

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