/**
 * Index buffer helper class
 */
public class IndexBuffer
{

    private static final Logger LOGGER = Logger.getLogger(IndexBuffer.class);

    protected int bufferId = -1;
    protected int stride = -1;
    protected long sizeInBytes;
    private int elementCount = -1;
    protected boolean ready = false;

    private IntBuffer buffer = null;


    /**
     * Creates and allocates a vertex buffer with the requested size in bytes.
     * @param sizeInBytes the size in bytes
     */
    public void createBuffer(long sizeInBytes)
    {
        if (bufferId != -1)
        {
            LOGGER.error("Buffer already created");
            return;
        }

        bufferId = allocateGLBuffer();

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferId);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeInBytes, GL_STATIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

        this.sizeInBytes = sizeInBytes;

        GLErrorChecker.checkError();

        LOGGER.info("Created index buffer with size in bytes: " + sizeInBytes);

    }

    /**
     * Uploads index data into a previously created buffer.
     * @param data the data to upload
     */
    public void uploadIndexData(List<Integer> data)
    {
        if (bufferId == -1)
        {
            LOGGER.error("Buffer not yet created");
            return;
        }

        stride = 3;
        elementCount = data.size();
        long requiredBytes = elementCount * 4;

        if (getSizeInBytes() != requiredBytes)
        {
            LOGGER.error("Invalid buffer size, required: " + requiredBytes + " allocated: " + getSizeInBytes());
            return;
        }

        buffer = BufferUtils.createIntBuffer(elementCount);

        int index = 0;

        for (Integer i : data)
        {
            buffer.put(index, i);
            index++;
        }

        buffer.rewind();
        buffer.flip();

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferId);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

        GLErrorChecker.checkError();

        LOGGER.info("Successfully uploaded index data");

        ready = true;
    }

    /**
     * Allocates a GL Buffer
     * @return the GL buffer id that was allocated
     */
    protected int allocateGLBuffer()
    {
        IntBuffer buffer = BufferUtils.createIntBuffer(1);
        glGenBuffers(buffer);

        int result = buffer.get(0);
        LOGGER.info("Created index buffer: " + result);
        return result;
    }


    public long getSizeInBytes()
    {
        return sizeInBytes;
    }

    public boolean isReady()
    {
        return ready;
    }

    public int getElementCount()
    {
        return elementCount;
    }

    public int getBufferId()
    {
        return bufferId;
    }


    public void destroy()
    {
        if (getBufferId() != -1)
        {
            glDeleteBuffers(getBufferId());
            LOGGER.debug("Destroyed GL index buffer: " + getBufferId());
        }

        bufferId = -1;
        ready = false;
    }

    public IntBuffer getBuffer()
    {
        return buffer;
    }

}



/**
 * Vertex buffer helper code
 */
public class VertexBuffer
{

    private static final Logger LOGGER = Logger.getLogger(VertexBuffer.class);

    protected int bufferId = -1;
    protected int stride = -1;
    protected long sizeInBytes;
    private int elementCount = -1;
    protected boolean ready = false;
    protected FloatBuffer buffer = null;

