mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-14 02:31:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into showwindow

Browse Source 
Conflicts:
	src/window.c
This commit is contained in:
Camilla Berglund 2012-09-06 15:11:50 +02:00
commit 9a183090e0
21 changed files with 88 additions and 2109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1152
examples/particles.c
View File

File diff suppressed because it is too large Load Diff

854
examples/pong3d.c
View File

@ -1,854 +0,0 @@
//========================================================================
// This is a small test application for GLFW.
// This is an OpenGL port of the famous "PONG" game (the first computer
// game ever?). It is very simple, and could be improved alot. It was
// created in order to show off the gaming capabilities of GLFW.
//========================================================================
#include <GL/glfw.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//========================================================================
// Constants
//========================================================================
// Screen resolution
#define WIDTH 640
#define HEIGHT 480
// Player size (units)
#define PLAYER_XSIZE 0.05f
#define PLAYER_YSIZE 0.15f
// Ball size (units)
#define BALL_SIZE 0.02f
// Maximum player movement speed (units / second)
#define MAX_SPEED 1.5f
// Player movement acceleration (units / seconds^2)
#define ACCELERATION 4.0f
// Player movement deceleration (units / seconds^2)
#define DECELERATION 2.0f
// Ball movement speed (units / second)
#define BALL_SPEED 0.4f
// Menu options
#define MENU_NONE 0
#define MENU_PLAY 1
#define MENU_QUIT 2
// Game events
#define NOBODY_WINS 0
#define PLAYER1_WINS 1
#define PLAYER2_WINS 2
// Winner ID
#define NOBODY 0
#define PLAYER1 1
#define PLAYER2 2
// Camera positions
#define CAMERA_CLASSIC 0
#define CAMERA_ABOVE 1
#define CAMERA_SPECTATOR 2
#define CAMERA_DEFAULT CAMERA_CLASSIC
//========================================================================
// Textures
//========================================================================
#define TEX_TITLE 0
#define TEX_MENU 1
#define TEX_INSTR 2
#define TEX_WINNER1 3
#define TEX_WINNER2 4
#define TEX_FIELD 5
#define NUM_TEXTURES 6
// Texture names
char * tex_name[ NUM_TEXTURES ] = {
"pong3d_title.tga",
"pong3d_menu.tga",
"pong3d_instr.tga",
"pong3d_winner1.tga",
"pong3d_winner2.tga",
"pong3d_field.tga"
};
// OpenGL texture object IDs
GLuint tex_id[ NUM_TEXTURES ];
//========================================================================
// Global variables
//========================================================================
// Display information
int width, height;
// Frame information
double thistime, oldtime, dt, starttime;
// Camera information
int camerapos;
// Player information
struct {
double ypos; // -1.0 to +1.0
double yspeed; // -MAX_SPEED to +MAX_SPEED
} player1, player2;
// Ball information
struct {
double xpos, ypos;
double xspeed, yspeed;
} ball;
// And the winner is...
int winner;
// Lighting configuration
const GLfloat env_ambient[4] = {1.0f,1.0f,1.0f,1.0f};
const GLfloat light1_position[4] = {-3.0f,3.0f,2.0f,1.0f};
const GLfloat light1_diffuse[4] = {1.0f,1.0f,1.0f,0.0f};
const GLfloat light1_ambient[4] = {0.0f,0.0f,0.0f,0.0f};
// Object material properties
const GLfloat player1_diffuse[4] = {1.0f,0.3f,0.3f,1.0f};
const GLfloat player1_ambient[4] = {0.3f,0.1f,0.0f,1.0f};
const GLfloat player2_diffuse[4] = {0.3f,1.0f,0.3f,1.0f};
const GLfloat player2_ambient[4] = {0.1f,0.3f,0.1f,1.0f};
const GLfloat ball_diffuse[4] = {1.0f,1.0f,0.5f,1.0f};
const GLfloat ball_ambient[4] = {0.3f,0.3f,0.1f,1.0f};
const GLfloat border_diffuse[4] = {0.3f,0.3f,1.0f,1.0f};
const GLfloat border_ambient[4] = {0.1f,0.1f,0.3f,1.0f};
const GLfloat floor_diffuse[4] = {1.0f,1.0f,1.0f,1.0f};
const GLfloat floor_ambient[4] = {0.3f,0.3f,0.3f,1.0f};
//========================================================================
// LoadTextures() - Load textures from disk and upload to OpenGL card
//========================================================================
GLboolean LoadTextures( void )
{
int i;
// Generate texture objects
glGenTextures( NUM_TEXTURES, tex_id );
// Load textures
for( i = 0; i < NUM_TEXTURES; i ++ )
{
// Select texture object
glBindTexture( GL_TEXTURE_2D, tex_id[ i ] );
// Set texture parameters
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
// Upload texture from file to texture memory
if( !glfwLoadTexture2D( tex_name[ i ], 0 ) )
{
fprintf( stderr, "Failed to load texture %s\n", tex_name[ i ] );
return GL_FALSE;
}
}
return GL_TRUE;
}
//========================================================================
// DrawImage() - Draw a 2D image as a texture
//========================================================================
void DrawImage( int texnum, float x1, float x2, float y1, float y2 )
{
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, tex_id[ texnum ] );
glBegin( GL_QUADS );
glTexCoord2f( 0.0f, 1.0f );
glVertex2f( x1, y1 );
glTexCoord2f( 1.0f, 1.0f );
glVertex2f( x2, y1 );
glTexCoord2f( 1.0f, 0.0f );
glVertex2f( x2, y2 );
glTexCoord2f( 0.0f, 0.0f );
glVertex2f( x1, y2 );
glEnd();
glDisable( GL_TEXTURE_2D );
}
//========================================================================
// GameMenu() - Game menu (returns menu option)
//========================================================================
int GameMenu( void )
{
int option;
// Enable sticky keys
glfwEnable( GLFW_STICKY_KEYS );
// Wait for a game menu key to be pressed
do
{
// Get window size
glfwGetWindowSize( &width, &height );
// Set viewport
glViewport( 0, 0, width, height );
// Clear display
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
glClear( GL_COLOR_BUFFER_BIT );
// Setup projection matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.0f, 1.0f, 1.0f, 0.0f, -1.0f, 1.0f );
// Setup modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// Display title
glColor3f( 1.0f, 1.0f, 1.0f );
DrawImage( TEX_TITLE, 0.1f, 0.9f, 0.0f, 0.3f );
// Display menu
glColor3f( 1.0f, 1.0f, 0.0f );
DrawImage( TEX_MENU, 0.38f, 0.62f, 0.35f, 0.5f );
// Display instructions
glColor3f( 0.0f, 1.0f, 1.0f );
DrawImage( TEX_INSTR, 0.32f, 0.68f, 0.65f, 0.85f );
// Swap buffers
glfwSwapBuffers();
// Check for keys
if( glfwGetKey( 'Q' ) || !glfwGetWindowParam( GLFW_OPENED ) )
{
option = MENU_QUIT;
}
else if( glfwGetKey( GLFW_KEY_F1 ) )
{
option = MENU_PLAY;
}
else
{
option = MENU_NONE;
}
// To avoid horrible busy waiting, sleep for at least 20 ms
glfwSleep( 0.02 );
}
while( option == MENU_NONE );
// Disable sticky keys
glfwDisable( GLFW_STICKY_KEYS );
return option;
}
//========================================================================
// NewGame() - Initialize a new game
//========================================================================
void NewGame( void )
{
// Frame information
starttime = thistime = glfwGetTime();
// Camera information
camerapos = CAMERA_DEFAULT;
// Player 1 information
player1.ypos = 0.0;
player1.yspeed = 0.0;
// Player 2 information
player2.ypos = 0.0;
player2.yspeed = 0.0;
// Ball information
ball.xpos = -1.0 + PLAYER_XSIZE;
ball.ypos = player1.ypos;
ball.xspeed = 1.0;
ball.yspeed = 1.0;
}
//========================================================================
// PlayerControl() - Player control
//========================================================================
void PlayerControl( void )
{
float joy1pos[ 2 ], joy2pos[ 2 ];
// Get joystick X & Y axis positions
glfwGetJoystickPos( GLFW_JOYSTICK_1, joy1pos, 2 );
glfwGetJoystickPos( GLFW_JOYSTICK_2, joy2pos, 2 );
// Player 1 control
if( glfwGetKey( 'A' ) || joy1pos[ 1 ] > 0.2f )
{
player1.yspeed += dt * ACCELERATION;
if( player1.yspeed > MAX_SPEED )
{
player1.yspeed = MAX_SPEED;
}
}
else if( glfwGetKey( 'Z' ) || joy1pos[ 1 ] < -0.2f )
{
player1.yspeed -= dt * ACCELERATION;
if( player1.yspeed < -MAX_SPEED )
{
player1.yspeed = -MAX_SPEED;
}
}
else
{
player1.yspeed /= exp( DECELERATION * dt );
}
// Player 2 control
if( glfwGetKey( 'K' ) || joy2pos[ 1 ] > 0.2f )
{
player2.yspeed += dt * ACCELERATION;
if( player2.yspeed > MAX_SPEED )
{
player2.yspeed = MAX_SPEED;
}
}
else if( glfwGetKey( 'M' ) || joy2pos[ 1 ] < -0.2f )
{
player2.yspeed -= dt * ACCELERATION;
if( player2.yspeed < -MAX_SPEED )
{
player2.yspeed = -MAX_SPEED;
}
}
else
{
player2.yspeed /= exp( DECELERATION * dt );
}
// Update player 1 position
player1.ypos += dt * player1.yspeed;
if( player1.ypos > 1.0 - PLAYER_YSIZE )
{
player1.ypos = 1.0 - PLAYER_YSIZE;
player1.yspeed = 0.0;
}
else if( player1.ypos < -1.0 + PLAYER_YSIZE )
{
player1.ypos = -1.0 + PLAYER_YSIZE;
player1.yspeed = 0.0;
}
// Update player 2 position
player2.ypos += dt * player2.yspeed;
if( player2.ypos > 1.0 - PLAYER_YSIZE )
{
player2.ypos = 1.0 - PLAYER_YSIZE;
player2.yspeed = 0.0;
}
else if( player2.ypos < -1.0 + PLAYER_YSIZE )
{
player2.ypos = -1.0 + PLAYER_YSIZE;
player2.yspeed = 0.0;
}
}
//========================================================================
// BallControl() - Ball control
//========================================================================
int BallControl( void )
{
int event;
double ballspeed;
// Calculate new ball speed
ballspeed = BALL_SPEED * (1.0 + 0.02*(thistime-starttime));
ball.xspeed = ball.xspeed > 0 ? ballspeed : -ballspeed;
ball.yspeed = ball.yspeed > 0 ? ballspeed : -ballspeed;
ball.yspeed *= 0.74321;
// Update ball position
ball.xpos += dt * ball.xspeed;
ball.ypos += dt * ball.yspeed;
// Did the ball hit a top/bottom wall?
if( ball.ypos >= 1.0 )
{
ball.ypos = 2.0 - ball.ypos;
ball.yspeed = -ball.yspeed;
}
else if( ball.ypos <= -1.0 )
{
ball.ypos = -2.0 - ball.ypos;
ball.yspeed = -ball.yspeed;
}
// Did the ball hit/miss a player?
event = NOBODY_WINS;
// Is the ball entering the player 1 goal?
if( ball.xpos < -1.0 + PLAYER_XSIZE )
{
// Did player 1 catch the ball?
if( ball.ypos > (player1.ypos-PLAYER_YSIZE) &&
ball.ypos < (player1.ypos+PLAYER_YSIZE) )
{
ball.xpos = -2.0 + 2.0*PLAYER_XSIZE - ball.xpos;
ball.xspeed = -ball.xspeed;
}
else
{
event = PLAYER2_WINS;
}
}
// Is the ball entering the player 2 goal?
if( ball.xpos > 1.0 - PLAYER_XSIZE )
{
// Did player 2 catch the ball?
if( ball.ypos > (player2.ypos-PLAYER_YSIZE) &&
ball.ypos < (player2.ypos+PLAYER_YSIZE) )
{
ball.xpos = 2.0 - 2.0*PLAYER_XSIZE - ball.xpos;
ball.xspeed = -ball.xspeed;
}
else
{
event = PLAYER1_WINS;
}
}
return event;
}
//========================================================================
// DrawBox() - Draw a 3D box
//========================================================================
#define TEX_SCALE 4.0f
void DrawBox( float x1, float y1, float z1, float x2, float y2, float z2 )
{
// Draw six sides of a cube
glBegin( GL_QUADS );
// Side 1 (down)
glNormal3f( 0.0f, 0.0f, -1.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( x1,y2,z1 );
glTexCoord2f( TEX_SCALE, 0.0f );
glVertex3f( x2,y2,z1 );
glTexCoord2f( TEX_SCALE, TEX_SCALE );
glVertex3f( x2,y1,z1 );
glTexCoord2f( 0.0f, TEX_SCALE );
glVertex3f( x1,y1,z1 );
// Side 2 (up)
glNormal3f( 0.0f, 0.0f, 1.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( x1,y1,z2 );
glTexCoord2f( TEX_SCALE, 0.0f );
glVertex3f( x2,y1,z2 );
glTexCoord2f( TEX_SCALE, TEX_SCALE );
glVertex3f( x2,y2,z2 );
glTexCoord2f( 0.0f, TEX_SCALE );
glVertex3f( x1,y2,z2 );
// Side 3 (backward)
glNormal3f( 0.0f, -1.0f, 0.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( x1,y1,z1 );
glTexCoord2f( TEX_SCALE, 0.0f );
glVertex3f( x2,y1,z1 );
glTexCoord2f( TEX_SCALE, TEX_SCALE );
glVertex3f( x2,y1,z2 );
glTexCoord2f( 0.0f, TEX_SCALE );
glVertex3f( x1,y1,z2 );
// Side 4 (forward)
glNormal3f( 0.0f, 1.0f, 0.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( x1,y2,z2 );
glTexCoord2f( TEX_SCALE, 0.0f );
glVertex3f( x2,y2,z2 );
glTexCoord2f( TEX_SCALE, TEX_SCALE );
glVertex3f( x2,y2,z1 );
glTexCoord2f( 0.0f, TEX_SCALE );
glVertex3f( x1,y2,z1 );
// Side 5 (left)
glNormal3f( -1.0f, 0.0f, 0.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( x1,y1,z2 );
glTexCoord2f( TEX_SCALE, 0.0f );
glVertex3f( x1,y2,z2 );
glTexCoord2f( TEX_SCALE, TEX_SCALE );
glVertex3f( x1,y2,z1 );
glTexCoord2f( 0.0f, TEX_SCALE );
glVertex3f( x1,y1,z1 );
// Side 6 (right)
glNormal3f( 1.0f, 0.0f, 0.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( x2,y1,z1 );
glTexCoord2f( TEX_SCALE, 0.0f );
glVertex3f( x2,y2,z1 );
glTexCoord2f( TEX_SCALE, TEX_SCALE );
glVertex3f( x2,y2,z2 );
glTexCoord2f( 0.0f, TEX_SCALE );
glVertex3f( x2,y1,z2 );
glEnd();
}
//========================================================================
// UpdateDisplay() - Draw graphics (all game related OpenGL stuff goes
// here)
//========================================================================
void UpdateDisplay( void )
{
// Get window size
glfwGetWindowSize( &width, &height );
// Set viewport
glViewport( 0, 0, width, height );
// Clear display
glClearColor( 0.02f, 0.02f, 0.02f, 0.0f );
glClearDepth( 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Setup projection matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective(
55.0f, // Angle of view
(GLfloat)width/(GLfloat)height, // Aspect
1.0f, // Near Z
100.0f // Far Z
);
// Setup modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
switch( camerapos )
{
default:
case CAMERA_CLASSIC:
gluLookAt(
0.0f, 0.0f, 2.5f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f
);
break;
case CAMERA_ABOVE:
gluLookAt(
0.0f, 0.0f, 2.5f,
(float)ball.xpos, (float)ball.ypos, 0.0f,
0.0f, 1.0f, 0.0f
);
break;
case CAMERA_SPECTATOR:
gluLookAt(
0.0f, -2.0, 1.2f,
(float)ball.xpos, (float)ball.ypos, 0.0f,
0.0f, 0.0f, 1.0f
);
break;
}
// Enable depth testing
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
// Enable lighting
glEnable( GL_LIGHTING );
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, env_ambient );
glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
glLightfv( GL_LIGHT1, GL_POSITION, light1_position );
glLightfv( GL_LIGHT1, GL_DIFFUSE, light1_diffuse );
glLightfv( GL_LIGHT1, GL_AMBIENT, light1_ambient );
glEnable( GL_LIGHT1 );
// Front face is counter-clock-wise
glFrontFace( GL_CCW );
// Enable face culling (not necessary, but speeds up rendering)
glCullFace( GL_BACK );
glEnable( GL_CULL_FACE );
// Draw Player 1
glMaterialfv( GL_FRONT, GL_DIFFUSE, player1_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, player1_ambient );
DrawBox( -1.f, (GLfloat)player1.ypos-PLAYER_YSIZE, 0.f,
-1.f+PLAYER_XSIZE, (GLfloat)player1.ypos+PLAYER_YSIZE, 0.1f );
// Draw Player 2
glMaterialfv( GL_FRONT, GL_DIFFUSE, player2_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, player2_ambient );
DrawBox( 1.f-PLAYER_XSIZE, (GLfloat)player2.ypos-PLAYER_YSIZE, 0.f,
1.f, (GLfloat)player2.ypos+PLAYER_YSIZE, 0.1f );
// Draw Ball
glMaterialfv( GL_FRONT, GL_DIFFUSE, ball_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, ball_ambient );
DrawBox( (GLfloat)ball.xpos-BALL_SIZE, (GLfloat)ball.ypos-BALL_SIZE, 0.f,
(GLfloat)ball.xpos+BALL_SIZE, (GLfloat)ball.ypos+BALL_SIZE, BALL_SIZE*2 );
// Top game field border
glMaterialfv( GL_FRONT, GL_DIFFUSE, border_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, border_ambient );
DrawBox( -1.1f, 1.0f, 0.0f, 1.1f, 1.1f, 0.1f );
// Bottom game field border
glColor3f( 0.0f, 0.0f, 0.7f );
DrawBox( -1.1f, -1.1f, 0.0f, 1.1f, -1.0f, 0.1f );
// Left game field border
DrawBox( -1.1f, -1.0f, 0.0f, -1.0f, 1.0f, 0.1f );
// Left game field border
DrawBox( 1.0f, -1.0f, 0.0f, 1.1f, 1.0f, 0.1f );
// Enable texturing
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, tex_id[ TEX_FIELD ] );
// Game field floor
glMaterialfv( GL_FRONT, GL_DIFFUSE, floor_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, floor_ambient );
DrawBox( -1.01f, -1.01f, -0.01f, 1.01f, 1.01f, 0.0f );
// Disable texturing
glDisable( GL_TEXTURE_2D );
// Disable face culling
glDisable( GL_CULL_FACE );
// Disable lighting
glDisable( GL_LIGHTING );
// Disable depth testing
glDisable( GL_DEPTH_TEST );
}
//========================================================================
// GameOver()
//========================================================================
void GameOver( void )
{
// Enable sticky keys
glfwEnable( GLFW_STICKY_KEYS );
// Until the user presses ESC or SPACE
while( !glfwGetKey( GLFW_KEY_ESC ) && !glfwGetKey( ' ' ) &&
glfwGetWindowParam( GLFW_OPENED ) )
{
// Draw display
UpdateDisplay();
// Setup projection matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.0f, 1.0f, 1.0f, 0.0f, -1.0f, 1.0f );
// Setup modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// Enable blending
glEnable( GL_BLEND );
// Dim background
glBlendFunc( GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA );
glColor4f( 0.3f, 0.3f, 0.3f, 0.3f );
glBegin( GL_QUADS );
glVertex2f( 0.0f, 0.0f );
glVertex2f( 1.0f, 0.0f );
glVertex2f( 1.0f, 1.0f );
glVertex2f( 0.0f, 1.0f );
glEnd();
// Display winner text
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_COLOR );
if( winner == PLAYER1 )
{
glColor4f( 1.0f, 0.5f, 0.5f, 1.0f );
DrawImage( TEX_WINNER1, 0.35f, 0.65f, 0.46f, 0.54f );
}
else if( winner == PLAYER2 )
{
glColor4f( 0.5f, 1.0f, 0.5f, 1.0f );
DrawImage( TEX_WINNER2, 0.35f, 0.65f, 0.46f, 0.54f );
}
// Disable blending
glDisable( GL_BLEND );
// Swap buffers
glfwSwapBuffers();
}
// Disable sticky keys
glfwDisable( GLFW_STICKY_KEYS );
}
//========================================================================
// GameLoop() - Game loop
//========================================================================
void GameLoop( void )
{
int playing, event;
// Initialize a new game
NewGame();
// Enable sticky keys
glfwEnable( GLFW_STICKY_KEYS );
// Loop until the game ends
playing = GL_TRUE;
while( playing && glfwGetWindowParam( GLFW_OPENED ) )
{
// Frame timer
oldtime = thistime;
thistime = glfwGetTime();
dt = thistime - oldtime;
// Get user input and update player positions
PlayerControl();
// Move the ball, and check if a player hits/misses the ball
event = BallControl();
// Did we have a winner?
switch( event )
{
case PLAYER1_WINS:
winner = PLAYER1;
playing = GL_FALSE;
break;
case PLAYER2_WINS:
winner = PLAYER2;
playing = GL_FALSE;
break;
default:
break;
}
// Did the user press ESC?
if( glfwGetKey( GLFW_KEY_ESC ) )
{
playing = GL_FALSE;
}
// Did the user change camera view?
if( glfwGetKey( '1' ) )
{
camerapos = CAMERA_CLASSIC;
}
else if( glfwGetKey( '2' ) )
{
camerapos = CAMERA_ABOVE;
}
else if( glfwGetKey( '3' ) )
{
camerapos = CAMERA_SPECTATOR;
}
// Draw display
UpdateDisplay();
// Swap buffers
glfwSwapBuffers();
}
// Disable sticky keys
glfwDisable( GLFW_STICKY_KEYS );
// Show winner
GameOver();
}
//========================================================================
// main() - Program entry point
//========================================================================
int main( void )
{
int menuoption;
// Initialize GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Open OpenGL window
if( !glfwCreateWindow( WIDTH, HEIGHT, 0,0,0,0, 16,0, GLFW_FULLSCREEN ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSwapInterval( 1 );
// Load all textures
if( !LoadTextures() )
{
glfwTerminate();
exit( EXIT_FAILURE );
}
// Main loop
do
{
// Get menu option
menuoption = GameMenu();
// If the user wants to play, let him...
if( menuoption == MENU_PLAY )
{
GameLoop();
}
}
while( menuoption != MENU_QUIT );
// Unload all textures
if( glfwGetWindowParam( GLFW_OPENED ) )
{
glDeleteTextures( NUM_TEXTURES, tex_id );
}
// Terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}

BIN
examples/pong3d_field.tga
View File

Binary file not shown.

BIN
examples/pong3d_instr.tga
View File

Binary file not shown.

BIN
examples/pong3d_menu.tga
View File

Binary file not shown.

BIN
examples/pong3d_title.tga
View File

Binary file not shown.

BIN
examples/pong3d_winner1.tga
View File

Binary file not shown.

BIN
examples/pong3d_winner2.tga
View File

Binary file not shown.

12
include/GL/glfw3.h
View File

@ -528,11 +528,11 @@ GLFWAPI void glfwSetGammaRamp(const GLFWgammaramp* ramp);
GLFWAPI void glfwWindowHint(int target, int hint); GLFWAPI void glfwWindowHint(int target, int hint);
GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, int mode, const char* title, GLFWwindow share); GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, int mode, const char* title, GLFWwindow share);
GLFWAPI void glfwDestroyWindow(GLFWwindow window); GLFWAPI void glfwDestroyWindow(GLFWwindow window);
GLFWAPI void glfwSetWindowTitle(GLFWwindow, const char* title); GLFWAPI void glfwSetWindowTitle(GLFWwindow window, const char* title);
GLFWAPI void glfwGetWindowSize(GLFWwindow, int* width, int* height); GLFWAPI void glfwGetWindowSize(GLFWwindow window, int* width, int* height);
GLFWAPI void glfwSetWindowSize(GLFWwindow, int width, int height); GLFWAPI void glfwSetWindowSize(GLFWwindow window, int width, int height);
GLFWAPI void glfwGetWindowPos(GLFWwindow, int* xpos, int* ypos); GLFWAPI void glfwGetWindowPos(GLFWwindow window, int* xpos, int* ypos);
GLFWAPI void glfwSetWindowPos(GLFWwindow, int xpos, int ypos); GLFWAPI void glfwSetWindowPos(GLFWwindow window, int xpos, int ypos);
GLFWAPI void glfwIconifyWindow(GLFWwindow window); GLFWAPI void glfwIconifyWindow(GLFWwindow window);
GLFWAPI void glfwRestoreWindow(GLFWwindow window); GLFWAPI void glfwRestoreWindow(GLFWwindow window);
GLFWAPI void glfwShowWindow(GLFWwindow window); GLFWAPI void glfwShowWindow(GLFWwindow window);
@ -567,7 +567,7 @@ GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun);
/* Joystick input */ /* Joystick input */
GLFWAPI int glfwGetJoystickParam(int joy, int param); GLFWAPI int glfwGetJoystickParam(int joy, int param);
GLFWAPI int glfwGetJoystickPos(int joy, float* pos, int numaxes); GLFWAPI int glfwGetJoystickAxes(int joy, float* axes, int numaxes);
GLFWAPI int glfwGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons); GLFWAPI int glfwGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons);
/* Clipboard */ /* Clipboard */

3
readme.html
View File

@ -301,6 +301,7 @@ version of GLFW.</p>
<li>Renamed <code>GLFW_BUILD_DLL</code> to <code>_GLFW_BUILD_DLL</code></li> <li>Renamed <code>GLFW_BUILD_DLL</code> to <code>_GLFW_BUILD_DLL</code></li>
<li>Renamed <code>version</code> test to <code>glfwinfo</code></li> <li>Renamed <code>version</code> test to <code>glfwinfo</code></li>
<li>Renamed <code>GLFW_NO_GLU</code> to <code>GLFW_INCLUDE_GLU</code> and made it disabled by default</li> <li>Renamed <code>GLFW_NO_GLU</code> to <code>GLFW_INCLUDE_GLU</code> and made it disabled by default</li>
<li>Renamed <code>glfwGetJoystickPos</code> to <code>glfwGetJoystickAxes</code> to match <code>glfwGetJoystickButtons</code></li>
<li>Renamed mouse position functions to cursor position equivalents</li> <li>Renamed mouse position functions to cursor position equivalents</li>
<li>Replaced <code>glfwOpenWindow</code> and <code>glfwCloseWindow</code> with <code>glfwCreateWindow</code> and <code>glfwDestroyWindow</code></li> <li>Replaced <code>glfwOpenWindow</code> and <code>glfwCloseWindow</code> with <code>glfwCreateWindow</code> and <code>glfwDestroyWindow</code></li>
<li>Replaced ad hoc build system with CMake</li> <li>Replaced ad hoc build system with CMake</li>
@ -954,6 +955,8 @@ their skills. Special thanks go out to:</p>
<li>Samuli Tuomola, for support, bug reports and testing</li> <li>Samuli Tuomola, for support, bug reports and testing</li>
<li>Torsten Walluhn, for fixing various compilation issues on OS X</li>
<li>Frank Wille, for helping with the AmigaOS port and making GLFW <li>Frank Wille, for helping with the AmigaOS port and making GLFW
compile under IRIX 5.3</li> compile under IRIX 5.3</li>

8
src/cocoa_joystick.m
View File

@ -528,7 +528,7 @@ int _glfwPlatformGetJoystickParam(int joy, int param)
// Get joystick axis positions // Get joystick axis positions
//======================================================================== //========================================================================
int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes) int _glfwPlatformGetJoystickAxes(int joy, float* axes, int numaxes)
{ {
int i; int i;
@ -556,12 +556,12 @@ int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes)
long readScale = axes->maxReport - axes->minReport; long readScale = axes->maxReport - axes->minReport;
if (readScale == 0) if (readScale == 0)
pos[i] = axes->value; axes[i] = axes->value;
else else
pos[i] = (2.0f * (axes->value - axes->minReport) / readScale) - 1.0f; axes[i] = (2.0f * (axes->value - axes->minReport) / readScale) - 1.0f;
if (i & 1) if (i & 1)
pos[i] = -pos[i]; axes[i] = -axes[i];
} }
return numaxes; return numaxes;

