Welcome to the MacNN Forums.

JeroMiya · Jul 23, 2001, 07:29 PM

I'm trying to write a VERY simple game engine for a game I'm writing in OpenGL on OSX. However, I DO NOT want to use global variables in this engine. I hate global variables. However, I see absolutely no way around using them in an OpenGL program. Why you ask? Because you have to assign functions for OpenGL to call at certain points, like when the screen needs to be redrawn, or when you press a key. I want to share data between these functions, but I don't want the data to be global. For example, in this game I'm using an object list (each object has all the information about where it is on the screen, how to draw it, and how to move it). I could just make this list static data in the draw function, but I would rather share the list with the idle function. That way, I can do frame rate timing in the idle function (moving the objects, but not drawing them until a certain amount of time has gone by so that the objects move at the same speed at different framerates). How are you supposed to do this? I tried assigning the member functions of a class, so that I can have the list as private data of the class, but I get an error saying "void was not ignored as it should be". This is a short snipit of what I'm trying to do. <BLOCKQUOTE>code:<HR><pre>
...
GLvoid InitGL(GLvoid);
GLvoid Idle(GLvoid);
class MyGLControlClass
{
public:
...
GLvoid draw(GLvoid);
GLvoid init(GLvoid);
...
private:
int a;
};
int main(int argc, char** argv)
{
MyGLControlClass con;

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutGameModeString("1024x768:32@75");
glutEnterGameMode();

con.init();
InitGL();
glutDisplayFunc(con.draw()); // NOTE: THIS IS CAUSING THE ERROR <-------------------------------
glutIdleFunc(Idle);//Idle Function is dont every loop
glutMainLoop();

return 0;
}

GLvoid InitGL(GLvoid)
{

glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // This Will Clear The Background Color To Black
// Colours follow standar Red, Green, Blue, then alpha channel
glClearDepth(1.0); // Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS); // The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glShadeModel(GL_SMOOTH); // Enables Smooth Color Shading

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

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

glMatrixMode(GL_MODELVIEW);

}

// Idle ---------------------------------------------------------------------

GLvoid Idle(GLvoid)
{
glutPostRedisplay();//Makes glut re-render the scene
}

GLvoid MyGLControlClass::init(GLvoid)
{
a = 10;
}

GLvoid MyGLControlClass::draw(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity(); // Reset The View
//Lesson 2
a++;
if (a > 14)
a = 0;
glTranslatef(-1.5f,0.0f,-6.0f); // Move Left 1.5 Units And Into The Screen 6.0

//Setup the rotation for the triangle
glRotatef(a,0.0f,1.0f,0.0f); // Rotate The Triangle On The Y axis
glRotatef(a,1.0f,0.0f,0.0f);
//Make a Triangle
glBegin(GL_TRIANGLES); // Drawing Using Triangles
//Front Face
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Front)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f(-1.0f,-1.0f, 1.0f); // Left Of Triangle (Front)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f( 1.0f,-1.0f, 1.0f); // Right Of Triangle (Front)
//Right Face
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Right)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f( 1.0f,-1.0f, 1.0f); // Left Of Triangle (Right)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f( 1.0f,-1.0f, -1.0f); // Right Of Triangle (Right)
//Left Face
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Back)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f( 1.0f,-1.0f, -1.0f); // Left Of Triangle (Back)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f(-1.0f,-1.0f, -1.0f); // Right Of Triangle (Back)
//Back Face
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Left)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f(-1.0f,-1.0f,-1.0f); // Left Of Triangle (Left)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f(-1.0f,-1.0f, 1.0f); // Right Of Triangle (Left)
glEnd(); // Finished Drawing The Triangles
glBegin(GL_QUADS);
glVertex3f(-1.0f,-0.5f, 1.0f);
glVertex3f(1.0f,-0.5f, 1.0f);
glVertex3f(1.0f,-0.5f, -1.0f);
glVertex3f(-1.0f,-0.5f, -1.0f);
glEnd();

glutSwapBuffers();

}
[/code]

aleph_null · Jul 24, 2001, 01:48 PM

Yeah, OpenGL sorta tugs you into using globals...

If you genuinely have need for only a single instance of a class through the entire scope of the program, making it global isn't such a bad thing, IMHO.

If you want to legitimize it somewhat, and you don't need to subclass or make multiple instances of your control class, you can either make the required methods and members static, or use a namespace instead of a class. Namespaces can be nested.

Too bad glutDisplayFunc and IdleFunc don't let you pass some user data to the callback. Then you could set up a static callback which gets a pointer to the instance of the class, giving you access to its innards....

I believe when I was working on a game engine a while back I had a few global objects/threads which interacted... a "world" object, which kept track of the objects in the world; a renderer object, which would walk the world's object tree periodically and ask eack object to render itself; a number of camera objects, which set up the modelview matrix prior to rendering (and the renderer could switch among the cameras); a physics thread, which did collision detection and updated objects' positions ....

But then I started with Apple's setupGL sample code, so I wasn't using GLUT. It's a little more flexible.

Eek, sorry for rambling... remembering the "good 'ol days"

Look into namespaces.

swcrissman · Jul 25, 2001, 07:33 AM

The problem isnt that using OpenGL forces you to use globals, but rather glut does. If you want to do serious work using openGl, and want your code to be cleaner (no globals, not relying on callbacks) you need to look at implementing openGL natively.

If you are careful, you can implement the program natively, and still maximize portability. Last summer, my friend and I put together a game using openGL. I was using the mac, and he using his pc. Good abstraction at the various levels ensure that most of the code can still be shared, even without glut.

Hope that helps.

Spencer