PDA

View Full Version : Need Help Writing Custom Base Code



31337
10-14-2002, 06:33 PM
I'm trying to convert my upcoming paintball game's basecode from NeHe's windows.h basecode to glfw. But for some wierd reason, all I get is a blank screen. I was wondering if anybody could check out my source code and possibly verify what the problem is. Soooo without further ado here it is:

#include <gl\glaux.h> // Header File For The GLaux Lib
#include <windows.h> // Header File For Window$
#include <stdio.h> // Header File For Input/Output
#include <gl\gl.h> // Header File For The GL Library
#include <gl\glu.h> // Header File For The GLu Library
#include <iostream.h> // Header for C++ console input/output
#include <fstream.h> // Header for C++ file I/O
#include <string.h> // Header for working with strings
#include <gl\glut.h> // Header for GLUT
#include <math.h> // Header for sine and cosine
#include <gl\glfw.h> // Header for glfw
#include <stdarg.h>

// Start doing all definitions
#define startingAngle 240
#define numberOfTextures 2

extern PersonWithGun();

// We don't wanto use global variables, they are the DEVIL!

// Here's a class to store all of our input settings
// We will be doing this to avoid the use of global variables
// Global variables lead to "sloppy program structure" which != good http://www.opengl.org/discussion_boards/ubb/smile.gif

class texture {
public:
GLuint textureID;
};

class mapClass {
public: // These need to be public
int mapX; // The map x variable
int mapY; // The map y variable
int **map; // The map somethin somethin variable
};

class inputClass {
public:
int mouseX; // The current mouse position on the x axis
int mouseY; // The current mouse position on the y axis
int scrollbarPosition; // The current mouse scrollbar position
int oscrollbarPosition; // This is the old mouse scrollbar position
int oldMouseX; // The old mouse position on the x axis
int oldMouseY; // The old mouse position on the y axis
};

class player {
public:
float playersAngle; // The angle the player is facing
float playersXYZ[3]; // The location of the player
int PersonID; // Integer value for the person model
};

// Here we will turn the above classes into objects
player playerInfo;
inputClass inputObject;
mapClass mapVars;
texture textureObject[numberOfTextures];

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc

int loadMap(const char *filename) {
int i, j;
mapVars.mapX = 0, mapVars.mapY = 0;
char buffer[64];
FILE *inputfile = fopen(filename,"r");

i = -1;
do
{
buffer[++i] = fgetc(inputfile);

} while (buffer[i] != 'X');
buffer[i] = '\0';
sscanf(buffer, "%d", &mapVars.mapX);

i = -1;
do
{
buffer[++i] = fgetc(inputfile);

} while (buffer[i] != '\n');
buffer[i] = '\0';
sscanf(buffer, "%d", &mapVars.mapY);

mapVars.map = new int*[mapVars.mapX];
for (i=0; i<mapVars.mapX; i++)
{
mapVars.map[i] = new int[mapVars.mapY];
}

for(i=0; i<mapVars.mapX;i++) {
for(j=0; j<mapVars.mapY;j++) {
buffer[0] = fgetc(inputfile);
buffer[1] = '\0';
mapVars.map[i][j] = atoi(buffer);
}
fgetc(inputfile); // this will read in the new line character
}

fclose(inputfile);
return 1;
}

GLvoid drawBox( long float x, long float y, long float z ) {

glBindTexture(GL_TEXTURE_2D, textureObject[0].textureID);
glBegin( GL_QUADS );
glColor3f(1, 1, 1); // Incase the texturing failed make the boxes white
// The basic shape of the box

// Also will use the box texture loaded by LoadGLTextures()

// The bottom of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y,z+1);

// The top of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y+1,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z+1);

// The left side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y,z+1);

// The right side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x+1,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x+1,y,z+1);

// The front side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z);

// The back side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z+1);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z+1 );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z+1);

glEnd();

}