2
src/internal.h
View File

@ -276,7 +276,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
// Joystick input // Joystick input
int _glfwPlatformGetJoystickParam(int joy, int param); int _glfwPlatformGetJoystickParam(int joy, int param);
int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes); int _glfwPlatformGetJoystickAxes(int joy, float* axes, int numaxes);
int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons); int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons);
// Time input // Time input

8
src/joystick.c
View File

@ -61,7 +61,7 @@ GLFWAPI int glfwGetJoystickParam(int joy, int param)
// Get joystick axis positions // Get joystick axis positions
//======================================================================== //========================================================================
GLFWAPI int glfwGetJoystickPos(int joy, float* pos, int numaxes) GLFWAPI int glfwGetJoystickAxes(int joy, float* axes, int numaxes)
{ {
int i; int i;
@ -77,7 +77,7 @@ GLFWAPI int glfwGetJoystickPos(int joy, float* pos, int numaxes)
return 0; return 0;
} }
if (pos == NULL || numaxes < 0) if (axes == NULL || numaxes < 0)
{ {
_glfwSetError(GLFW_INVALID_VALUE, NULL); _glfwSetError(GLFW_INVALID_VALUE, NULL);
return 0; return 0;
@ -85,9 +85,9 @@ GLFWAPI int glfwGetJoystickPos(int joy, float* pos, int numaxes)
// Clear positions // Clear positions
for (i = 0; i < numaxes; i++) for (i = 0; i < numaxes; i++)
pos[i] = 0.0f; axes[i] = 0.0f;
return _glfwPlatformGetJoystickPos(joy, pos, numaxes); return _glfwPlatformGetJoystickAxes(joy, axes, numaxes);
} }

