Vulkan vkCmdDrawIndexed used only first Value from VertexBuffer

Question

i`m trying to implement instanced mesh rendering in Vulkan.

My Problem is that Vulkan uses only the first Vertex from the binded VertexBuffer and duplicate the Value for all Indices. Output RenderDoc:

RenderDoc output Duplicated Vertex Input

These should be the correct values {{<inPosition>},{<inColor>},{<inTexCoord>}}:

const vkf::Vertex vertices[] = {
    { { -0.2f, -0.5f, 0.0f },{ 1.0f, 0.0f, 0.0f },{ 1.0f, 0.0f } },
    { { 0.5f, -0.5f, 0.0f },{ 0.0f, 1.0f, 0.0f },{ 0.0f, 0.0f } },
    { { 0.5f, 0.5f, 0.0f },{ 0.0f, 0.0f, 1.0f },{ 0.0f, 1.0f } },
    { { -0.5f, 0.5f, 0.0f },{ 1.0f, 1.0f, 1.0f },{ 1.0f, 1.0f } }
};

I've checked the VertexBuffer multiple times and it contains the correct values.

Here is the snipped from my CommandBuffer creating:

        vkCmdBindPipeline(m_commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.agents);

        VkBuffer vertexBuffers[] = { models.agent.verticesBuffer };
        VkBuffer instanceBuffers[] = { m_instanceBuffer.buffer };

        VkDeviceSize offsets[] = { 0 };
        vkCmdBindVertexBuffers(m_commandBuffers[i], 0, 1, vertexBuffers, offsets);
        vkCmdBindVertexBuffers(m_commandBuffers[i], 1, 1, instanceBuffers, offsets);

        vkCmdBindIndexBuffer(m_commandBuffers[i], models.agent.indexBuffer, 0, VK_INDEX_TYPE_UINT16);

        vkCmdBindDescriptorSets(m_commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayouts.pipelineLayoutAgent, 0, 1, &descriptorSets.agent, 0, nullptr);
        vkCmdDrawIndexed(m_commandBuffers[i], static_cast<uint32_t> (models.agent.indexCount), 5, 0, 0, 0); 

My first assumption was that my binding description is wrong. But I can`t see the error:

bindingDescription = {};
bindingDescription.binding = 0;
bindingDescription.stride = sizeof(Vertex);
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;

Why is only the first value from the buffer used?

EDIT:

InstanceData:

struct InstanceData
{
    glm::vec3 pos;
    glm::vec3 rot;
    float scale;


    static VkVertexInputBindingDescription getBindingDescription()
    {
        VkVertexInputBindingDescription bindingDescription = {};
        bindingDescription.binding = INSTANCING_BIND_ID;
        bindingDescription.stride = sizeof(InstanceData);
        bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;

        return bindingDescription;
    }

};

The whole VkPipelineVertexInputStateCreateInfo:

std::vector<VkVertexInputBindingDescription> bindingDesciption = {};
std::vector<VkVertexInputAttributeDescription> attributeDescriptions = {};

bindingDesciption = { 
    models.agent.bindingDescription,    
    InstanceData::getBindingDescription() 
};
attributeDescriptions =
{
    vertexInputAttributeDescription(VERTEX_BIND_ID, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(vkf::Vertex, pos)),
    vertexInputAttributeDescription(VERTEX_BIND_ID, 1, VK_FORMAT_R32G32B32_SFLOAT, offsetof(vkf::Vertex, color)),
    vertexInputAttributeDescription(INSTANCING_BIND_ID, 2, VK_FORMAT_R32G32B32_SFLOAT, offsetof(InstanceData, pos)),
    vertexInputAttributeDescription(VERTEX_BIND_ID, 3, VK_FORMAT_R32G32_SFLOAT, offsetof(vkf::Vertex, texCoord))
};

VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};

vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputInfo.vertexBindingDescriptionCount = static_cast<uint32_t>(bindingDesciption.size());
vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
vertexInputInfo.pVertexBindingDescriptions = bindingDesciption.data();
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();

EDIT 2

#define VERTEX_BIND_ID 0
#define INSTANCING_BIND_ID 1

EDIT 3: I`m using VulkanMemoryAllocator. Creating Staging Buffer

size_t vertexBufferSize = sizeof(vkf::Vertex) *_countof(vertices);

createStagingBuffer(vertexBufferSize );

VkBuffer createStagingBuffer(VkDeviceSize size)
{
    VkBuffer buffer;
    VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
    bufferInfo.size = size;
    bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

    VmaAllocationCreateInfo allocCreateInfo = {};
    allocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
    allocCreateInfo.flags = VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT;

    VmaAllocationInfo allocInfo = {};
    if (vmaCreateBuffer(m_allocator, &bufferInfo, &allocCreateInfo, &buffer, &m_allocation, &allocInfo) != VK_SUCCESS)
    {
        throw std::runtime_error("failed to create Buffer!");
    }
    return buffer;
}

Copy vertices:

memcpy(mappedStaging, vertices, vertexBufferSize);

Creating Buffer:

createBuffer(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VMA_MEMORY_USAGE_GPU_ONLY);

VkBuffer createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VmaMemoryUsage vmaUsage)
{
    VkBuffer buffer;   

    VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
    bufferInfo.size = size;
    bufferInfo.usage = usage;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

    VmaAllocationCreateInfo allocCreateInfo = {};
    allocCreateInfo.usage = vmaUsage;
    allocCreateInfo.flags = 0;

    VmaAllocationInfo allocInfo;
    if (vmaCreateBuffer(m_allocator, &bufferInfo, &allocCreateInfo, &buffer, &m_allocation, &allocInfo) != VK_SUCCESS)
    {
        throw std::runtime_error("failed to create Buffer!");
    }    
    return buffer;
}

This is how I transfair my Buffer from staging:

copyBuffer(stagingVertexBuffer, verticesBuffer, vertexBufferSize);

void Base::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size)
{
    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

    VkBufferCopy copyRegion = {};
    copyRegion.dstOffset = 0;
    copyRegion.srcOffset = 0;
    copyRegion.size = size;
    vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);

    endSingleTimeCommands(commandBuffer);
}

I checked several times if the data is in the staging Buffer and after modifing the createBuffer Prozess also in the verticesBuffer. They are stored there correctly.

Answer 1

I found the mistake. The mistake was here:

bindingDesciption = { 
    models.agent.bindingDescription,    
    InstanceData::getBindingDescription() 
};

By the time the binding took place, models.agent.bindingDescription,was not initialized yet. As a result, the VkVertexInputBindingDescription was faulty. models.agent.bindingDescription was filled with the standard values for VkVertexInputBindingDescription:

binding = 0
stroke = 0
inputRate = VK_VERTEX_INPUT_RATE_VERTEX