GLint drawLandscape() {


glBindTexture(GL_TEXTURE_2D, textureObject[1].textureID);
glPushMatrix();
glTranslatef(0,-0.0001,0);
glBegin( GL_QUADS ); // The floor will just be a big textured rectangle
glColor3f(0.111,0.111,0.111); // Incase it doesn't texture the floor will be white!
glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,0,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,0,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,-0.2,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,-0.2,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,-100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,-100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(-100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,-100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(100,-0.2,-100); // Upper left hand corner

glEnd();
glPopMatrix();


int i, j;

//if (loadMap("demomap.map")) {
for(i=0; i<mapVars.mapX; i++) {
for(j=0; j<mapVars.mapY; j++) {
if (mapVars.map[i][j]==1) {
drawBox(i*2, 0, j*2);
}
}
cout << endl;
}
// }

return true;
}

int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
// Setup all of the class values
playerInfo.playersAngle = startingAngle;
playerInfo.playersXYZ[0] = 0;
playerInfo.playersXYZ[1] = 0;
playerInfo.playersXYZ[2] = 0;

inputObject.oldMouseX = 0;
inputObject.oldMouseY = 0;
glfwDisable( GLFW_MOUSE_CURSOR );

loadMap("Maps\\demomap.map");

// Here we will load our textures for the floor and the box
glGenTextures( 1, &textureObject[1].textureID);
glBindTexture( GL_TEXTURE_2D, textureObject[1].textureID);
glfwLoadTexture2D( "Textures\\floor.tga", GLFW_BUILD_MIPMAPS_BIT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glGenTextures( 1, &textureObject[0].textureID);
glBindTexture( GL_TEXTURE_2D, textureObject[0].textureID );
glfwLoadTexture2D( "Textures\\box.tga", GLFW_BUILD_MIPMAPS_BIT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glEnable( GL_TEXTURE_2D );

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping (important)
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
return 0; // Initialization Went OK
}

int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
{ int width, height; // Window dimensions
glfwGetWindowSize( &width, &height );
height = height < 1 ? 1 : height;
glViewport( 0, 0, width, height );

glfwDisable( GLFW_MOUSE_CURSOR );
inputObject.scrollbarPosition = glfwGetMouseWheel();
if(inputObject.oldMouseX < inputObject.mouseX) { // compare the mouse variables accordingly
playerInfo.playersAngle+=1;}

if(inputObject.oldMouseX > inputObject.mouseX) {
playerInfo.playersAngle-=0.01; }
if(inputObject.scrollbarPosition > inputObject.oscrollbarPosition) {
glScalef(0.01, 0.01, 0.01); }
if(inputObject.scrollbarPosition < inputObject.oscrollbarPosition) {
glScalef(10, 10, 10); }

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity();
// Follow the person
gluLookAt(
playerInfo.playersXYZ[0]+cos(playerInfo.playersAngle)*2, playerInfo.playersXYZ[1]+2, playerInfo.playersXYZ[2]+sin(playerInfo.playersAngle)*2,
playerInfo.playersXYZ[0], playerInfo.playersXYZ[1], playerInfo.playersXYZ[2],
0, 1, 0);

glMatrixMode( GL_MODELVIEW ); // We need to be in the MODELVIEW matrix for gluLookAt()

if(playerInfo.playersAngle<=0) {
playerInfo.playersAngle+=360;
}

drawLandscape();

glColor3f(1,0.2,0.2);

glTranslatef(playerInfo.playersXYZ[0],playerInfo.playersXYZ[1]+0.4,playerInfo.playersXYZ[2]);

glRotatef(playerInfo.playersAngle,0,1,0);
glColor3f(0.5, 0.2, 0.25);
glCallList(playerInfo.PersonID);

inputObject.oldMouseX = inputObject.mouseX;
inputObject.oldMouseY = inputObject.mouseY;
inputObject.oscrollbarPosition = inputObject.scrollbarPosition;
return TRUE; // Everything Went OK

}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
{
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}

glViewport(0,0,width,height); // Reset The Current Viewport

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix

}

int main(int argc, char* argv[])
{
inputObject.mouseX = 0;
inputObject.mouseY = 0;
int major, minor, rev;
int running;

if( glfwInit() != GL_TRUE ) { // Initialize glfw
cout << "ERROR CODE 103: GLFW FAILED TO INITIALIZE!" << endl;
}

// Display the glfw version
glfwGetVersion(&major, &minor, &rev);
cout << "GLFW version: " << major << "." << minor << "." << rev << endl;
if(major != 2 &#0124; &#0124; minor != 1 &#0124; &#0124; rev != 0) {
cout << "WARNING: YOUR GLFW VERSION IS DIFFERENT THAN THE INTENDED" << endl
<< "VERSION. INTENDED VERSION IS 2.0.1" << endl;
}

// Now we must produce the window for the program
// If it failed warn the user and attempt to continue
if( glfwOpenWindow( 1280, 1024, 8, 8, 8, 8, 24, 0,GLFW_FULLSCREEN ) != GL_TRUE) {
// Lets warn the user
cout << "ERROR CODE 201: THE WINDOW COULD NOT BE OPENED" << endl;
}

if ( InitGL() != 0 ) {
cout << "ERROR CODE: 32, InitGL failed to initialize." << endl;
}

do {

DrawGLScene();
glfwSwapBuffers();
running = !glfwGetKey( GLFW_KEY_ESC ) &&
glfwGetWindowParam( GLFW_OPENED );



}
while( running );
// Close the window we created
glfwCloseWindow();

glfwTerminate(); // Kill glfw
return 0;
}

nexusone
10-15-2002, 06:24 AM
Maybe it the Devil in your code, that is causing the problems or all the global variables you have in your progam....... http://www.opengl.org/discussion_boards/ubb/smile.gif

It is sloppy to use global variables when only a local is needed.... but not sloppy when they are used correctly....


int players; // global


void noid(void)
{
int i; local

dosomething();

}

After looking over your code, it look like you are drawing behind the camera your scene.

You near starts at 0.1 and your scene starts at your scene at 0.0001! Try changing that to say 1.0!

I see you call glViewport twice, the function of glViewport is tell opengl the window size to render too. Remove it from your draw_scene routine, since it should only be called when the window has been resized by the user.
Just delete all of this from drawscene routine:

glfwGetWindowSize( &width, &height );
height = height < 1 ? 1 : height;
glViewport( 0, 0, width, height );

// Also change drawscene here items in this order.

glClear(.................);
glMatrixMode( GL_MODELVIEW );// Draw mode
glLoadIdentity(); // Reset matrix

gluLookAt(........);


[This message has been edited by nexusone (edited 10-15-2002).]

31337
10-15-2002, 06:55 AM
I did the changes you suggested involving the viewport however I still get a black screen. I did a search through my code for 0.0001 and all I saw it for was a translation which I took out and I still get a black screen. How do I make it so my scene isn't getting drawn behind my camera? Thanks for your help btw

nexusone
10-15-2002, 07:51 AM
After looking more at your code:

In the draw land scape routine,
You are translating on the Y axis which is up/down.
Change to glTranslatef(0.0, 0.0, -1.0); also try -1.0 to -100.0 to bring you scene into view.
With out any Rotation of the scene, -Z forward looking and +Z is behind you.


Also in your draw routine, after your draw the land scape. You then draw the player, are you wanting a first person view?

You may want to use glPush/pop matrix() around the gltranslate for the player.



Originally posted by 31337:
I did the changes you suggested involving the viewport however I still get a black screen. I did a search through my code for 0.0001 and all I saw it for was a translation which I took out and I still get a black screen. How do I make it so my scene isn't getting drawn behind my camera? Thanks for your help btw



[This message has been edited by nexusone (edited 10-15-2002).]

31337
10-15-2002, 04:03 PM
No I'm going for third person. I will check out what you were talking about...

31337
10-15-2002, 04:08 PM
I tried looping through -100 to 100 for the translation of the landscape and still nothing... Also, I push/popMatrix'd the character translations but still no good. I think its something to do with the way the window is being rendered or the basecode because with the win32 basecode this ran perfectly fine.

nexusone
10-16-2002, 05:42 AM
Found another thing that maybe a cause of your problems in gluPerspective.

gluPerspective(45.0f, w/h, 1.0f, 100.0f) Note that you used 0.1 for your near setting, I think you can not use a number less then one here, so replace the 0.1 with 1.0.

As for glfw, have not used it.



Originally posted by 31337:
I tried looping through -100 to 100 for the translation of the landscape and still nothing... Also, I push/popMatrix'd the character translations but still no good. I think its something to do with the way the window is being rendered or the basecode because with the win32 basecode this ran perfectly fine.

31337
10-16-2002, 07:13 AM
Nope still nothing. anyways using 0.1 worked with my windows.h basecode... I've spent a lot of time looking through this and trying to find out why I'm not getting anything, but I just don't see it.

31337
10-16-2002, 01:28 PM
Ok, I tried taking out gluLookAt() and I see stuff, so I'm guessing it isn't a problem with the basecode. But in that case then why does it work perfectly with the win32 basecode? Any ideas? I'll look through the win32 basecode some more

31337
10-17-2002, 06:37 AM
Ok I've looked through the win32 basecode and I still don't understand why gluLookAt is causing problems...

marcus256
10-17-2002, 11:00 AM
Hi! Glad to see you're switching to GLFW http://www.opengl.org/discussion_boards/ubb/wink.gif

This sound as a typical OpenGL related problem, not basecode. My best guess is that you are doing things in another order than you did before. Check your loops and how you call your functions. Another possibility is that you deleted (or added) something by mistake when you did your port.

I'll have a look at the code and see if I can spot something.

31337
10-17-2002, 03:53 PM
Hmm I hadn't thought about that. I'll keep looking through it more as well. Thanks for your help

31337
10-18-2002, 05:33 PM
Ok maybe posting the win32 basecode will help. And yes it is NeHe's and I'm using it with his permission but I wanto change it so I can say I wrote everything myself and didn't just gank other people's code. Without further ado here it is:

/* Thanks goes to NeHe - written by Jeff Jensen */

#include <gl\glaux.h> // Header File For The GLaux Lib
#include <windows.h> // Header File For Window$
#include <stdio.h> // Header File For Input/Output
#include <gl\gl.h> // Header File For The GL Library
#include <gl\glu.h> // Header File For The GLu Library
#include <iostream.h> // Header for C++ console input/output
#include <fstream.h> // Header for C++ file I/O
#include <string.h> // Header for working with strings

extern PersonWithGun();

HDC hDC=NULL; // Private GDI Device Context
HGLRC hRC=NULL; // Permanent Rendering Context
HWND hWnd=NULL; // Holds Our Window Handle
HINSTANCE hInstance; // Holds The Instance Of The Application

bool keys[256]; // Array Used For The Keyboard Routine
bool active=TRUE; // Window Active Flag Set To TRUE By Default
bool fullscreen=TRUE; // Fullscreen Flag Set To Fullscreen Mode By Default

float playersXYZ[3]; // Storing the players X, Y, and Z
int PersonID; // person display list id

// Making an OBJ class

class OBJ {
public:
float vertices[10000];
float textureVertices[10000];
float lightingNormals[10000];

int verts;
int texCords;
int normals;
};

// Declare class objects here
OBJ OBJData[10]; // Storing room for 10 obj models


/*struct OBJ;


// This is key as it will probably be passed to the drawOBJ function afterwards.
struct OBJ{

float * vertices2;
float * normals;
float * uvs;
int * faces;
int nVertices;
int nNormals;
int nUvs;
int nFaces;


};
*/

GLuint texture[10]; // Storage For One Texture

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc

AUX_RGBImageRec *LoadBMP(char *Filename) // Loads A Bitmap Image
{
FILE *File=NULL; // File Handle

if (!Filename) // Make Sure A Filename Was Given
{
MessageBox(NULL,"No filename given for texture","ERROR",MB_OK|MB_ICONEXCLAMATION);
return NULL; // If Not Return NULL
}

File=fopen(Filename,"r"); // Check To See If The File Exists

if (File) // Does The File Exist?
{
fclose(File); // Close The Handle
return auxDIBImageLoad(Filename); // Load The Bitmap And Return A Pointer
}
if (!File) {
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
}

return NULL; // If Load Failed Return NULL
}

// This function will eventually need several arguements.
// Particularly the area in the memory where the texture
// Is stored.

int drawOBJ(const int memLocation) {

// We'll use the counterv array for keeping track of the drawing
int counterv[3] = { 0,0,0 };

glBegin( GL_LINE_STRIP ); // Draw the wire frame of the OBJ in white
glColor3f(1,1,1);
while(OBJData[memLocation].vertices[counterv[0]] <= OBJData[memLocation].verts) {

// Start with the texture coordinates

// Check to make SURE your not reading free memory
if(OBJData[memLocation].textureVertices[counterv[1]] <= OBJData[memLocation].texCords ) {

glTexCoord2f(
OBJData[memLocation].textureVertices[counterv[1]],
OBJData[memLocation].textureVertices[counterv[1]+1]
);
}

// Check to make SURE your not reading free memory


// here's the vertices for the model
glVertex3f(
OBJData[memLocation].vertices[counterv[0]],
OBJData[memLocation].vertices[counterv[0]+1],
OBJData[memLocation].vertices[counterv[0]+2] );
counterv[0]+=3;


}
glEnd();
return 1;
}

int readOBJ(const int memLocation, const char *filename) {

OBJData[memLocation].verts = 0;
OBJData[memLocation].texCords = 0;
OBJData[memLocation].normals = 0;


// struct OBJ retOBJ;

char verticeType[3];
float verticeCords[3];
int counterv[3] = { 0,0,0 };

FILE *inputfile;
inputfile = fopen(filename,"r");
int lineCount[4] = { 0, 0, 0, 0}; // Set the line count to zero
/* First step: find out how many lines there are that start with each letter */

// strcmp returns 0 if the strings passed to it are the same
while(!feof(inputfile))
{
if( strcmp(verticeType,"v") == 0) {
lineCount[0]+=1; // Count the number of vertices
}
if( strcmp(verticeType,"vt") == 0) {
lineCount[1]+=1; // Count the number of lighting normals
}
if( strcmp(verticeType,"vn") == 0) {
lineCount[2]+=1; // Count the number of lighting normals
}
if( strcmp(verticeType,"f") == 0) {
lineCount[3]+=1; // Count the number of polygon faces
}
if( strcmp(verticeType,"#") == 0) {
// this is a comment line
}
}

fclose(inputfile);

// Assign the class the number of vertices, normals, and texture cords
OBJData[memLocation].verts = lineCount[0];
OBJData[memLocation].texCords = lineCount[1];
OBJData[memLocation].normals = lineCount[2];

/* End of first step, done counting lines */

// Now we need to approximate how much memory must be reserved
// For loading the model into memory.


/* Replace this array setup with vectors
int a,b,c;
a = lineCount[0] * 3;
b = lineCount[1] * 2;
c = lineCount[2] * 3;

float vertices[lineCount[0]*3];
float textureVertices[B];
float lightingNormals[c];
*/



// Here's the vector declaration, in a structure for easy passing to and fro
// At the end of this function all the data in this gets returned.
// This is key as it will probably be passed to the drawOBJ function afterwards.

// Just incase something fishy happened with the
// Texture we will declare the color as red.
glColor3f(1,0,0);

FILE *inputfile2;
inputfile2 = fopen(filename,"r");

while(fscanf(inputfile, "%s %f %f %f", verticeType, verticeCords[0], verticeCords[1], verticeCords[2]) != EOF) {

/* With the obj format, if the line begins with a
v then it is a model vertex. If it begins with
a vn then it is a lighting normal. If it begins
with a vt it is a texture coordinate.

Something that needs to be taken into account as well
is that some lines will begin with a f for a polygon
face but that will be loaded later because it is
pretty abstract and doesnt fit into this loop.
*/

// A standard vertice
// We are now loading all of the vertices into memory
if(verticeType=="v") {
OBJData[memLocation].vertices[counterv[0]] = verticeCords[0];
OBJData[memLocation].vertices[counterv[0]+1] = verticeCords[1];
OBJData[memLocation].vertices[counterv[0]+2] = verticeCords[2];
counterv[0]+=3;
// glVertex3f(virticeCords[0],virticeCords[1],virticeCords[2]);
// We dont wanto draw it we wanto load the vertice into the memory
}
// A texture coordinate
if(verticeType=="vt") {
OBJData[memLocation].textureVertices[counterv[1]] = verticeCords[0];
OBJData[memLocation].textureVertices[counterv[1]+1] = verticeCords[1];
counterv[1]+=2;
// glTexCoord2f(virticeCords[0], virticeCords[1]);
// We dont wanto texture map it we wanto load the vertice into the memory
}
// A lighting normal
if(verticeType=="vn") {
OBJData[memLocation].lightingNormals[counterv[2]] = verticeCords[0];
OBJData[memLocation].lightingNormals[counterv[2]+1] = verticeCords[1];
OBJData[memLocation].lightingNormals[counterv[2]+2] = verticeCords[2];
counterv[2]+=3;
// glNormal3f( virticeCords[0], virticeCords[1], virticeCords[2]);
// We don't wanto load the normal YET we just wanto load the normal into memory.
}

/* That should be evreything needed to draw the model
and texture it and light it up appropriately
EXCEPT for the standard polygon faces
which are designated by a line starting with a f.
*/

}

fclose(inputfile2);

/* Now scanning for lines that begin with f. The format
is as follows:

f int/int/int int/int/int int/int/int

The sets of integers are vertex positions, texture cord's
and lighting normals respectivly. Each polygon face
has to be flat and convex according to the obj standard.
The difficult part about this is that there is no limit to
how many virtices a polygon can have. However I will assume
a limit which could cause some discrepincies in the display
from the file but should save a lot of memory and make it a
lot easier on me http://www.opengl.org/discussion_boards/ubb/smile.gif The limit is 5 vertices for a polygon
face. There ya go! I am basing this off of the fact that
when I open the test model I cannot scroll left or right.
Therefore there arn't any massivly vertex consuming polygons.
*/

/*

int vertices[5];
int texturecords[5];
int lightingnormals[5];

fopen(filename,'r');

while(fscanf(inputfile, "%s %f/%f/%f %f/%f/%f %f/%f/%f %f/%f/%f %f/%f/%f),
verticeType, vertices[0], texturecords[0], lightingnormals[0],
vertices[1], texturecords[1], lightingnormals[1],
vertices[2], texturecords[2], lightingnormals[2],
vertices[3], texturecords[3], lightingnormals[3],
vertices[4], texturecords[4], lightingnormals[4],) {

if(verticeType=="f") {
glBegin( GL_POLYGON );

glEnd();
}

}

fclose(inputfile);
*/

return 1;
}

int LoadGLTextures(int textureID, char *Filename) // Load Bitmaps And Convert To Textures
{
int Status=FALSE; // Status Indicator

AUX_RGBImageRec *TextureImage[10]; // Create Storage Space For The Texture

memset(TextureImage,0,sizeof(void *)*1); // Set The Pointer To NULL

// Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
//if (TextureImage[textureID]=LoadBMP("Textures/box.bmp"))
if (TextureImage[textureID]=LoadBMP(Filename))
{
Status=TRUE; // Set The Status To TRUE

glGenTextures(1, &texture[textureID]); // Create The Texture

// Typical Texture Generation Using Data From The Bitmap
glBindTexture(GL_TEXTURE_2D, texture[textureID]);
glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[textureID]->sizeX, TextureImage[textureID]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[textureID]->data);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTE R,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTE R,GL_LINEAR);
}