14
src/win32_joystick.c
View File

@ -116,7 +116,7 @@ int _glfwPlatformGetJoystickParam(int joy, int param)
// Get joystick axis positions // Get joystick axis positions
//======================================================================== //========================================================================
int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes) int _glfwPlatformGetJoystickAxes(int joy, float* axes, int numaxes)
{ {
JOYCAPS jc; JOYCAPS jc;
JOYINFOEX ji; JOYINFOEX ji;
@ -137,22 +137,22 @@ int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes)
// Get position values for all axes // Get position values for all axes
axis = 0; axis = 0;
if (axis < numaxes) if (axis < numaxes)
pos[axis++] = calcJoystickPos(ji.dwXpos, jc.wXmin, jc.wXmax); axes[axis++] = calcJoystickPos(ji.dwXpos, jc.wXmin, jc.wXmax);
if (axis < numaxes) if (axis < numaxes)
pos[axis++] = -calcJoystickPos(ji.dwYpos, jc.wYmin, jc.wYmax); axes[axis++] = -calcJoystickPos(ji.dwYpos, jc.wYmin, jc.wYmax);
if (axis < numaxes && jc.wCaps & JOYCAPS_HASZ) if (axis < numaxes && jc.wCaps & JOYCAPS_HASZ)
pos[axis++] = calcJoystickPos(ji.dwZpos, jc.wZmin, jc.wZmax); axes[axis++] = calcJoystickPos(ji.dwZpos, jc.wZmin, jc.wZmax);
if (axis < numaxes && jc.wCaps & JOYCAPS_HASR) if (axis < numaxes && jc.wCaps & JOYCAPS_HASR)
pos[axis++] = calcJoystickPos(ji.dwRpos, jc.wRmin, jc.wRmax); axes[axis++] = calcJoystickPos(ji.dwRpos, jc.wRmin, jc.wRmax);
if (axis < numaxes && jc.wCaps & JOYCAPS_HASU) if (axis < numaxes && jc.wCaps & JOYCAPS_HASU)
pos[axis++] = calcJoystickPos(ji.dwUpos, jc.wUmin, jc.wUmax); axes[axis++] = calcJoystickPos(ji.dwUpos, jc.wUmin, jc.wUmax);
if (axis < numaxes && jc.wCaps & JOYCAPS_HASV) if (axis < numaxes && jc.wCaps & JOYCAPS_HASV)
pos[axis++] = -calcJoystickPos(ji.dwVpos, jc.wVmin, jc.wVmax); axes[axis++] = -calcJoystickPos(ji.dwVpos, jc.wVmin, jc.wVmax);
return axis; return axis;
} }

