opengl – Switched from fast mode to VBOs, recreation runs slower

I am attempting to enhance the draw efficiency on my c++, OpenGL, SDL recreation.

Again at school we largely discovered fast mode, in order that’s how my drawing was initially carried out. After I began studying up on-line about enhancing efficiency, I examine VBOs and the way they’re ‘so significantly better’ and use the graphics card reminiscence, and many others.

So I took a few nights and transformed to them. After I examined the sport, it truly ran slower (draw technique went from ~7 to ~10 ticks).

Did I do one thing improper or are VBOs solely extra environment friendly in sure conditions?

This is my class for tessellated polygons after including VBOs (my recreation attracts a variety of flat 2D shapes in a 3D world, kind of papermario-style)

#embody "Tesselator.h"

Tesselator::Tesselator(std::vector<b2Vec2> vertices, Gradient* gradient) {
    this->vertices = vertices;
    this->gradient = gradient;
    tesselator = gluNewTess();
    gluTessCallback(tesselator, GLU_TESS_BEGIN_DATA, (void(CALLBACK*)())beginCallback);
    gluTessCallback(tesselator, GLU_TESS_VERTEX_DATA, (void(CALLBACK*)())vertexCallback);
    gluTessCallback(tesselator, GLU_TESS_END, (void(CALLBACK*)())endCallback);
    int vertcount = (int)vertices.dimension();
    GLdouble vertarray[vertcount][3];
    for (int i = 0; i < vertices.dimension(); i++) {
        vertarray[i][0] = vertices[i].x;
        vertarray[i][1] = vertices[i].y;
        vertarray[i][2] = 0;
    }
    gluTessBeginPolygon(tesselator, this);
    gluTessBeginContour(tesselator);
    for (int i = 0; i < vertices.dimension(); i++) {
        gluTessVertex(tesselator, vertarray[i], vertarray[i]);
    }
    gluTessEndContour(tesselator);
    gluTessEndPolygon(tesselator);
    gluDeleteTess(tesselator);
    for (int i = 0; i < triangles.dimension(); i++) {
        triangleVBOs.push_back(new VertexBufferObject(triangles[i]));
    }
    for (int i = 0; i < trianglefans.dimension(); i++) {
        triangleFanVBOs.push_back(new VertexBufferObject(trianglefans[i]));
    }
    for (int i = 0; i < trianglestrips.dimension(); i++) {
        triangleStripVBOs.push_back(new VertexBufferObject(trianglestrips[i]));
    }
}
Tesselator::~Tesselator() {
    for (int i = 0; i < triangleVBOs.dimension(); i++) {
        delete triangleVBOs[i];
    }
    for (int i = 0; i < triangleFanVBOs.dimension(); i++) {
        delete triangleFanVBOs[i];
    }
    for (int i = 0; i < triangleStripVBOs.dimension(); i++) {
        delete triangleStripVBOs[i];
    }
    triangleVBOs.clear();
    triangleFanVBOs.clear();
    triangleStripVBOs.clear();
}
void Tesselator::draw(float z) {
    Drawing::applyZTranslation(z);
    for (int i = 0; i < triangleVBOs.dimension(); i++) {
        triangleVBOs[i]->draw(GL_TRIANGLES);
    }
    for (int i = 0; i < triangleFanVBOs.dimension(); i++) {
        triangleFanVBOs[i]->draw(GL_TRIANGLE_FAN);
    }
    for (int i = 0; i < triangleStripVBOs.dimension(); i++) {
        triangleStripVBOs[i]->draw(GL_TRIANGLE_STRIP);
    }
    Drawing::applyZTranslation(-z);
}
void Tesselator::addTriangle() {
    std::vector<b2Vec2> triangleVertices;
    triangles.push_back(triangleVertices);
}
void Tesselator::addTriangleFan() {
    std::vector<b2Vec2> triangleFanVertices;
    trianglefans.push_back(triangleFanVertices);
}
void Tesselator::addTriangleStrip() {
    std::vector<b2Vec2> triangleStripVertices;
    trianglestrips.push_back(triangleStripVertices);
}
void Tesselator::addVertex(b2Vec2 vertex) {
    if (currentType == GL_TRIANGLES) {
        triangles.again().push_back(b2Vec2(vertex.x, vertex.y));
    }
    else if (currentType == GL_TRIANGLE_FAN) {
        trianglefans.again().push_back(b2Vec2(vertex.x, vertex.y));
    }
    else if (currentType == GL_TRIANGLE_STRIP) {
        trianglestrips.again().push_back(b2Vec2(vertex.x, vertex.y));
    }
}
void CALLBACK Tesselator::beginCallback(GLenum sort, GLvoid * tessdata) {
    Tesselator* tess = (Tesselator*) tessdata;
    tess->currentType = sort;
    if (sort == GL_TRIANGLES) {
        tess->addTriangle();
    }
    else if (sort == GL_TRIANGLE_FAN) {
        tess->addTriangleFan();
    }
    else if (sort == GL_TRIANGLE_STRIP) {
        tess->addTriangleStrip();
    }
}
void CALLBACK Tesselator::vertexCallback(GLdouble* vertex, GLvoid* tessdata) {
    Tesselator* tess = (Tesselator*) tessdata;
    tess->addVertex(b2Vec2(*(vertex), *(vertex + 1)));
}
void CALLBACK Tesselator::endCallback() {
}