if (TextureImage[textureID]) // If Texture Exists
{
if (TextureImage[textureID]->data) // If Texture Image Exists
{
free(TextureImage[textureID]->data); // Free The Texture Image Memory
}

free(TextureImage[textureID]); // Free The Image Structure
}

return Status; // Return The Status
}

GLint drawLandscape() {


glBindTexture(GL_TEXTURE_2D, texture[1]);
glBegin( GL_QUADS ); // The floor will just be a big textured rectangle
glColor3f(0.111,0.111,0.111); // Incase it doesn't texture the floor will be white!
glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,0,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,0,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,-0.2,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,-0.2,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,-100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,-100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(-100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,-100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(100,-0.2,-100); // Upper left hand corner

glEnd();
return true;
}

GLvoid drawBox( long float x, long float y, long float z ) {

glBindTexture(GL_TEXTURE_2D, texture[0]);
glBegin( GL_QUADS );
glColor3f(1, 1, 1); // Incase the texturing failed make the boxes white
// The basic shape of the box

// Also will use the box texture loaded by LoadGLTextures()

// The bottom of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y,z+1);

// The top of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y+1,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z+1);

// The left side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y,z+1);

// The right side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x+1,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x+1,y,z+1);

// The front side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z);

// The back side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z+1);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z+1 );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z+1);

glEnd();

}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
{
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}

glViewport(0,0,width,height); // Reset The Current Viewport

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix

}