2
src/win32_platform.h
View File

@ -191,7 +191,7 @@ typedef struct _GLFWlibraryWin32
// Timer data // Timer data
struct { struct {
GLboolean hasPerformanceCounter; GLboolean hasPC;
double resolution; double resolution;
unsigned int t0_32; unsigned int t0_32;
__int64 t0_64; __int64 t0_64;

8
src/win32_time.c
View File

@ -45,13 +45,13 @@ void _glfwInitTimer(void)
if (QueryPerformanceFrequency((LARGE_INTEGER*) &freq)) if (QueryPerformanceFrequency((LARGE_INTEGER*) &freq))
{ {
_glfwLibrary.Win32.timer.hasPerformanceCounter = GL_TRUE; _glfwLibrary.Win32.timer.hasPC = GL_TRUE;
_glfwLibrary.Win32.timer.resolution = 1.0 / (double) freq; _glfwLibrary.Win32.timer.resolution = 1.0 / (double) freq;
QueryPerformanceCounter((LARGE_INTEGER*) &_glfwLibrary.Win32.timer.t0_64); QueryPerformanceCounter((LARGE_INTEGER*) &_glfwLibrary.Win32.timer.t0_64);
} }
else else
{ {
_glfwLibrary.Win32.timer.hasPerformanceCounter = GL_FALSE; _glfwLibrary.Win32.timer.hasPC = GL_FALSE;
_glfwLibrary.Win32.timer.resolution = 0.001; // winmm resolution is 1 ms _glfwLibrary.Win32.timer.resolution = 0.001; // winmm resolution is 1 ms
_glfwLibrary.Win32.timer.t0_32 = _glfw_timeGetTime(); _glfwLibrary.Win32.timer.t0_32 = _glfw_timeGetTime();
} }
@ -71,7 +71,7 @@ double _glfwPlatformGetTime(void)
double t; double t;
__int64 t_64; __int64 t_64;
if (_glfwLibrary.Win32.timer.hasPerformanceCounter) if (_glfwLibrary.Win32.timer.hasPC)
{ {
QueryPerformanceCounter((LARGE_INTEGER*) &t_64); QueryPerformanceCounter((LARGE_INTEGER*) &t_64);
t = (double)(t_64 - _glfwLibrary.Win32.timer.t0_64); t = (double)(t_64 - _glfwLibrary.Win32.timer.t0_64);
@ -91,7 +91,7 @@ void _glfwPlatformSetTime(double t)
{ {
__int64 t_64; __int64 t_64;
if (_glfwLibrary.Win32.timer.hasPerformanceCounter) if (_glfwLibrary.Win32.timer.hasPC)
{ {
QueryPerformanceCounter((LARGE_INTEGER*) &t_64); QueryPerformanceCounter((LARGE_INTEGER*) &t_64);
_glfwLibrary.Win32.timer.t0_64 = t_64 - (__int64) (t / _glfwLibrary.Win32.timer.resolution); _glfwLibrary.Win32.timer.t0_64 = t_64 - (__int64) (t / _glfwLibrary.Win32.timer.resolution);

6
src/window.c
View File

@ -85,6 +85,12 @@ void _glfwSetDefaultWindowHints(void)
// The default is to show the window and allow window resizing // The default is to show the window and allow window resizing
_glfwLibrary.hints.resizable = GL_TRUE; _glfwLibrary.hints.resizable = GL_TRUE;
_glfwLibrary.hints.visible = GL_TRUE; _glfwLibrary.hints.visible = GL_TRUE;
// The default is 24 bits of depth, 8 bits of color
_glfwLibrary.hints.depthBits = 24;
_glfwLibrary.hints.redBits = 8;
_glfwLibrary.hints.greenBits = 8;
_glfwLibrary.hints.blueBits = 8;
} }

27
src/x11_joystick.c
View File

@ -36,6 +36,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -109,6 +110,7 @@ static void pollJoystickEvents(void)
{ {
#ifdef _GLFW_USE_LINUX_JOYSTICKS #ifdef _GLFW_USE_LINUX_JOYSTICKS
int i; int i;
ssize_t result;
struct js_event e; struct js_event e;
for (i = 0; i <= GLFW_JOYSTICK_LAST; i++) for (i = 0; i <= GLFW_JOYSTICK_LAST; i++)
@ -117,8 +119,17 @@ static void pollJoystickEvents(void)
continue; continue;
// Read all queued events (non-blocking) // Read all queued events (non-blocking)
while (read(_glfwLibrary.X11.joystick[i].fd, &e, sizeof(e)) > 0) for (;;)
{ {
errno = 0;
result = read(_glfwLibrary.X11.joystick[i].fd, &e, sizeof(e));
if (errno == ENODEV)
_glfwLibrary.X11.joystick[i].present = GL_FALSE;
if (result < sizeof(e))
break;
// We don't care if it's an init event or not // We don't care if it's an init event or not
e.type &= ~JS_EVENT_INIT; e.type &= ~JS_EVENT_INIT;
@ -221,6 +232,8 @@ void _glfwTerminateJoysticks(void)
int _glfwPlatformGetJoystickParam(int joy, int param) int _glfwPlatformGetJoystickParam(int joy, int param)
{ {
pollJoystickEvents();
if (!_glfwLibrary.X11.joystick[joy].present) if (!_glfwLibrary.X11.joystick[joy].present)
return 0; return 0;
@ -247,20 +260,20 @@ int _glfwPlatformGetJoystickParam(int joy, int param)
// Get joystick axis positions // Get joystick axis positions
//======================================================================== //========================================================================
int _glfwPlatformGetJoystickPos(int joy, float* pos, int numAxes) int _glfwPlatformGetJoystickAxes(int joy, float* axes, int numAxes)
{ {
int i; int i;
pollJoystickEvents();
if (!_glfwLibrary.X11.joystick[joy].present) if (!_glfwLibrary.X11.joystick[joy].present)
return 0; return 0;
pollJoystickEvents();
if (_glfwLibrary.X11.joystick[joy].numAxes < numAxes) if (_glfwLibrary.X11.joystick[joy].numAxes < numAxes)
numAxes = _glfwLibrary.X11.joystick[joy].numAxes; numAxes = _glfwLibrary.X11.joystick[joy].numAxes;
for (i = 0; i < numAxes; i++) for (i = 0; i < numAxes; i++)
pos[i] = _glfwLibrary.X11.joystick[joy].axis[i]; axes[i] = _glfwLibrary.X11.joystick[joy].axis[i];
return numAxes; return numAxes;
} }
@ -275,11 +288,11 @@ int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons,
{ {
int i; int i;
pollJoystickEvents();
if (!_glfwLibrary.X11.joystick[joy].present) if (!_glfwLibrary.X11.joystick[joy].present)
return 0; return 0;
pollJoystickEvents();
if (_glfwLibrary.X11.joystick[joy].numButtons < numButtons) if (_glfwLibrary.X11.joystick[joy].numButtons < numButtons)
numButtons = _glfwLibrary.X11.joystick[joy].numButtons; numButtons = _glfwLibrary.X11.joystick[joy].numButtons;

48
src/x11_window.c
View File

@ -473,17 +473,10 @@ static void processSingleEvent(void)
// A keyboard key was pressed // A keyboard key was pressed
window = findWindow(event.xkey.window); window = findWindow(event.xkey.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for KeyPress event\n");
return; return;
}
// Translate and report key press
_glfwInputKey(window, translateKey(event.xkey.keycode), GLFW_PRESS); _glfwInputKey(window, translateKey(event.xkey.keycode), GLFW_PRESS);
// Translate and report character input
_glfwInputChar(window, translateChar(&event.xkey)); _glfwInputChar(window, translateChar(&event.xkey));
break; break;
} }
@ -492,10 +485,7 @@ static void processSingleEvent(void)
// A keyboard key was released // A keyboard key was released
window = findWindow(event.xkey.window); window = findWindow(event.xkey.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for KeyRelease event\n");
return; return;
}
// Do not report key releases for key repeats. For key repeats we // Do not report key releases for key repeats. For key repeats we
// will get KeyRelease/KeyPress pairs with similar or identical // will get KeyRelease/KeyPress pairs with similar or identical
@ -523,9 +513,7 @@ static void processSingleEvent(void)
} }
} }
// Translate and report key release
_glfwInputKey(window, translateKey(event.xkey.keycode), GLFW_RELEASE); _glfwInputKey(window, translateKey(event.xkey.keycode), GLFW_RELEASE);
break; break;
} }
@ -534,10 +522,7 @@ static void processSingleEvent(void)
// A mouse button was pressed or a scrolling event occurred // A mouse button was pressed or a scrolling event occurred
window = findWindow(event.xbutton.window); window = findWindow(event.xbutton.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ButtonPress event\n");
return; return;
}
if (event.xbutton.button == Button1) if (event.xbutton.button == Button1)
_glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS); _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS);
@ -566,10 +551,7 @@ static void processSingleEvent(void)
// A mouse button was released // A mouse button was released
window = findWindow(event.xbutton.window); window = findWindow(event.xbutton.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ButtonRelease event\n");
return; return;
}
if (event.xbutton.button == Button1) if (event.xbutton.button == Button1)
{ {
@ -597,10 +579,7 @@ static void processSingleEvent(void)
// The cursor entered the window // The cursor entered the window
window = findWindow(event.xcrossing.window); window = findWindow(event.xcrossing.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for EnterNotify event\n");
return; return;
}
if (window->cursorMode == GLFW_CURSOR_HIDDEN) if (window->cursorMode == GLFW_CURSOR_HIDDEN)
hideCursor(window); hideCursor(window);
@ -614,10 +593,7 @@ static void processSingleEvent(void)
// The cursor left the window // The cursor left the window
window = findWindow(event.xcrossing.window); window = findWindow(event.xcrossing.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for LeaveNotify event\n");
return; return;
}
if (window->cursorMode == GLFW_CURSOR_HIDDEN) if (window->cursorMode == GLFW_CURSOR_HIDDEN)
showCursor(window); showCursor(window);
@ -631,10 +607,7 @@ static void processSingleEvent(void)
// The cursor was moved // The cursor was moved
window = findWindow(event.xmotion.window); window = findWindow(event.xmotion.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for MotionNotify event\n");
return; return;
}
if (event.xmotion.x != window->X11.cursorPosX || if (event.xmotion.x != window->X11.cursorPosX ||
event.xmotion.y != window->X11.cursorPosY) event.xmotion.y != window->X11.cursorPosY)
@ -672,10 +645,7 @@ static void processSingleEvent(void)
// The window configuration changed somehow // The window configuration changed somehow
window = findWindow(event.xconfigure.window); window = findWindow(event.xconfigure.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ConfigureNotify event\n");
return; return;
}
_glfwInputWindowSize(window, _glfwInputWindowSize(window,
event.xconfigure.width, event.xconfigure.width,
@ -693,10 +663,7 @@ static void processSingleEvent(void)
// Custom client message, probably from the window manager // Custom client message, probably from the window manager
window = findWindow(event.xclient.window); window = findWindow(event.xclient.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for ClientMessage event\n");
return; return;
}
if ((Atom) event.xclient.data.l[0] == _glfwLibrary.X11.wmDeleteWindow) if ((Atom) event.xclient.data.l[0] == _glfwLibrary.X11.wmDeleteWindow)
{ {
@ -727,10 +694,7 @@ static void processSingleEvent(void)
// The window was mapped // The window was mapped
window = findWindow(event.xmap.window); window = findWindow(event.xmap.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for MapNotify event\n");
return; return;
}
_glfwInputWindowVisibility(window, GL_TRUE); _glfwInputWindowVisibility(window, GL_TRUE);
_glfwInputWindowIconify(window, GL_FALSE); _glfwInputWindowIconify(window, GL_FALSE);
@ -742,10 +706,7 @@ static void processSingleEvent(void)
// The window was unmapped // The window was unmapped
window = findWindow(event.xmap.window); window = findWindow(event.xmap.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for UnmapNotify event\n");
return; return;
}
_glfwInputWindowVisibility(window, GL_FALSE); _glfwInputWindowVisibility(window, GL_FALSE);
_glfwInputWindowIconify(window, GL_TRUE); _glfwInputWindowIconify(window, GL_TRUE);
@ -757,10 +718,7 @@ static void processSingleEvent(void)
// The window gained focus // The window gained focus
window = findWindow(event.xfocus.window); window = findWindow(event.xfocus.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for FocusIn event\n");
return; return;
}
_glfwInputWindowFocus(window, GL_TRUE); _glfwInputWindowFocus(window, GL_TRUE);
@ -775,10 +733,7 @@ static void processSingleEvent(void)
// The window lost focus // The window lost focus
window = findWindow(event.xfocus.window); window = findWindow(event.xfocus.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for FocusOut event\n");
return; return;
}
_glfwInputWindowFocus(window, GL_FALSE); _glfwInputWindowFocus(window, GL_FALSE);
@ -793,10 +748,7 @@ static void processSingleEvent(void)
// The window's contents was damaged // The window's contents was damaged
window = findWindow(event.xexpose.window); window = findWindow(event.xexpose.window);
if (window == NULL) if (window == NULL)
{
fprintf(stderr, "Cannot find GLFW window structure for Expose event\n");
return; return;
}
_glfwInputWindowDamage(window); _glfwInputWindowDamage(window);
break; break;

51
tests/glfwinfo.c
View File

@ -119,6 +119,32 @@ static void list_extensions(int major, int minor)
putchar('\n'); putchar('\n');
} }
static GLboolean valid_version(void)
{
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
if (major != GLFW_VERSION_MAJOR)
{
printf("*** ERROR: GLFW major version mismatch! ***\n");
return GL_FALSE;
}
if (minor != GLFW_VERSION_MINOR || revision != GLFW_VERSION_REVISION)
printf("*** WARNING: GLFW version mismatch! ***\n");
printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
return GL_TRUE;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
int ch, profile = 0, strategy = 0, major = 1, minor = 0, revision; int ch, profile = 0, strategy = 0, major = 1, minor = 0, revision;
@ -126,6 +152,9 @@ int main(int argc, char** argv)
GLint flags, mask; GLint flags, mask;
GLFWwindow window; GLFWwindow window;
if (!valid_version())
exit(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "dfhlm:n:p:r:")) != -1) while ((ch = getopt(argc, argv, "dfhlm:n:p:r:")) != -1)
{ {
switch (ch) switch (ch)
@ -181,6 +210,8 @@ int main(int argc, char** argv)
argc -= optind; argc -= optind;
argv += optind; argv += optind;
// Initialize GLFW and create window
glfwSetErrorCallback(error_callback); glfwSetErrorCallback(error_callback);
if (!glfwInit()) if (!glfwInit())
@ -218,26 +249,6 @@ int main(int argc, char** argv)
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
// Report GLFW version
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
if (major != GLFW_VERSION_MAJOR ||
minor != GLFW_VERSION_MINOR ||
revision != GLFW_VERSION_REVISION)
{
printf("*** WARNING: GLFW version mismatch! ***\n");
}
printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
// Report OpenGL version // Report OpenGL version
printf("OpenGL context version string: \"%s\"\n", glGetString(GL_VERSION)); printf("OpenGL context version string: \"%s\"\n", glGetString(GL_VERSION));

2
tests/joysticks.c
View File

@ -137,7 +137,7 @@ static void refresh_joysticks(void)
j->axes = realloc(j->axes, j->axis_count * sizeof(float)); j->axes = realloc(j->axes, j->axis_count * sizeof(float));
} }
glfwGetJoystickPos(GLFW_JOYSTICK_1 + i, j->axes, j->axis_count); glfwGetJoystickAxes(GLFW_JOYSTICK_1 + i, j->axes, j->axis_count);
button_count = glfwGetJoystickParam(GLFW_JOYSTICK_1 + i, GLFW_BUTTONS); button_count = glfwGetJoystickParam(GLFW_JOYSTICK_1 + i, GLFW_BUTTONS);
if (button_count != j->button_count) if (button_count != j->button_count)