I am currently working on my first iteration of my sprite renderer and I'm trying to draw 2 sprites. They both use the same texture and are placed into the same buffer, but unfortunately only the second sprite is shown on the the screen. I assume I messed something up when I place them into the buffer and that I am overwriting the data of the first sprite.

So how should I be mapping my buffer with an offset?

/*
Code that sets up the sprite vertices and etc
*/

D3D11_MAPPED_SUBRESOURCE resource = vertexBuffer->map(vertexBufferMapType);
memcpy(resource.pData, verts, sizeof(SpriteVertex) * VERTEX_PER_QUAD);
vertexBuffer->unmap();
vertexCount += VERTEX_PER_QUAD;

I feel like I should be doing something like:

/*
Code that sets up the sprite vertices and etc
*/

D3D11_MAPPED_SUBRESOURCE resource = vertexBuffer->map(vertexBufferMapType);
//Place the sprite vertex data into the pData using the current vertex count as offset
//The code resource.pData[vertexCount] is syntatically wrong though :( Not sure how it should look since pData is void pointer
memcpy(resource.pData[vertexCount], verts, sizeof(SpriteVertex) * VERTEX_PER_QUAD);
vertexBuffer->unmap();
vertexCount += VERTEX_PER_QUAD;

Also speaking of offsets can someone give an example of when the pOffsets param for the IASetVertexBuffers call would not be 0
 

Your right in that the first code chunk just overwrites what you already have in there if you call it a second time.

resource.pData is a void pointer as you know. it's just an address. resource.pData[vertexCount] is the right idea though, but since it's a void pointer, you can't index it that way. two things you can do. one is to cast resource.pData to a SpriteVertex* (or a char* then multiply vertexCount by the size of your vertex structure), then index it:
(static_cast<SpriteVertex*>resource.pData)[vertexCount]

or:
(static_cast<char*>resource.pData)[vertexCount * sizeof(SpriteVertex)]

The other thing you can do is just add the number of bytes to resource.pData to get to your second chunk of vertices address:

resource.pData + (vertexCount * sizeof(SpriteVertex))

As for the pOffsets param, an example might be that you have a 2d animated sprite. all your animations of the sprite are in a single texture at different texture coordinates. You might have two vertex buffers, one for positions, and one for texture coordinates. the positions vertex buffer might simply contain 6 vertices for a quad (two triangles). the texture coordinates vertex buffer might contain all the texture coordinates for each frame of animation for that sprite. When you call IASetVertexBuffers, you will provide both of those vertex buffers, and two pOffsets. The first time you render your sprite, maybe you want the first animation frame, which is the texture coordinates located at the beginning of your texture coordinates buffer. in this case, the array of pOffsets you pass in would look like [0, 0], meaning start at the beginning of both buffers. Next you want to draw the second frame of animation, so you would pass in an array that might look like this [0, 6] (each quad has 2 triangles, each triangle has 3 texture coordinates, so the quad you are drawing might have 6 texture coordinates), the first one is your positions buffer, you will use the same positions for the quad. the second is your texture coordinates you want to use, offset 6 to get to the second animation frame. this is in bytes though so would actually be 6 * sizeof(texturecoordinate)

So looking at the data (psuedocode), your buffers all together might look like this:

vertex positions:

[0, 1, 2, 3, 4, 5] - just pretend each number is actually a vertex position

texture coordinates:

[0, 1, 2, 3, 4, 5, - first animation frame

6, 7, 8, 9, 10, 11, - second animation frame

12, 13, 14, 15, 16, 17] - third animation frame