OpenGL mit c++ - Klassen

Ich versucht habe, etwas zu schreiben, die lassen mich einfach zu verwalten OpenGL mit Klassen.

Nahm ich einen Ansatz, der mit einem Drawable-Klasse [die Formen/etc würde vererben und überschreiben, eine zeichnen-Funktion], und dann mit einer Controller-Klasse zum Durchlaufen einer Tabelle der Drawable-Klassen und zeichnen Sie alle.
Das einzige Problem, das ich habe bemerkt, dass die draw () - Methode aufgerufen wird, von der Drawable-Klasse, anstelle der Rechteck-Klasse. ??

    class Drawable {
        public:
            void draw();
    };
    class Rectangle : public Drawable {
        public:
            void draw();
    };
    class Controller {
        public:
            Drawable ents[200];
            int ent_count;
            void frame();
            void append(Drawable item); //this will add an object onto the list
            Controller();
    };
    void Drawable::draw() {
        //this is the default drawing function, which should be overridden
    }
    void Rectangle::draw() {
        //gl functions here
    }
    void Controller::frame() {
        for(int i=0;i<ent_count,i++) {
            ents[i].draw(); //draw all entities on the list
        }
        //here, a timer would loop back the frame() function
    }
    void Controller::append(Drawable item) {
         ents[ent_count++]=item;
    }
    int main(void) {
         Controller main_controller; //create a controller
         Rectangle rect; //create a rectangle
         main_controller.append(rect); //insert rectangle into controller list
         main_controller.frame(); //start the frame loop
    }

[wenn es um kleine Tippfehler in, dass es ist, weil es geschrieben wurde, als eine Zusammenfassung der Methode.]
Diese Methode, die ich versucht habe zu verwenden, ist nicht sehr erfolgreich gewesen, und ich bin mir ziemlich sicher, dass es hat zu tun mit der Vererbung.
Irgendwelche Ideen?
Gesamten source-code:

#include <iostream>
#include <GL/glfw.h>
#include <GL/gl.h>
class Drawable {
      public:
             int x,y;
             void draw();
             void frame();
             void create();
             void destroy(); 
};
void Drawable::create() {

}
void Drawable::draw() {
}
class Rectangle : public Drawable {
      public:
      int w,h;
      unsigned short r,g,b;
      Rectangle(int x,int y, int w, int h, unsigned short r, unsigned short g, unsigned short b);
      void draw();
};
void Rectangle::draw() {
     glColor3ub(r,g,b);
     glBegin(GL_QUADS);
     glVertex2i(x,y);
     glVertex2i(x+w,y);
     glVertex2i(x+w,y+h);
     glVertex2i(x,y+h);
     glEnd();
}
Rectangle::Rectangle(int x,int y, int w, int h, unsigned short r, unsigned short g, unsigned short b) {
                         this->x=x;
                         this->y=y;
                         this->w=w;
                         this->r=r;
                         this->g=g;
                         this->b=b;
}
class Controller {
public:
       Controller(int w,int h,int fsaa,bool fs,bool vsync,const char* title);
       bool running;
       int frame_limit;
       Drawable entity[200];
       int entity_count;
       void fev();
       void begin();
       void bind();
       void append(Drawable item);
      };
Controller::Controller(int w,int h,int fsaa,bool fs,bool vsync,const char* title) {
                          int fullscreen= (fs ? GLFW_FULLSCREEN : GLFW_WINDOW);
                          bool window=glfwOpenWindow(w,h,0,0,0,0,10,10,fullscreen);
                          glfwSetWindowTitle(title);
                          frame_limit=120;
                          entity_count=0;
                          std::cout << (window ? "Successfully initialized a window.\n" : "Error initializing window!\n");
       }
void Controller::begin() {
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glOrtho(0,640,480,0,0,5);
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
     glClearColor(0.4f,0.4f,0.4f,1.0f);
     running=true;
     fev();
}
void Controller::append(Drawable item) {
     entity[entity_count++]=item;
}
void Controller::fev() {
     glClear(GL_COLOR_BUFFER_BIT);
     for (int i=0;i<entity_count;++i) {
          entity[i].draw();
          }
     glfwSwapBuffers();
     if (frame_limit>0) {
        glfwSleep(1000/frame_limit*0.001);
     }
     if (running) {
        if (glfwGetKey(GLFW_KEY_ESC) || !glfwGetWindowParam(GLFW_OPENED)) {
           running=false;
        }
        fev();
     } else {
       std::cout << "terminated!";
}
}
int main(void) {
    glfwInit();
    Controller main(640,480,0,false,false,"WindTitle");
    Rectangle rect(50,50,50,50,50,50,50);
    main.append(rect);
    main.begin();
}