and right here is my vertex buffer object class

#embody "VertexBufferObject.h"

VertexBufferObject::VertexBufferObject(std::vector<b2Vec2> shapeVertices) {
    numberOfCoordinateValues = 0;
    for (int i = 0; i < shapeVertices.dimension(); i++) {
        numberOfCoordinateValues = numberOfCoordinateValues + 2;
    }
    float coordinateValues[numberOfCoordinateValues];
    int coordinateValueArrayIndex = 0;
    for (int i = 0; i < shapeVertices.dimension(); i++) {
        coordinateValues[coordinateValueArrayIndex] = shapeVertices[i].x;
        coordinateValueArrayIndex++;
        coordinateValues[coordinateValueArrayIndex] = shapeVertices[i].y;
        coordinateValueArrayIndex++;
    }
    glGenBuffers(1, &id);
    glBindBuffer(GL_ARRAY_BUFFER, id);
    glBufferData(GL_ARRAY_BUFFER, sizeof(coordinateValues),     coordinateValues, GL_STATIC_DRAW);
}
VertexBufferObject::~VertexBufferObject() {
    glDeleteBuffers(1, &id);
}
void VertexBufferObject::draw(GLenum mode) {
    glBindBuffer(GL_ARRAY_BUFFER, id);
    glVertexPointer(2, GL_FLOAT, 0, NULL);
    glEnableClientState(GL_VERTEX_ARRAY);
    glDrawArrays(mode, 0, numberOfCoordinateValues/2);
    glDisableClientState(GL_VERTEX_ARRAY);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

and heres what the draw technique for Tesselator used to appear to be earlier than including VBOs

void Tesselator::draw(float z) {
    for (int i = 0; i < triangles.dimension(); i++) {
        Drawing::drawTriangles(triangles[i], z, gradient);
    }
    for (int i = 0; i < trianglefans.dimension(); i++) {
        Drawing::drawTriangleFan(trianglefans[i], z, gradient);
    }
    for (int i = 0; i < trianglestrips.dimension(); i++) {
        Drawing::drawTriangleStrip(trianglestrips[i], z, gradient);
    }
}

and in Drawing.cpp:

void Drawing::drawTriangles(std::vector<b2Vec2> vertices, float z, Gradient* gradient) {
    glBegin(GL_TRIANGLES);
    for (int i = 0; i < vertices.dimension(); i++) {
        addVertex(vertices[i].x, vertices[i].y, z, gradient);
    }
    glEnd();
}
void Drawing::drawTriangleFan(std::vector<b2Vec2> vertices, float z, Gradient* gradient) {
    glBegin(GL_TRIANGLE_FAN);
    for (int i = 0; i < vertices.dimension(); i++) {
        addVertex(vertices[i].x, vertices[i].y, z, gradient);
    }
    glEnd();
}
void Drawing::drawTriangleStrip(std::vector<b2Vec2> vertices, float z, Gradient* gradient) {
    glBegin(GL_TRIANGLE_STRIP);
    for (int i = 0; i < vertices.dimension(); i++) {
        addVertex(vertices[i].x, vertices[i].y, z, gradient);
    }
    glEnd();
}