int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
// Since this only runs once we should do all loading here, including obj
// Models
// readOBJ(0, "Models\\personwithgun.obj"); // This will load the OBJ model into the 0 slot
playersXYZ[0] = 0;
playersXYZ[1] = 0;
playersXYZ[2] = 0;
if (!LoadGLTextures(0,"Textures/box.bmp")) // Jump To Texture Loading Routine
{
MessageBox(NULL,"Couldn't load Textures/box.bmp","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // If Texture Didn't Load Return FALSE
}
if (!LoadGLTextures(1,"Textures/floor.bmp")) // Jump To Texture Loading Routine
{
MessageBox(NULL,"Couldn't load Textures/floor.bmp","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // If Texture Didn't Load Return FALSE
}
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping (important)
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
return TRUE; // Initialization Went OK
}

int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer

glMatrixMode( GL_MODELVIEW ); // We need to be in the MODELVIEW matrix for gluLookAt()
gluLookAt(playersXYZ[0], playersXYZ[1]+10, playersXYZ[2], playersXYZ[0], playersXYZ[1], playersXYZ[2], 0, 1, 0); // Follow the person
glLoadIdentity(); // Reset The Current Modelview Matrix

glTranslatef(-1.5f,0.0f,-6.0f); // Move Left 1.5 Units And Into The Screen 6.0

// Now to start drawing
// drawLandscape();
glCallList(PersonID);

drawBox(0,0,0);
drawLandscape();
// drawOBJ(0);
// Render the temporary person!
glColor3f(1,0.2,0.2);


return TRUE; // Everything Went OK
}

GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
{
if (fullscreen) // Are We In Fullscreen Mode?
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}

if (hRC) // Do We Have A Rendering Context?
{
if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
{
MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
}

if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
{
MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
}
hRC=NULL; // Set RC To NULL
}

if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
{
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hDC=NULL; // Set DC To NULL
}

if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
{
MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hWnd=NULL; // Set hWnd To NULL
}

if (!UnregisterClass("OpenGL",hInstance)) // Are We Able To Unregister Class
{
MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hInstance=NULL; // Set hInstance To NULL
}
}

/* This Code Creates Our OpenGL Window. Parameters Are: *
* title - Title To Appear At The Top Of The Window *
* width - Width Of The GL Window Or Fullscreen Mode *
* height - Height Of The GL Window Or Fullscreen Mode *
* bits - Number Of Bits To Use For Color (8/16/24/32) *
* fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height

fullscreen=fullscreenflag; // Set The Global Fullscreen Flag

hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name

if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if (fullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWID TH|DM_PELSHEIGHT;

// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCC ESSFUL)
{
// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","Jensen GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE
}
else
{
// Pop Up A Message Box Letting User Know The Program Is Closing.
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE; // Return FALSE
}
}
}

if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}

AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size

// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};

if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen

if (!InitGL()) // Initialize Our Newly Created GL Window
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

return TRUE; // Success
}

LRESULT CALLBACK WndProc( HWND hWnd, // Handle For This Window
UINT uMsg, // Message For This Window
WPARAM wParam, // Additional Message Information
LPARAM lParam) // Additional Message Information
{
switch (uMsg) // Check For Windows Messages
{
case WM_ACTIVATE: // Watch For Window Activate Message
{
if (!HIWORD(wParam)) // Check Minimization State
{
active=TRUE; // Program Is Active
}
else
{
active=FALSE; // Program Is No Longer Active
}

return 0; // Return To The Message Loop
}

case WM_SYSCOMMAND: // Intercept System Commands
{
switch (wParam) // Check System Calls
{
case SC_SCREENSAVE: // Screensaver Trying To Start?
case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?
return 0; // Prevent From Happening
}
break; // Exit
}

case WM_CLOSE: // Did We Receive A Close Message?
{
PostQuitMessage(0); // Send A Quit Message
return 0; // Jump Back
}

case WM_KEYDOWN: // Is A Key Being Held Down?
{
keys[wParam] = TRUE; // If So, Mark It As TRUE
return 0; // Jump Back
}

case WM_KEYUP: // Has A Key Been Released?
{
keys[wParam] = FALSE; // If So, Mark It As FALSE
return 0; // Jump Back
}

case WM_SIZE: // Resize The OpenGL Window
{
ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height
return 0; // Jump Back
}
}

// Pass All Unhandled Messages To DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

void InitDisplayLists()
{
PersonID = PersonWithGun();
}

int WINAPI WinMain( HINSTANCE hInstance, // Instance
HINSTANCE hPrevInstance, // Previous Instance
LPSTR lpCmdLine, // Command Line Parameters
int nCmdShow) // Window Show State
{


MSG msg; // Windows Message Structure
BOOL done=FALSE; // Bool Variable To Exit Loop

// Ask The User Which Screen Mode They Prefer
if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
{
fullscreen=FALSE; // Windowed Mode
}

// Create Our OpenGL Window
if (!CreateGLWindow("Elite Paintball 2.0",640,480,32,fullscreen))
{
return 0; // Quit If Window Was Not Created
}

InitDisplayLists();

while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
if (active) // Program Active?
{
if (keys[VK_ESCAPE]) // Was ESC Pressed?
{
done=TRUE; // ESC Signalled A Quit
}
else // Not Time To Quit, Update Screen
{
DrawGLScene(); // Draw The Scene
SwapBuffers(hDC); // Swap Buffers (Double Buffering)
}
}

if (keys[VK_F1]) // Is F1 Being Pressed?
{
keys[VK_F1]=FALSE; // If So Make Key FALSE
KillGLWindow(); // Kill Our Current Window
fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode
// Recreate Our OpenGL Window
if (!CreateGLWindow("Elite Paintball",1280,1024,32,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
}
}
}

// Shutdown
KillGLWindow(); // Kill The Window
return (msg.wParam); // Exit The Program
}

marcus256
10-19-2002, 03:41 PM
Hi!

Some things:

1) Do not glfwDisable( GLFW_MOUSE_CURSOR ) every frame - this is something you do at Init (you already do that)

2) I can't see where you get your mouse X/Y coordinates in the GLFW code

3) If you want to check the GLFW version, only check the major & minor numbers (revision is only bugfixes, no API change). Also, think of major/minor like this: different major == possible API change (different functionality), different minor == possible API addition (new functions, but old functions work as they did before).

4) I would change the includes to:


#include <windows.h> // Header File For Window$ (if you want MessageBox, otherwise remove it)
#include <stdio.h> // Header File For Input/Output
#include <string.h> // Header for working with strings
#include <stdarg.h>
#include <iostream.h> // Header for C++ console input/output
#include <fstream.h> // Header for C++ file I/O
#include <math.h> // Header for sine and cosine
#include <gl/glfw.h> // Header for GLFW, OpenGL and GLU
Do you use them all? Your app would be portable to e.g. Linux if you don't use <windows.h> (nor WinMain). And don't use back-slashes (\) for paths, your compiler converts / to \ if needed.

Also, it is much simpler to read your code if you use the [ code ] & [ /code ] markers around your code (without the spaces) http://www.opengl.org/discussion_boards/ubb/wink.gif



[This message has been edited by marcus256 (edited 10-19-2002).]

31337
10-19-2002, 04:04 PM
Thanks I'll change those ASAP, however do you have any idea why it isn't drawing?

31337
10-19-2002, 04:23 PM
Ok I made all the changes you suggested. Now however when I move the mouse left and right it rotates (I dont think it rotates correctly but it is rotating which is a start) and I can see the top of the boxes at the bottom of my screen. Here's the new code:




// glfwTest.cpp : An attempt at using a new basecode for Elite Paintball 2.0
//
// /-\
// ---- ----
// / Dedicated \
// / TO \
// / Nick \
// /----------------------\
//
// May he always be remembered...
// Nick died in a car crash while driving with some friends to
// UC Berkley. I will never forget him.
// NEW INCLUDES

#include <stdio.h> // Header File For Input/Output
#include <string.h> // Header for working with strings
#include <stdarg.h>
#include <iostream.h> // Header for C++ console input/output
#include <fstream.h> // Header for C++ file I/O
#include <math.h> // Header for sine and cosine
#include <gl/glfw.h> // Header for GLFW, OpenGL and GLU
#include <gl/gl.h> // Header file for OpenGL <http://www.opengl.org>
#include <gl/glaux.h> // Header file for GLaux
#include <gl/glu.h> // Header file for glu


/* OLD INCLUDES
#include <gl\glaux.h> // Header File For The GLaux Lib
#include <windows.h> // Header File For Window$
#include <stdio.h> // Header File For Input/Output
#include <gl\gl.h> // Header File For The GL Library
#include <gl\glu.h> // Header File For The GLu Library
#include <iostream.h> // Header for C++ console input/output
#include <fstream.h> // Header for C++ file I/O
#include <string.h> // Header for working with strings
#include <gl\glut.h> // Header for GLUT
#include <math.h> // Header for sine and cosine
#include <gl\glfw.h> // Header for glfw
#include <stdarg.h>
*/


