i know that the available methods when compiling a display are limited. i was just wondering if anyone knew what methods these are? this may be the reason im getting some odd functionality in my program.

It would probably be easier if you showed us the display list generation code and described what's going wrong...

its not that im asking for help with my code. im sure its just a simple typo or something, because it was working fine before. i would just like to know for future reference.

The OpenGL Red book lists the commands that aren't stored in display lists (note that this is just for OpenGL 1.1; commands added by extensions or in later versions may also not be compiled):

glColorPointer()
glFlush()
glNormalPointer()
glDeleteLists()
glGenLists()
glPixelStore()
glDisableClientState()
glGet*()
glReadPixels()
glEdgeFlagPointer()
glIndexPointer()
glRenderMode()
glEnableClientState()
glInterleavedArrays()
glSelectBuffer()
glFeedbackBuffer()
glIsEnabled()
glTexCoordPointer()
glFinish()
glIsList()
glVertexPointer()

Basically, anything that relies on a buffer you provide or that returns OpenGL state.

im using glEnableClientState() and glDisableClientState() within the displayList compile of my model loading object...everything seems to work fine...what exactly does glEnableClientState() do?

It's perfectly legal (and sometimes necessary) to use them inside display list compilation. They just won't be compiled with the rest of the list.

glEnableClientState enables a piece of client state (duh?), usually a vertex array. Client state is state that always resides on the "machine" making the OpenGL calls, not on the "machine" rendering them. It's usually the case that you can think of the CPU as the first machine and the graphics card as the second, though it is possible to render across an actual network using OpenGL on X11.

rendering across a network? what does that supposed to mean? ive heard of that in raytracing apps but what does it have to do with OpenGL?

Rendering across the network as in your program one one machine calls gl**** and the machine on the other side of the room/town/county/country/planet draws the pictures.

The point is that OpenGL is designed to allow that, so the things that can and can't be compiled into a display list have to take that into account. Things that rely on a pointer you provide to OpenGL obviously won't work across a network.

As I understand it, you *can* use the array pointers in a display list, but their contents at the moment of compilation will be stored in the list and they will *not* be updated if the pointer is changed before the list is executed.

Precisely. It's not that the gl*Pointer calls are illegal to call from inside the display list, it's that they're not compiled into the display list. The geometry from the drawElements or drawArrays calls is compiled into the list.