Okay, the question hasn't been answered, so I figured I ought to do my namesake justice here.

The pVertices (clearly, a pointer to vertices) is cast to void** because the pointer itself may change.

But, since pVertices is void*, you must get the address of that variable so that you can cast it to a pointer-to-a-pointer (as has already been mentioned).

Here's the reason the third argument to Lock is void**: if it were void*, you wouldn't be able to change the pointer value. This will probably make more sense if you first consider the case where the argument is not a pointer type.

Let's say we have a function foo:

void foo(int a){    a = 0;}

If you call foo(x) then print the value of x, you'll find that it doesn't actually change. This is because the change only exists within the scope of the function foo(), unless you pass the argument by reference or by pointer. So, if we had another function:

void bar(int* a){    *a = 0}

then calling bar(&x) _would_ change x.

In the case where the location of the pointer might change, you would want to pass a pointer-to-a-pointer, so that any change to which pointer was being used could continue outside of the function's scope. The pointer itself may still point to the same address as the pointer being passed to the function (which is probably the case for this Lock() function) yet which pointer is doing so can be changed (and since it's a void**, the type of the underlying object itself could also change). An example:

void* global_verts;bool foobar(void** pToP){    // you could append the values in the arguments to the global vertices    int size = length(global_verts) + length(*pToP); // assume length is a helper function to find the length of an array of vertices    void* newPtr = new Vertex[size];    gLen = length(global_verts);    for (i = 0; i < gLen; ++i) newPtr = global_verts;    for (i = 0; i < length(*pToP); ++i) newPtr[i+gLen] = (*pToP);    void* old_global = global_verts // (see edit below)    void* old_ptop = *pToP; // (see edit below)    // here, we change the global pointer to the new concatenation of vertices    global_verts = newPtr;    // and make sure that the argument gets updated, too    *pToP = global_verts;    // EDIT: fixed a memory leak (be careful when using pointers!)    delete [] old_global;    delete [] old_ptop;   (I'm assuming that the argument had always been allocated using new [] -- make sure new and delete calls match)    return true;}

[Edited by - void* on May 19, 2006 8:21:23 PM]

In all honesty, I don't see why you are declaring 'pVertices' as 'VOID*'. You might as well declare it as your vertex type (as Evil Steve stated) and save all the fun stuff for passing it off to IDirect3DVertexBuffer9::Lock() (well, DX 8 or 9).
Plus, I think it's a double pointer so that it can also set the value of the data that you pass off to the function.

NOTE: That's an interesting name, void*.