Drawing a cube with GlDrawElements()?

Is there a way to draw a cube like this and as a result, only upload 8 verticies and 24 indicies to the graphics card? If so how could this be done?

Thanks

I currently do it like this:

boxdims.x = w;
    boxdims.y = h;
    boxdims.z = d;
    center = c;

    GLfloat vboverticies[72];
    GLfloat vbonormals[18];
    Vertex3f verticies[24];

    //Top face
    verticies[0] = Vertex3f(-boxdims.x / 2.0f,boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[1] = Vertex3f(-boxdims.x / 2.0f,boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[2] = Vertex3f(boxdims.x / 2.0f,boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[3] = Vertex3f(boxdims.x / 2.0f,boxdims.y / 2.0f, -boxdims.z / 2.0f);


    //Bottom face
    verticies[4] = Vertex3f(-boxdims.x / 2.0f,-boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[5] = Vertex3f(boxdims.x / 2.0f,-boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[6] = Vertex3f(boxdims.x / 2.0f,-boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[7] = Vertex3f(-boxdims.x / 2.0f,-boxdims.y / 2.0f, boxdims.z / 2.0f);


    //Left face
    verticies[8] = Vertex3f(-boxdims.x / 2.0f,-boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[9] = Vertex3f(-boxdims.x / 2.0f,-boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[10] =Vertex3f(-boxdims.x / 2.0f,boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[11] =Vertex3f(-boxdims.x / 2.0f,boxdims.y / 2.0f, -boxdims.z / 2.0f);


    //Right face
    verticies[12] =Vertex3f(boxdims.x / 2.0f,-boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[13] =Vertex3f(boxdims.x / 2.0f,boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[14] =Vertex3f(boxdims.x / 2.0f,boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[15] =Vertex3f(boxdims.x / 2.0f,-boxdims.y / 2.0f, boxdims.z / 2.0f);

    //Front face
    verticies[16] =Vertex3f(-boxdims.x / 2.0f,-boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[17] =Vertex3f(boxdims.x / 2.0f,-boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[18] =Vertex3f(boxdims.x / 2.0f,boxdims.y / 2.0f, boxdims.z / 2.0f);
    verticies[19] =Vertex3f(-boxdims.x / 2.0f,boxdims.y / 2.0f, boxdims.z / 2.0f);

    //Back face
    verticies[20] =Vertex3f(-boxdims.x / 2.0f,-boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[21] =Vertex3f(-boxdims.x / 2.0f,boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[22] =Vertex3f(boxdims.x / 2.0f,boxdims.y / 2.0f, -boxdims.z / 2.0f);
    verticies[23] =Vertex3f(boxdims.x / 2.0f,-boxdims.y / 2.0f, -boxdims.z / 2.0f);




    for(int i = 0; i < 24; i++)
    {
        verticies[i].x += center.x;
        verticies[i].y += center.y;
        verticies[i].z += center.z;
    }


    int count = 0;
    for(int i = 0; i < 24; ++i)
    {
        vboverticies[count] = verticies[i].x;
        count++;
        vboverticies[count] = verticies[i].y;
        count++;
        vboverticies[count] = verticies[i].z;
        count++;
    }

    //glNormal3f(0.0, 1.0f, 0.0f);
    //glNormal3f(0.0, -1.0f, 0.0f);
    //glNormal3f(-1.0, 0.0f, 0.0f);
    //glNormal3f(1.0, 0.0f, 0.0f);
    //glNormal3f(0.0, 0.0f, 1.0f);
    //glNormal3f(0.0, 0.0f, -1.0f);
    vbonormals[0] = (0.0);
    vbonormals[1] = (1.0);
    vbonormals[2] = (0.0);

    vbonormals[3] = (0.0);
    vbonormals[4] = (-1.0);
    vbonormals[5] = (0.0);

    vbonormals[6] = (-1.0);
    vbonormals[7] = (0.0);
    vbonormals[8] = (0.0);

    vbonormals[9] = (1.0);
    vbonormals[10]= (0.0);
    vbonormals[11]= (0.0);

    vbonormals[12]= (0.0);
    vbonormals[13]= (0.0);
    vbonormals[14]= (1.0);

    vbonormals[15]= (0.0);
    vbonormals[16]= (0.0);
    vbonormals[17]= (-1.0);



    //Create the VBO
    glDeleteBuffers(1, &vboID);
    glGenBuffersARB(1, &vboID);
    glBindBufferARB(GL_ARRAY_BUFFER, vboID);
    glBufferDataARB(GL_ARRAY_BUFFER, (72 * sizeof(GLfloat)) + 
        (18 * sizeof(GLfloat)) , NULL, GL_STATIC_COPY);

    glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, 72 * sizeof(GLfloat), vbovertici开发者_如何学Goes);
    glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 72 * sizeof(GLfloat),
        18 * sizeof(GLfloat), vbonormals);


}

The answer is no.

If you need normals, you'll have to have 24 vertices, as no face shares normals. Note that the example provided by shk does not handle normals.

Maybe it'll be helpfull - http://www.songho.ca/opengl/gl_vertexarray.html

You can, but you'll have to use geometry shaders for that, and you should not mess with this stuff until you really know what you're doing. What's more, for just a cube, it's really not a big deal.