CS0045 Module 5 (Sample Code 2)

0.0(0)
Studied by 0 people
call kaiCall Kai
learnLearn
examPractice Test
spaced repetitionSpaced Repetition
heart puzzleMatch
flashcardsFlashcards
GameKnowt Play
Card Sorting

1/27

flashcard set

Earn XP

Description and Tags

Convert the previous OpenGL program (Sample Code 1) to use Vertex Buffer Objects

28 Terms

1
New cards
#include __ //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


<GL/glew.h>


2
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    __(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glutInit


3
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    __(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glutInitWindowSize


4
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    __(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glutInitWindowPosition


5
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    __("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glutCreateWindow


6
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    ___(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glutDisplayFunc


7
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    __ = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


GLenum err


8
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = ___ // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glewInit();


9
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (___) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


err == GLEW_OK


10
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        ___
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glutMainLoop();


11
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

___ {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


void triangle()


12
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
__ trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


GLfloat


13
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat ___ {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


trianglevertices[] =


14
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
___
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


GLuint VBOid;


15
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
__(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glGenBuffers


16
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
__(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glBindBuffer


17
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
__(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glBufferData


18
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
__(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glEnableClientState


19
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
__(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glVertexPointer


20
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
__(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glDrawArrays


21
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
__(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glDisableClientState


22
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
__(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glBindBuffer


23
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
__(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glDeleteBuffers


24
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void ___ {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


display()


25
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    __(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glClear


26
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    __(.16f,.72f,.08f,1.0f);
    triangle();
    glFlush();
}


glColor4f


27
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    ___
    glFlush();
}


triangle();


28
New cards
#include <GL/glew.h> //New GLEW header file
#include <GL/glut.h>
#include <iostream>

using namespace std;

void display();
void triangle();
void init();

int main(int argc, char** argv){

    glutInit(&argc, argv);

    glutInitWindowSize(800,600);
    glutInitWindowPosition(100,100);
    glutCreateWindow("simple");

    glutDisplayFunc(display);

    GLenum err = glewInit(); // <------- Include glew initialization calls before the main loop
    if (err == GLEW_OK) {
        glutMainLoop();
    }

}

void triangle() {
//1. Initialize the triangle using an array
GLfloat trianglevertices[] = {
    0.0f, .75f, 0.0f,
    -0.75f, 0.0f, 0.0f,
    0.75f, 0.0f, 0.0f
};

//2. Generate a Vertex Buffer Object ID for your array of vertices and bind it
GLuint VBOid;
glGenBuffers(1, &VBOid);
glBindBuffer(GL_ARRAY_BUFFER, VBOid);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*9, trianglevertices, GL_STATIC_DRAW);

//3. Activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);

//4. Draw the primitive object
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);

//5. Disable client side capability for normal operation
glDisableClientState(GL_VERTEX_ARRAY);

// bind with 0, so, switch back to normal pointer operation
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &VBOid);

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(.16f,.72f,.08f,1.0f);
    triangle();
    ___
}


glFlush();