For software skinning just update the vertices' positions in the array or vertex buffer, then send it down the pipeline.

IIRC if you keep using vertex arrays you have the copy in system memory and send it down the pipeline everytime you call glVertexPointer etc. so you just update the array in system memory.

Using vertex buffers (VBOs) you'd send the vertices down once and then the driver loads them from video memory. With VBOs you can update portions of the data with glBufferSubData. And if you don't interleave the vertices (i.e. you don't put one vertex after another in the array) but rather store them component-wise / serialized (store positions in a row, then normals, then texcoords etc.) you can cut down the required memory bandwidth since you now are able to update just the positions and the normals.

With VBOs you don't need to remove the old data, you can just bind your existing VBO and then call glBufferData or glBufferSubData. There is a nice whitepaper that explains how to use VBOs. It also has a section of useage tips when dealing with dynamic data.

VBO is an extension, so it only requires that your video card driver supports the extension. It does not depend on the actual capabilities of your video card. The way VBO is actually implemented and the way it performs will depend on your hardware, but as long as your driver supports VBO, you can use it.

IIRC = if I remember correctly

Creation and updates
No, don't create a new VBO on every change. Just bind with glBindBuffer and update with glBufferData or glBufferSubData (updates portions of the VBO). The buffer id is generated once and stored for future use.

Buffer data access
You have 2 options:
1. Keep a copy of the data in client memory, update it there and then send the updated part to the VBO.
2. Use the mapping instructions to directly write to the VBO. Keep in mind that you have to lock the VBO and unlock it after you're done.

Usage
You have to use streaming or dynamic usage but I don't have the docs right here to tell you what could be th best option in your case. If I remember correctly (IIRC) streaming is for data that changes (almost) every frame whereas dynamic usage changes less frequently. It may however be the case that there isn't that much a difference between them at all, since the usage parameter is a hint for the driver on where to store the VBO.

Rendering
Your render code could indeed look like what you've posted.
If you're using normals, texcoord etc. it would expand to


Storage
Here stride can have two values:
For interleaved VBOs it would be stride = vertexSize
For serialized VBOs it would be stride = 0.

The offset value also could be different. Let's assume the vertex layout is

texcoord (2 floats)
normal (3 floats)
position (3 floats)

In interleaved VBOs the offsets would be:
texcoordoffset = 0
normaloffset = 2
vertexoffset = 5

This means that from the beginning of each vertex the corresponding component is found at the given offset.

For serialized VBOs the offsets could look like this:
texcoordoffset = 0
normaloffset = vertexCount * 2
vertexoffset = vertexCount * 5

Here the components are stored as non-interleaved arrays, i.e. all texcoords first, then normals, then positions.

If your positions and normals change you update only the corresponding portions via glBufferSubData (in interleaved VBOs you'd have to update the whole buffer).

That code is correct. However, if you can afford to keep a copy of your vertex data in system memory, I would say forget using the mapping method. The problem with mapping is that if the data is in video memory or even AGP memory, the driver will have to copy it to system memory when you map it. You will then update all or part of the data. Finally, when you unmap it, the driver has to copy the data back. Now, you can't really get around having to update the GPU's copy of the data, but if you can keep your own working copy of the data you can at least avoid the GPU->CPU copy. Use glBufferData with a NULL pointer as the paper states to avoid stalling the pipeline. Then just call glBufferData or glBufferSubData to update the GPUs copy of the data.

The offset for vertexoffset is 5 because you have to jump 2 to get past the texture coords, and then jump another 3 to get past the normal.