void vk_cmd_buffers_compute_record(VkPipeline compute, VkPipelineLayout compute_layout, VkCommandBuffer compute_cmds, VkBuffer compute_count, uint32_t graphics_queue_index, uint32_t compute_queue_index, VkDescriptorSet *sets)
{
    VkCommandBufferBeginInfo compute_cmds_begin_info = vk_cmd_buffers_begin_info_init(0);

    if (vkBeginCommandBuffer(compute_cmds, &compute_cmds_begin_info)!= VK_SUCCESS)
    {
        printf("Failed to begin recording compute command buffer\n");
    }

    galaxy_params g =
    {
        .star_count = STAR_COUNT,
        .max_rad = 3500.0,
        .bulge_rad = 1250.0,
        .angle = 6.28,
        .eccentricity = 0.85,
        .base_height = 300.0,
        .height = 250.0,
        .dust_temp = 4000.0,
        .min_temp = 1900.0,
        .max_temp = 50000.0,
        .min_star_opacity = 0.1,
        .max_star_opacity = 0.5,
        .min_dust_opacity = 0.01,
        .max_dust_opacity = 0.05,
        .speed = 10.0
    };

    if (graphics_queue_index != compute_queue_index)
    {
        VkBufferMemoryBarrier buffer_barrier =
        {
            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .pNext = NULL,
            .srcAccessMask =  VK_ACCESS_NONE,
            .dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
            .srcQueueFamilyIndex = graphics_queue_index,
            .dstQueueFamilyIndex = compute_queue_index,
            .buffer = compute_count,
            .offset = 0,
            .size = sizeof(uint32_t)
        };

        vkCmdPipelineBarrier(compute_cmds, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_ACCESS_NONE, 0, NULL, 1, &buffer_barrier, 0, NULL);
    }

    uint32_t offsets[2] = {0, 0};
    vkCmdBindPipeline(compute_cmds, VK_PIPELINE_BIND_POINT_COMPUTE, compute);
    vkCmdBindDescriptorSets(compute_cmds, VK_PIPELINE_BIND_POINT_COMPUTE, compute_layout, 0, 1, sets, 2, offsets);
    vkCmdPushConstants(compute_cmds, compute_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(g), &g);

    vkCmdFillBuffer(compute_cmds, compute_count, 0, sizeof(uint32_t), 0);

    VkMemoryBarrier memory_barrier =
    {
        .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
        .pNext = NULL,
        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_SHADER_READ_BIT
    };

    vkCmdPipelineBarrier(compute_cmds, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_ACCESS_NONE, 1, &memory_barrier, 0, NULL, 0, NULL);

    vkCmdDispatch(compute_cmds, PARTICLE_COUNT / PARTICLE_DISPATCH_SIZE, 1, 1);

    if (graphics_queue_index != compute_queue_index)
    {
        VkBufferMemoryBarrier buffer_barrier =
        {
            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .pNext = NULL,
            .srcAccessMask =  VK_ACCESS_SHADER_WRITE_BIT,
            .dstAccessMask = VK_ACCESS_NONE,
            .srcQueueFamilyIndex = compute_queue_index,
            .dstQueueFamilyIndex = graphics_queue_index,
            .buffer = compute_count,
            .offset = 0,
            .size = sizeof(uint32_t)
        };

        vkCmdPipelineBarrier(compute_cmds, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_ACCESS_NONE, 0, NULL, 1, &buffer_barrier, 0, NULL);
    }

    if (vkEndCommandBuffer(compute_cmds) != VK_SUCCESS)
    {
        printf("Failed to record compute command buffer\n");
    }
}

static void vk_cmd_buffers_galaxy_record(VkPipeline galaxy, VkPipelineLayout galaxy_layout, VkCommandBuffer cmd_buffers, VkBuffer indirect_cmds, VkBuffer compute_count, uint32_t graphics_queue_index, uint32_t compute_queue_index, VkDescriptorSet *sets)
{
    if (graphics_queue_index != compute_queue_index)
    {
        VkBufferMemoryBarrier buffer_barrier =
        {
            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .pNext = NULL,
            .srcAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
            .dstAccessMask = VK_ACCESS_NONE,
            .srcQueueFamilyIndex = compute_queue_index,
            .dstQueueFamilyIndex = graphics_queue_index,
            .buffer = indirect_cmds,
            .offset = 0,
            .size = VK_WHOLE_SIZE
        };

        vkCmdPipelineBarrier(cmd_buffers, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, 0, 0, NULL, 1, &buffer_barrier, 0, NULL);
    }

    uint32_t offset = 0;
    vkCmdBindPipeline(cmd_buffers, VK_PIPELINE_BIND_POINT_GRAPHICS, galaxy);
    vkCmdBindDescriptorSets(cmd_buffers, VK_PIPELINE_BIND_POINT_GRAPHICS, galaxy_layout, 0, 1, sets, 1, &offset);

    galaxy_info info =
    {
        .star_count = STAR_COUNT,
        .time = glfwGetTime(),
        .min_temp = 1900.0,
        .max_temp = 50000.0,
        .star_size = 10.0,
        .dust_size = 500.0,
        .h2size = 150.0,
        .h2dist = 300.0
    };

    vkCmdPushConstants(cmd_buffers, galaxy_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(info), &info);
    vkCmdDrawIndirectCount(cmd_buffers, indirect_cmds, 0, compute_count, 0, 6 * PARTICLE_COUNT, sizeof(VkDrawIndirectCommand));

    if (graphics_queue_index != compute_queue_index)
    {
        VkBufferMemoryBarrier buffer_barrier =
        {
            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .pNext = NULL,
            .srcAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
            .dstAccessMask = VK_ACCESS_NONE,
            .srcQueueFamilyIndex = graphics_queue_index,
            .dstQueueFamilyIndex = compute_queue_index,
            .buffer = indirect_cmds,
            .offset = 0,
            .size = VK_WHOLE_SIZE
        };

        vkCmdPipelineBarrier(cmd_buffers, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 1, &buffer_barrier, 0, NULL);
    }
}