Thread: std::unordered_map question

Hi there,

I'm struggling a bit with this as it's a little new to me. I've come across this in my project and was wondering exactly what it's doing?

Here's a struct definition which contains the un-ordered map. The struct MeshGeometry has some COM pointers in it that will (presumably) point to filled vertex and index buffers later. I've left some of the details out for clarity:

Code:

struct MeshGeometry
{
    // Give it a name so we can look it up by name.
    std::string Name;

    // System memory copies.  Use Blobs because the vertex/index format can be generic.
    // It is up to the client to cast appropriately.  
    Microsoft::WRL::ComPtr<ID3DBlob> VertexBufferCPU = nullptr;
    Microsoft::WRL::ComPtr<ID3DBlob> IndexBufferCPU  = nullptr;

    Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferGPU = nullptr;
    Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferGPU = nullptr;

    Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferUploader = nullptr;
    Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferUploader = nullptr;

    // Data about the buffers.
    UINT VertexByteStride = 0;
    UINT VertexBufferByteSize = 0;
    DXGI_FORMAT IndexFormat = DXGI_FORMAT_R16_UINT;
    UINT IndexBufferByteSize = 0;

    // A MeshGeometry may store multiple geometries in one vertex/index buffer.
    // Use this container to define the Submesh geometries so we can draw
    // the Submeshes individually.
    std::unordered_map<std::string, SubmeshGeometry> DrawArgs;

.... rest omitted (just a few member functions)

}

So that's the struct where the unordered_map data member is first defined. The SubmeshGeometry struct has the following definition:

Code:

// Defines a subrange of geometry in a MeshGeometry.  This is for when multiple
// geometries are stored in one vertex and index buffer.  It provides the offsets
// and data needed to draw a subset of geometry stores in the vertex and index 
// buffers so that we can implement the technique described by Figure 6.3.

struct SubmeshGeometry
{
    UINT IndexCount = 0;
    UINT StartIndexLocation = 0;
    INT BaseVertexLocation = 0;

    // Bounding box of the geometry defined by this submesh. 
    // This is used in later chapters of the book.
    DirectX::BoundingBox Bounds;
};

And here's the code used to run this stuff in the .cpp file:

Code:

    SubmeshGeometry submesh;
    submesh.IndexCount = (UINT)indices.size();
    submesh.StartIndexLocation = 0;
    submesh.BaseVertexLocation = 0;

    mBoxGeo->DrawArgs["box"] = submesh;

So a MeshGeometry can hold buffers that actually contain several individual objects such as a box, a sphere and a cylinder. When we only want to draw one of them we need only a portion of the MeshGeometry - which is the SubmeshGeometry.

So it seems the map takes the Submesh declaration and somehow ties it to a portion of the MeshGeometry struct. It seems to do this however with an std::string, which I found a bit weird. I know there's a lot of API stuff in here but it's the C++ stuff I'm concerned about. Namely how the unordered_map ties data to struct and does so using a string.

So when this is done can I sort of "access" the unordered_map in the MeshGeometry struct and retrieve Submesh data from it?

That would make sense actually, because some of this data is needed later on (functions not shown here) to tell the GPU which part of the buffer to draw from, so you can pick out which specific shape you want to draw.

Still a bit shaky on it though, so I'd appreciate some input on the C++ only parts of it. I understand this is not the place to be requesting info about the API parts.

Thanks

I'd suggest you practice with an example or two using types you're more familiar with.

std::unordered_map - cppreference.com

When you know what an unordered_map is all about, you'll be able to understand the code that much better.

Hash table - Wikipedia

I may have misinterpreted your question, but I thought you were asking how the unordered_map works. It uses a hash table, which is an "unordered" data structure, hence the name. The standard map class uses a balanced binary tree, which is ordered so that you can output the data by key in sorted order.

Code:

#include <iostream>
#include <string>
#include <map>
#include <unordered_map>

int main() {
    const char *s[] = {
        "one", "two", "three", "four", "five",
        "six", "seven", "eight", "nine", "ten"
    };

    std::map<std::string, int> om;
    std::unordered_map<std::string, int> um;

    for (int i = 0; i < int(sizeof s / sizeof *s); ++i) {
        om.insert({s[i], i + 1});
        um.insert({s[i], i + 1});
    }
    
    // this outputs in sorted key order
    for (const auto& [k, v]: om)
        std::cout << k << ": " << v << '\n';

    std::cout << "----\n";

    // this outputs in a seemingly arbitrary order
    for (const auto& [k, v]: um)
        std::cout << k << ": " << v << '\n';
}

Output:

Code:

eight: 8
five: 5
four: 4
nine: 9
one: 1
seven: 7
six: 6
ten: 10
three: 3
two: 2
----
one: 1
two: 2
six: 6
three: 3
nine: 9
five: 5
four: 4
seven: 7
eight: 8
ten: 10