GLUT code in C++ with classes

Question

The following is code to draw a rectangle, but I am getting an error in glutdisplayFunc(). How can I fix it?

#include <iostream>
#include <glut.h>

using namespace std;

class GUI
{
  public:
    int W,H;
    GUI()
    {
        W = 800;
        H = 600;
        glClearColor(0, 0, 0, 0);
        gluOrtho2D(-W, W, -H, H);
        glMatrixMode(GL_PROJECTION);
    }
    void display()
    {
        glBegin(GL_POLYGON);
        glVertex2d(-500, 300);
        glVertex2d(500, 300);
        glVertex2d(500, -300);
        glVertex2d(-500, -300);
        glEnd();
        glFlush();
    }
};

int main(int argv, char **argc)
{
    GUI ob;

    glutInit(&argv, argc);
    glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
    glutInitWindowSize(ob.W, ob.H);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Queen Problem");
    glutDisplayFunc(ob.display);      //Error
    glutMainLoop();
    return 0;
}

I am using Visual Studio 2010. I created some of the programs in OpenGL, but without any clases. This is my first experience of using classes with OpenGL.

The error is:

Error 1 error C3867: 'GUI::display': function call missing argument list; use '&GUI::display' to create a pointer to member.

I tried to use &GUI::display, but it also resulted in the error.

Answer 1

C++ has no notion of a concept called "closures". A closure is a tuple consisting of a function, and a scope in which the function is executed with. Class member functions require a class instance to work with. You can't take a function pointer of an instance's member function, due to the lack of this concept in C++.

Furthermore GLUT is a C API, which means, that even if C++ did support closures, GLUT wouldn't know how to work with this.

So what you must so is use a non-member function use that to call a class member function on an instance. Most C APIs allow you to provide a callback parameter (usually in the form of a void*). GLUT however doesn't do this, so effectively you can only call on a global instance of the class.

update

There are further problems with your code. You instanciate GUI before there is a OpenGL context. The OpenGL context gets created by glutCreateWindow. But the `GUI' constructor makes OpenGL calls, which are invalid without a constructor available.

And to make matters worse: All those calls in the constructor actually belong in the drawing code.

Answer 2

C++ and C do not share the same linkage and ABI. Additionally, for classes, there is what is called the 'implicit' parameter known as the 'this' pointer, the argument is hidden and resolved for you. Internally, this will change the function signature from what you expect and the compiler takes care of the details making sure this works. The C function call expects a reference to a function with the expected signature. It also has no way to interop this directly and you'll have to bridge this in some fashion.

Answer 3

• The reason why you are getting the error message is because you either defined the function display() as a member function of GUI class or you did not defined the display() function as a member of GUI class and you are trying to call it from the GUI class.
• To fix the problem, you need to define display() function as a non-member function of GUI with no input parameters. If it`s a non-member function you cannot do this ob.display. glutDisplayFunc does not take a member function.
• To refer to the non-member function display() on GUI class, you need to call it this way;
• glutDisplayFunc(&display);

Answer 4

Solution

1. Make display static.
2. Or get rid of the GUI class. If you have only one window, you don't really need it.
3. Make single global instance of GUI class, and call its display() method from the glut display callback.
4. Or use different library to initialize OpenGL.
5. Or find a way to pass the "this" pointer through glut.

Explanation

In C++ class methods have hidden this parameter, unless it is static. You can't call non-static class member without having this pointer.

GLUT expects a function without the this parameter.

If you do not know what the this" pointer is, you need to get a C++ book and study more.

Either make "display" static (in which case you won't be able to access class members from within the method), or find some way to pass "this" pointer to be used within.

Passing the this pointer through glut and forwarding the call to a class would look like this:

class Gui{
public:
    void display();
};

void* getWindowData(int id);
void setWindowData(int id, void* p);

void displayForwarded(){
    Gui *gui = (Gui*)getWindowData();      
    if (gui)
        gui->display();
}

int main(int argc, char** argv){
    ....
    int windowId = glutCreateWindow();       
    Gui gui;
    setWindowData(windowId, &gui);
    glutDisplayFunc(displayForwarder);
}

The problem is content of getWindowData() and setWindowData(). If you were using OpenGLUT, you could've used glutSetWindowData function in them.

In FreeGLUT you could either abuse the window title to pass a pointer through it (bad idea, don't do that), but that's a bad taste.

So what's left is to create a global map that'll convert window ids to user data pointers and user data through that.

typedef int WindowId;
typedef std::map<WindowId, Gui*> GuiMap;

namespace Internal{
     GuiMap guiMap;
}
class Gui{
public:
    ...
    void display();
}

void setWindowGui(WindowId id, Gui* p){
     Inertnal::guiMap[id] = p; // guiMap.insert(std::make_pair(id, p))
}

Gui* getWindowGui(WindowId id){
     GuiMap::iterator found = Internal.guiMap.find(id);
     if (found == Internal.guiMap.end())
         return 0;
     return found.second;
}

void displayForwarder(){
     WindowId = getGetWindow();//glut function
     Gui *gui = getWindowGui(id);
     if (!gui)
         throw std::string("gui not found");
     gui->display();
}

int main(int argc, char** argv){
    ...
    Gui gui;
    WindowId window = glutCreateWindow(.....);...
    setWindowGuiwindow, &gui);
    glutDisplayFunc(displayForwarder);
    ...
    ...
}

If you don't understand the answer, get a C++ book and read it.