// Start doing all definitions
#define startingAngle 240
#define numberOfTextures 2

extern PersonWithGun();

// We don't wanto use global variables, they are the DEVIL!

// Here's a class to store all of our input settings
// We will be doing this to avoid the use of global variables
// Global variables lead to "sloppy program structure" which != good http://www.opengl.org/discussion_boards/ubb/smile.gif

class texture {
public:
GLuint textureID;
};

class mapClass {
public: // These need to be public
int mapX; // The map x variable
int mapY; // The map y variable
int **map; // The map somethin somethin variable
};

class inputClass {
public:
int mouseX; // The current mouse position on the x axis
int mouseY; // The current mouse position on the y axis
int scrollbarPosition; // The current mouse scrollbar position
int oscrollbarPosition; // This is the old mouse scrollbar position
int oldMouseX; // The old mouse position on the x axis
int oldMouseY; // The old mouse position on the y axis
};

class player {
public:
float playersAngle; // The angle the player is facing
float playersXYZ[3]; // The location of the player
int PersonID; // Integer value for the person model
};

// Here we will turn the above classes into objects
player playerInfo;
inputClass inputObject;
mapClass mapVars;
texture textureObject[numberOfTextures];

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc

int loadMap(const char *filename) {
int i, j;
mapVars.mapX = 0, mapVars.mapY = 0;
char buffer[64];
FILE *inputfile = fopen(filename,"r");

i = -1;
do
{
buffer[++i] = fgetc(inputfile);

} while (buffer[i] != 'X');
buffer[i] = '\0';
sscanf(buffer, "%d", &amp;mapVars.mapX);

i = -1;
do
{
buffer[++i] = fgetc(inputfile);

} while (buffer[i] != '\n');
buffer[i] = '\0';
sscanf(buffer, "%d", &amp;mapVars.mapY);

mapVars.map = new int*[mapVars.mapX];
for (i=0; i<mapVars.mapX; i++)
{
mapVars.map[i] = new int[mapVars.mapY];
}

for(i=0; i<mapVars.mapX;i++) {
for(j=0; j<mapVars.mapY;j++) {
buffer[0] = fgetc(inputfile);
buffer[1] = '\0';
mapVars.map[i][j] = atoi(buffer);
}
fgetc(inputfile); // this will read in the new line character
}

fclose(inputfile);
return 1;
}

