如何从DirectXTK（ToolKit）DirectX :: Model类获取所有顶点坐标以用于碰撞检测

Question

I'm, doing some basic rendering with DirectXToolKit and I would like to be able to get the vertex coordinates for each model in order to compute collisions between models.

currently, I have some test code to load the model, but the ID3D11Buffer loads internally using CreateFromSDKMESH

void Model3D::LoadSDKMESH(ID3D11Device* p_device, ID3D11DeviceContext* device_context, const wchar_t* file_mesh)
{
    mAlpha = 1.0f;
    mTint = DirectX::Colors::White.v;

    mStates.reset(new DirectX::CommonStates(p_device));
    auto fx = new DirectX::EffectFactory(p_device);
    fx->SetDirectory(L"media");
    mFxFactory.reset(fx);
    mBatch.reset(new DirectX::PrimitiveBatch<DirectX::VertexPositionColor>(device_context));

    mBatchEffect.reset(new DirectX::BasicEffect(p_device));
    mBatchEffect->SetVertexColorEnabled(true);
    {
        void const* shaderByteCode;
        size_t byteCodeLength;

        mBatchEffect->GetVertexShaderBytecode(&shaderByteCode, &byteCodeLength);

        HR(p_device->CreateInputLayout(DirectX::VertexPositionColor::InputElements,
            DirectX::VertexPositionColor::InputElementCount,
            shaderByteCode, byteCodeLength,
            mBatchInputLayout.ReleaseAndGetAddressOf()));
    }

    mModel = DirectX::Model::CreateFromSDKMESH(p_device, file_mesh, *mFxFactory);
}

I know there is a way to get vertexes from the ID3D11Buffer , answered here: How to read vertices from vertex buffer in Direct3d11

But they suggest not loading from GPU memory. So I assume it's better to load vertices ahead of time into a separate container.

Answer 1

I looked into CreateFromSDKMESH and there are a few functions that are publicly accessible without making changes to XTK

In order to get Vertices while loading a model, replace the line mModel = DirectX::Model::CreateFromSDKMESH(p_device, file_mesh, *mFxFactory); in the question above with:

size_t data_size = 0;
std::unique_ptr<uint8_t[]> v_data;
HRESULT hr = DirectX::BinaryReader::ReadEntireFile(file_mesh, v_data, &data_size);
if (FAILED(hr))
{
    DirectX::DebugTrace("CreateFromSDKMESH failed (%08X) loading '%ls'\n", hr, file_mesh);
    throw std::exception("CreateFromSDKMESH");
}
uint8_t* mesh_data = v_data.get();
mModel = DirectX::Model::CreateFromSDKMESH(p_device, v_data.get(), data_size, *mFxFactory, false, false);
mModel->name = file_mesh;
auto v_header = reinterpret_cast<const DXUT::SDKMESH_HEADER*>(mesh_data);
auto vb_array = reinterpret_cast<const DXUT::SDKMESH_VERTEX_BUFFER_HEADER*>(mesh_data + v_header->VertexStreamHeadersOffset);

if(v_header->NumVertexBuffers < 1)
    throw std::exception("Vertex Buffers less than 1");
auto& vertex_header = vb_array[0];
uint64_t buffer_data_offset = v_header->HeaderSize + v_header->NonBufferDataSize;
uint8_t* buffer_data = mesh_data + buffer_data_offset;  
auto verts_pairs = reinterpret_cast<std::pair<Vector3,Vector3>*>(buffer_data + (vertex_header.DataOffset - buffer_data_offset));

There, accessing a coordinate should be as simple as

float x = verts_pairs[0].first.x; and the total number of vertices is stored in

vertex_header.NumVertices

Dont forget that after loading the vertex buffer gets deleted, so you may want to do something like:

memcpy(vertexBuffer, reinterpret_cast<std::pair<Vector3,Vector3>*>(buffer_data + (vertex_header.DataOffset - buffer_data_offset)), vertexCnt);

Also, vertex buffer doesn't get transformed with draw functions, so you will need to do transforms yourselves

Thanks,