// Vulkan: expose one storage buffer to a shader
VkDescriptorSetLayoutBinding bind{
    .binding = 0,
    .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
    .descriptorCount = 1,
    .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
};
VkDescriptorSetLayoutCreateInfo lci{
    .bindingCount = 1, .pBindings = &bind,
};
vkCreateDescriptorSetLayout(device, &lci, nullptr, &layout);

VkDescriptorPoolSize size{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1 };
VkDescriptorPoolCreateInfo pci{
    .maxSets = 1, .poolSizeCount = 1, .pPoolSizes = &size,
};
vkCreateDescriptorPool(device, &pci, nullptr, &pool);

VkDescriptorSetAllocateInfo ai{
    .descriptorPool = pool, .descriptorSetCount = 1, .pSetLayouts = &layout,
};
vkAllocateDescriptorSets(device, &ai, &set);

VkDescriptorBufferInfo info{ buffer, 0, VK_WHOLE_SIZE };
VkWriteDescriptorSet write{
    .dstSet = set, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
    .pBufferInfo = &info,
};
vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);

vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
                        pipe_layout, 0, 1, &set, 0, nullptr);

// Daxa: hand the shader a pointer. That is the binding model.
recorder.push_constant(MyPush{
    .vertices = device.get_buffer_device_address(buffer).value(),
});

// main.glsl
DAXA_DECL_PUSH_CONSTANT(MyPush, push)

void main() {
    MyVertex v = deref_i(push.vertices, gl_VertexIndex);
}

// Vulkan: barrier a compute write before a fragment read
VkImageMemoryBarrier2 barrier{
    .srcStageMask  = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
    .srcAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
    .dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
    .dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
    .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
    .newLayout = VK_IMAGE_LAYOUT_GENERAL,
    .image = image,
    .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
};
VkDependencyInfo dep{
    .imageMemoryBarrierCount = 1, .pImageMemoryBarriers = &barrier,
};
vkCmdPipelineBarrier2(cmd, &dep);
// ...and again for every resource, on every pass, every frame.

// Daxa: declare intent, TaskGraph emits the barriers
tg.add_task(daxa::Task::Compute("blur")
    .writes(image)
    .executes(blur));

tg.add_task(daxa::Task::Raster("present")
    .reads(image)
    .executes(present));
// Barriers and reordering: generated from the reads/writes.