GLvoid drawBox( long float x, long float y, long float z ) {

glBindTexture(GL_TEXTURE_2D, textureObject[0].textureID);
glBegin( GL_QUADS );
glColor3f(1, 1, 1); // Incase the texturing failed make the boxes white
// The basic shape of the box

// Also will use the box texture loaded by LoadGLTextures()

// The bottom of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y,z+1);

// The top of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y+1,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z+1);

// The left side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y,z+1);

// The right side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x+1,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y+1,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x+1,y,z+1);

// The front side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z);

// The back side of the box
glTexCoord2f(0.0f, 0.0f); glVertex3f(x,y,z+1);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x+1,y,z+1 );
glTexCoord2f(1.0f, 1.0f); glVertex3f(x+1,y+1,z+1);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x,y+1,z+1);

glEnd();

}

GLint drawLandscape() {

glBindTexture(GL_TEXTURE_2D, textureObject[1].textureID);
glPushMatrix();
glBegin( GL_QUADS ); // The floor will just be a big textured rectangle
glColor3f(0.111,0.111,0.111); // Incase it doesn't texture the floor will be white!
glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,0,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,0,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,-0.2,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,-0.2,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,-100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,-100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,-100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(-100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(-100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(-100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100,-0.2,-100); // Upper left hand corner

glTexCoord2f(0.0f, 0.0f); glVertex3f(100,0,-100); // Lower left hand corner
glTexCoord2f(1.0f, 0.0f); glVertex3f(100,0,100); // Lower right hand corner
glTexCoord2f(1.0f, 1.0f); glVertex3f(100,-0.2,100); // Upper right hand corner
glTexCoord2f(0.0f, 1.0f); glVertex3f(100,-0.2,-100); // Upper left hand corner

glEnd();
glPopMatrix();


int i, j;

//if (loadMap("demomap.map")) {
for(i=0; i<mapVars.mapX; i++) {
for(j=0; j<mapVars.mapY; j++) {
if (mapVars.map[i][j]==1) {
drawBox(i*2, 0, j*2);
}
}
cout << endl;
}
// }

return true;
}

int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
int width, height; // Window dimensions
glfwGetWindowSize( &amp;width, &amp;height );
height = height < 1 ? 1 : height;
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}

glViewport(0,0,width,height);
// Setup all of the class values
playerInfo.playersAngle = startingAngle;
playerInfo.playersXYZ[0] = 0;
playerInfo.playersXYZ[1] = 0;
playerInfo.playersXYZ[2] = 0;

inputObject.oldMouseX = 0;
inputObject.oldMouseY = 0;
glfwDisable( GLFW_MOUSE_CURSOR );

loadMap("Maps//demomap.map");

// Here we will load our textures for the floor and the box
glGenTextures( 1, &amp;textureObject[1].textureID);
glBindTexture( GL_TEXTURE_2D, textureObject[1].textureID);
glfwLoadTexture2D( "Textures//floor.tga", GLFW_BUILD_MIPMAPS_BIT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glGenTextures( 1, &amp;textureObject[0].textureID);
glBindTexture( GL_TEXTURE_2D, textureObject[0].textureID );
glfwLoadTexture2D( "Textures//box.tga", GLFW_BUILD_MIPMAPS_BIT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glEnable( GL_TEXTURE_2D );

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping (important)
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
return 0; // Initialization Went OK
}

int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
{
inputObject.scrollbarPosition = glfwGetMouseWheel();
glfwGetMousePos(&amp;inputObject.mouseX, &amp;inputObject.mouseY);

if(inputObject.oldMouseX < inputObject.mouseX) { // compare the mouse variables accordingly
playerInfo.playersAngle+=1;}

if(inputObject.oldMouseX > inputObject.mouseX) {
playerInfo.playersAngle-=0.01; }
if(inputObject.scrollbarPosition > inputObject.oscrollbarPosition) {
glScalef(0.01, 0.01, 0.01); }
if(inputObject.scrollbarPosition < inputObject.oscrollbarPosition) {
glScalef(10, 10, 10); }

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer



glMatrixMode( GL_MODELVIEW ); // We need to be in the MODELVIEW matrix for gluLookAt()
glLoadIdentity();
// Follow the person
gluLookAt(
playerInfo.playersXYZ[0]+cos(playerInfo.playersAngle)*2, playerInfo.playersXYZ[1]+2, playerInfo.playersXYZ[2]+sin(playerInfo.playersAngle)*2,
playerInfo.playersXYZ[0], playerInfo.playersXYZ[1], playerInfo.playersXYZ[2],
0, 1, 0);
if(playerInfo.playersAngle<=0) {
playerInfo.playersAngle+=360;
}

drawLandscape();

glColor3f(1,0.2,0.2);

glPushMatrix();
glTranslatef(playerInfo.playersXYZ[0],playerInfo.playersXYZ[1]+0.4,playerInfo.playersXYZ[2]);

glRotatef(playerInfo.playersAngle,0,1,0);
glColor3f(0.5, 0.2, 0.25);
glCallList(playerInfo.PersonID);
glPopMatrix();
inputObject.oldMouseX = inputObject.mouseX;
inputObject.oldMouseY = inputObject.mouseY;
inputObject.oscrollbarPosition = inputObject.scrollbarPosition;
return TRUE; // Everything Went OK

}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
{
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}

glViewport(0,0,width,height); // Reset The Current Viewport

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,1,100);

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix

}

