Image data values created on the CPU is not uploaded to GPU

[dov]

While trying to reimplement the Sascha Willem ssao.cpp program in VSG I encountered the issue that the data in the 8x8 image containing noise values that I create on the CPU side, is not uploaded to the GPU. When inspecting the texture in qrenderdoc, I can see my texture but its values are constant 1.0 and do not reflect the values that I entered on the CPU side.

Here's what I do:

  #define SSAO_NOISE_DIM 8
  :
  auto noiseValues = vsg::ubvec4Array2D::create(SSAO_NOISE_DIM, SSAO_NOISE_DIM);
  for (uint32_t i = 0; i < SSAO_NOISE_DIM * SSAO_NOISE_DIM; ++i)
    noiseValues->set(i, vsg::ubvec4 {0, 0, 0, 0}); // set to zero for testing
 
  // This should not be needed, as I do the above assignment before `viewer->compile`, in any case it doesn't help the issue
  // in question.
  noiseValues->properties.dataVariance = vsg::DYNAMIC_DATA;
  noiseValues->dirty();
  
  // Create image
  auto noiseImage = vsg::Image::create();

  noiseImage->data = noiseValues;
  noiseImage->format = VK_FORMAT_R8G8B8A8_UNORM;
  noiseImage->extent = VkExtent3D{SSAO_NOISE_DIM, SSAO_NOISE_DIM, 1};
  noiseImage->usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
  noiseImage->arrayLayers = 1;
  
  // Create sampler
  auto sampler = vsg::Sampler::create();
  sampler->magFilter = VK_FILTER_NEAREST;
  sampler->minFilter = VK_FILTER_NEAREST;
  
// Create ImageView from the image
  auto noiseImageView = vsg::ImageView::create(noiseImage);

  // Create ImageInfo for descriptor
  noiseImageInfo = vsg::ImageInfo::create(
    sampler, noiseImageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

I then set up the descriptor bindings for this image:

  vsg::DescriptorSetLayoutBindings descriptorBindings {
    ...,
    ...,
    {2, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}, // samplernoise
  };

and declare the descriptorSetLayout and the descriptor:

  auto descriptorSetLayout = vsg::DescriptorSetLayout::create(descriptorBindings);
  :
  descriptors.push_back(
          vsg::DescriptorImage::create(
            inputImages[binding.binding], // binding.binding==2 -> noiseImageInfo
            binding.binding, // binding==2
            0, // array element
            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER));
  auto descriptorSet = vsg::DescriptorSet::create(descriptorSetLayout, descriptors);
  :
  auto bindDescriptorSet = vsg::BindDescriptorSet::create(
    VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline->layout,
    0, // firstSet
    descriptorSet);

  auto stateGroup = vsg::StateGroup::create();
  stateGroup->add(bindGraphicsPipeline);
  stateGroup->add(bindDescriptorSet);

My fragment shader references the above binding:

layout (binding = 2) uniform sampler2D ssaoNoise;

I have verified that if I change the size of the SSAO_NOISE_DIM define, then the new size is reflected in qrenderdoc, so apparently the pipeline is set up correctly. The only thing that is missing is that the data in qrenderdoc does not reflect the values in the noiseValues array.

Is there some flag to vsg::Image that indicates that the image value should be transfered to the GPU? What am I missing?

I'll create a minimum fully working example, if it will help debugging the issue.

[dov]

I made some progress debugging this:

1. I added an manual non-VSG transfer of the image data to the GPU and in qrenderdoc I could verify that in Frame #0, in the Copy/Clear Pass, the CPU values are copied to the NoiseImage as expected.
2. However, a few statements later, according to qrenderdoc, the following commands occur in sequence:

vkCmdCopyBufferToImage(Buffer 275, NoiseImage)
vkCmdCopyBufferToImage(Buffer 275, 2D Depth Attachment 144)
vkCmdCopyBufferToImage(Buffer 275, 2D Depth Attachment 172)
vkCmdCopyBufferToImage(Buffer 275, 2D Depth Attachment 195)
vkCmdCopyBufferToImage(Buffer 275, 2D Depth Attachment 212)

Buffer 275 contains a constant value for the byte region that is copied to NoiseImage. This is what overrides the NoiseImage with constant 1.0.

So now the question is, why the CPU array of the noiseImage isn't transfered to "Buffer 275"?

[dov]

I found the answer!

The reason for the failed transfer was found by debugging code in VulkanSceneGraph/src/vsg/app/TransferTask.cpp:

Images are treated differently than buffer uniforms, and the value in the image data is not uploaded to the GPU unless the value->properties.format is set explictly:

Here's the corrected code

  auto noiseValues = vsg::vec4Array2D::create(SSAO_NOISE_DIM, SSAO_NOISE_DIM);
  noiseValues->properties.format = VK_FORMAT_R32G32B32A32_SFLOAT; // Must be set for values to be transfered!
  for (uint32_t i = 0; i < SSAO_NOISE_DIM * SSAO_NOISE_DIM; ++i)
  {
    auto v = vsg::vec4(...); // Must match the properties.format
    noiseValues->set(i, v);
  }
  
  // Create image
  auto noiseImage = vsg::Image::create();
  noiseImage->data = noiseValues;
  noiseImage->format = noiseValues->properties.format; // Should match the value format

This is only necessy for an texture image uniform. For other buffer uniforms, the value is always uploaded to the GPU.