mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-09-20 05:42:17 +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_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

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(window, windowSizeFun);
glfwSetWindowRefreshCallback(window, windowRefreshFun);
glfwSetMousePosCallback(window, mousePosFun);
glfwSetMouseButtonCallback(window, 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(window, key_callback);
glfwEnable(window, GLFW_KEY_REPEAT);
/* Still running? */
running = running && glfwIsWindow( window );
}
// Window resize handler
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(
${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_glext.m
cocoa_init.m
cocoa_joystick.m
cocoa_time.m
cocoa_window.m)
set(cocoa_SOURCES cocoa_enable.m
cocoa_fullscreen.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")

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)

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)

2
src/x11/x11_gamma.c
View File

@ -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);

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
;