How to Bind Multiple Shapes/Models to One Vertex Buffer?

Question

If I have two Vertex Arrays, one for Square, and one for Triangle; what is the best way to bind them to the VertexBuffer?

What are the patterns used to write multiple vertices to the VertexBuffer? Streams? Vectors? Is there an Add, (+) overload that can be used like .pSysMem += anotherMesh.GetVertices()?

1. Is this possible with objects that have different numbers of Vertices?
2. Is this possible with objects that have different buffer element descriptions, (one with float4 position data, and another with float3 and texcoords, etc)?

Currently, I am binding one Shape, (a triangle), to the subresource like this:

ModelRenderer::StaticBufferDescription.ByteWidth = bufferSize;
ModelRenderer::StaticBufferDescription.BindFlags = D3D11_BIND_VERTEX_BUFFER; 


ModelRenderer::StaticSubResourceData.SysMemPitch = 0;
ModelRenderer::StaticSubResourceData.SysMemSlicePitch = 0;
ModelRenderer::StaticSubResourceData.pSysMem = model->GetVertices(); 

DeviceManager::Device->CreateBuffer(
    & ModelRenderer::StaticBufferDescription, 
    & ModelRenderer::StaticSubResourceData, 
    & ModelRenderer::StaticBuffer);

Answer 1

You can definitely put multiple objects in a vertex buffer, even with different numbers of vertices. A vertex buffer doesn't know or care where the "objects" are in it - it's nothing more than a list of vertices. If you have a fixed set of objects you want to draw, you can simply concatenate all your vertices together and put them in one big vertex buffer; when you do your Draw() call, you'll specify the range of vertices to draw from the buffer. Or if you use index buffers and DrawIndexed(), the same applies.

All the vertices in a buffer have to be the same format, though (i.e. the same size and order of components like position, normal, UV etc). You can't mix and match different vertex formats in one buffer. Well, technically perhaps you could, but you'd have to re-call IASetVertexBuffers() with different strides and offsets, and do a separate draw call, for each format. That would pretty much negate the point of putting everything in one big vertex buffer; it would be simpler just to have several buffers.

Now, you brought up instancing, so I'll say a little about that. Instancing is designed to let you repeat an "inner" vertex buffer many times, each time pairing it with a different "outer vertex" (i.e. an instance). Across all the instances drawn in a single draw call, the inner vertex buffer must be the same. So if you have triangles in one buffer and squares in another, you would not be able to draw multiple instances of both of them in one draw call, using hardware instancing. You would have to do one draw call for all the triangles, and one for all the squares.

You have a couple options here. First, you could do the instancing manually, by constructing a huge vertex buffer and copying in the triangle vertices as many times as you have triangles, and the square vertices as many times as you have squares, etc.

The other option, which is advanced, is to use some tricks in the vertex shader to look up the inner vertices from a different place in the buffer depending on a value set in the outer vertex data. This requires all the different instance meshes to be padded out to a common vertex size by adding degenerate triangles. This approach was used in Just Cause 2. For more information see Emil Persson's presentation Graphics Gems for Games (slides 19-24).

Answer 2

The easiest solution for you is to just settle on a common vertex type for all of your objects, which would be a superset of all the different vertex types you currently have. Yes, I know that right about now you're thinking something like "but that would waste memory!" but always remember - this is a tradeoff, and what you're losing in memory usage you're gaining by not having to call IASetVertexBuffers multiple times with different strides and offsets. Memory isn't everything, buffer changes can be potentially expensive (if nothing else you'll need to break the current batch to do one), and avoiding so many buffer changes can potentially give you much more performance than saving a few lousy kilobytes.

From there you just need to adjust the parameters of your Draw () call as appropriate.

Answer 3

In the example below, individual mesh/instance data is being copyied into a big memory buffer, which is then assigned to the subresource. Alternatively, the instance data could already be in a memory buffer so this wouldn't have to be done every "draw".

Also, a vector is guaranteed to be contiguous in C++11 so you can assign the vector to the subResource.pSysMem = vector, rather than a fixed size array.

If you want to go further than this, you can can stream into the memory buffer being used from a flat file. Just be careful of buffer overruns.

void ModelRenderer::UpdateInstanceBuffer()
    {
        NS::InstanceStateFactory<int> * stateFactory = nullptr;
        stateFactory = (NS::InstanceStateFactory<int> *) NS::ModelFacade::GetInstanceStateFactory();

        // std::vector<NS::Vertex> instances;

        unsigned int memoryAllocationSizeInBytes = sizeof(Position) * 10;

        std::vector<int8_t> buffer(memoryAllocationSizeInBytes);

        int instanceCount = 0;
        int stride = sizeof(Position);

        for(auto & kv : stateFactory->Instances)
        {
            // Push vector arrays into Memory Buffer
            memcpy(&buffer[0] + instanceCount * stride, & kv.second->Position, stride);

            instanceCount ++;
        }

        D3D11_MAPPED_SUBRESOURCE resource;

        HRESULT hResult = DeviceManager::DeviceContext->
            Map(ModelRenderer::InstanceBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &resource);

        // resource.pData = instances.data();
        memcpy(resource.pData, buffer.data(), sizeof(Position) * instanceCount);

        DeviceManager::DeviceContext->Unmap(ModelRenderer::InstanceBuffer.Get(), 0);

        // ModelRenderer::BindInstanceBuffer();

        // delete instances.data();
    }