int main(int argc, char* argv[])
{
inputObject.mouseX = 0;
inputObject.mouseY = 0;
int major, minor, rev;
int running;

if( glfwInit() != GL_TRUE ) { // Initialize glfw
cout << "ERROR CODE 103: GLFW FAILED TO INITIALIZE!" << endl;
}

// Display the glfw version
glfwGetVersion(&amp;major, &amp;minor, &amp;rev);
cout << "GLFW version: " << major << "." << minor << "." << rev << endl;
if(major != 2) {
cout << "WARNING: POSSIBLE DIFFERENT API VERSION, INTENDED GLFW VERSION IS 2.1.0!" << endl;
exit(1);
}
if(minor < 1) {
cout << "WARNING: OLDER GLFW VERSION THAN INTENDED." << endl;
}

// Now we must produce the window for the program
// If it failed warn the user and attempt to continue
if( glfwOpenWindow( 1280, 1024, 8, 8, 8, 8, 24, 0,GLFW_FULLSCREEN ) != GL_TRUE) {
// Lets warn the user
cout << "ERROR CODE 201: THE WINDOW COULD NOT BE OPENED" << endl;
}

if ( InitGL() != 0 ) {
cout << "ERROR CODE: 32, InitGL failed to initialize." << endl;
}

do {

DrawGLScene();
glfwSwapBuffers();
running = !glfwGetKey( GLFW_KEY_ESC ) &amp;&amp;
glfwGetWindowParam( GLFW_OPENED );



}
while( running );
// Close the window we created
glfwCloseWindow();

glfwTerminate(); // Kill glfw
return 0;
}

marcus256
10-20-2002, 03:05 AM
Yes yes yes... I think I found it:

Your resize function is never registered! You need to:



glfwSetWindowSizeCallback( ReSizeGLScene );

in your InitGL code.

Also, the resize function should be declared as:



void GLFWCALL ReSizeGLScene(int width, int height)

Hope this helps http://www.opengl.org/discussion_boards/ubb/smile.gif

31337
10-20-2002, 02:54 PM
Hmm when I try and compile it it tells me

'ReSizeGLScene' : redefinition; different type modifiers

and

'ReSizeGLScene' : undeclared identifier

Please excuse my foolishness I have never used callbacks or at least don't know how they work. I added that glfwSetWindowSizeCallback( ReSizeGLScene ); line to the front of initGL and changed the void ReSizeGLScene to void GLFWCALL ReSizeGLScene(int width, int height)

zeckensack
10-20-2002, 10:24 PM
Originally posted by 31337:
Hmm when I try and compile it it tells me

'ReSizeGLScene' : redefinition; different type modifiers

and

'ReSizeGLScene' : undeclared identifier

Please excuse my foolishness I have never used callbacks or at least don't know how they work. I added that glfwSetWindowSizeCallback( ReSizeGLScene ); line to the front of initGL and changed the void ReSizeGLScene to void GLFWCALL ReSizeGLScene(int width, int height)Change the function in both places. Prototype and implementation.

Right now your compiler complains about you implementing a function that was declared differently. Nothing to do with callbacks in itself http://www.opengl.org/discussion_boards/ubb/smile.gif

So you go

//declaration somewhere at the top
void GLFWCALL ReSizeGLSCENE(int width,int height);

<...>

//actual implementation
void GLFWCALL
ReSizeGLScene(int width,int height)
{
//do something
}

marcus256
10-21-2002, 02:51 AM
...or you can just move your resize function to above your init function. If you want it below (as it is now), you have to do a proto above the init function (as zak said).

31337
10-21-2002, 06:47 AM
Wahoo it works now! I can't wait to work on it some more when I get home today. Thanks for your help guys, especially you marcus your awsome.