    /**
     * Creates and allocates a vertex buffer with the requested size in bytes.
     * @param sizeInBytes the size in bytes
     */
    public void createBuffer(long sizeInBytes)
    {
        GLErrorChecker.checkError();

        if (bufferId != -1)
        {
            LOGGER.error("Buffer already created");
            return;
        }

        bufferId = allocateGLBuffer();

        glBindBuffer(GL_ARRAY_BUFFER, bufferId);
        glBufferData(GL_ARRAY_BUFFER, sizeInBytes, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        this.sizeInBytes = sizeInBytes;

        GLErrorChecker.checkError();

        LOGGER.info("Created vertex buffer with size in bytes: " + sizeInBytes);

    }

    /**
     * Uploads 3f data into a previously created buffer.
     * @param data the data to upload
     */
    public void uploadData3f(List<Vector3f> data)
    {
        GLErrorChecker.checkError();

        if (bufferId == -1)
        {
            LOGGER.error("Buffer not created");
            return;
        }

        stride = 3;
        elementCount = data.size() * stride;
        long requiredBytes = elementCount * 4;

        if (getSizeInBytes() != requiredBytes)
        {
            LOGGER.error("Invalid buffer size, required: " + requiredBytes + " allocated: " + getSizeInBytes());
            return;
        }

        FloatBuffer buffer = BufferUtils.createFloatBuffer(elementCount);

        int index = 0;

        for (Vector3f v : data)
        {
            buffer.put(index, v.x);
            index++;
            buffer.put(index, v.y);
            index++;
            buffer.put(index, v.z);
            index++;
        }

        buffer.rewind();
        buffer.flip();

        glBindBuffer(GL_ARRAY_BUFFER, bufferId);
        glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        ready = true;

        GLErrorChecker.checkError();

        LOGGER.info("Successfully uploaded vertex 3f data");
    }

    /**
     * Uploads 2f data into a previously created buffer.
     * @param data the data to upload
     */
    public void uploadData2f(List<Vector2f> data)
    {

        GLErrorChecker.checkError();

        if (bufferId == -1)
        {
            LOGGER.error("Buffer not created");
            return;
        }

        stride = 2;
        elementCount = data.size() * stride;
        long requiredBytes = elementCount * 4;

        if (getSizeInBytes() != requiredBytes)
        {
            LOGGER.error("Invalid buffer size, required: " + requiredBytes + " allocated: " + getSizeInBytes());
            return;
        }

        buffer = BufferUtils.createFloatBuffer(elementCount);

        int index = 0;

        for (Vector2f v : data)
        {
            buffer.put(index, v.x);
            index++;
            buffer.put(index, v.y);
            index++;
        }

        buffer.rewind();
        buffer.flip();

        glBindBuffer(GL_ARRAY_BUFFER, bufferId);
        glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        ready = true;

        GLErrorChecker.checkError();

        LOGGER.info("Successfully uploaded vertex 2f data");
    }

    /**
     * Allocates a GL Buffer
     * @return the GL buffer id that was allocated
     */
    protected int allocateGLBuffer()
    {
        GLErrorChecker.checkError();

        IntBuffer buffer = BufferUtils.createIntBuffer(1);
        glGenBuffers(buffer);

        GLErrorChecker.checkError();

        int result = buffer.get(0);
        LOGGER.info("Created vertex buffer: " + result);
        return result;
    }


    public long getSizeInBytes()
    {
        return sizeInBytes;
    }

    public boolean isReady()
    {
        return ready;
    }

    public int getElementCount()
    {
        return elementCount;
    }

    public int getBufferId()
    {
        return bufferId;
    }



    public void destroy()
    {
        if (getBufferId() != -1)
        {
            glDeleteBuffers(getBufferId());
            LOGGER.debug("Destroyed GL vertex buffer: " + getBufferId());
        }

        bufferId = -1;
        ready = false;
    }

    public FloatBuffer getBuffer()
    {
        return buffer;
    }

}


  /**
   * Set up and rendering code from my mesh class
   */
   public void renderFromBuffer()
    {

        if (!buffersCreated)
        {
            createIndexBuffer();
            createVertexBuffer();
            buffersCreated = true;
        }

        glEnableClientState(GL_VERTEX_ARRAY);
        glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.getBufferId());
        glVertexPointer(3, GL_FLOAT, 0, 0);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.getBufferId());
        glDrawElements(GL_TRIANGLES, 9, GL_UNSIGNED_INT, 0);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        glDisableClientState(GL_VERTEX_ARRAY);
    }

    protected void createIndexBuffer()
    {
        indexBuffer = new IndexBuffer();
        indexBuffer.createBuffer(faces.size() * 3 * 4);
        List<Integer> indices = new ArrayList<Integer>(faces.size() * 3);

        for (Triangle t : faces)
        {
            indices.add(t.pointIndex[0]);
            indices.add(t.pointIndex[1]);
            indices.add(t.pointIndex[2]);
        }

        indexBuffer.uploadIndexData(indices);
    }

    protected void createVertexBuffer()
    {
        vertexBuffer = new VertexBuffer();
        vertexBuffer.createBuffer(positions.size() * 3 * 4);
        vertexBuffer.uploadData3f(positions);
    }

I've trimmed out the support for normal and texture buffers to keep it simpler