Descriptors

typedef struct
{
    VkDescriptorSetLayout layout;
    VkDescriptorPool pool;
    VkDescriptorSet sets[MAX_FRAMES_IN_FLIGHT];
    vk_uniform compute_frustum[MAX_FRAMES_IN_FLIGHT];
    vk_buffer compute_indirect_cmds[MAX_FRAMES_IN_FLIGHT], compute_count[MAX_FRAMES_IN_FLIGHT];
    vk_buffer galaxy_particles[MAX_FRAMES_IN_FLIGHT];
    vk_uniform graphics_camera[MAX_FRAMES_IN_FLIGHT], galaxy_camera[MAX_FRAMES_IN_FLIGHT];
}   vk_desc_set;

VkDescriptorSetLayoutBinding vk_desc_set_layout_binding_init(uint32_t binding, VkDescriptorType type, uint32_t desc_count, VkShaderStageFlags stage)
{
    VkDescriptorSetLayoutBinding desc_set =
    {
        .binding = binding,
        .descriptorType = type,
        .descriptorCount = desc_count,
        .stageFlags = stage,
        .pImmutableSamplers = NULL
    };

    return desc_set;
}

static VkDescriptorSetLayoutCreateInfo vk_desc_set_layout_info_init(VkDescriptorSetLayoutBinding *binding, uint32_t binding_count)
{
    VkDescriptorSetLayoutCreateInfo layout_info =
    {
        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .bindingCount = binding_count,
        .pBindings = binding
    };

    return layout_info;
}

static VkDescriptorSetLayout vk_desc_set_layout_init(vk_device *d, VkDescriptorSetLayoutBinding *binding, uint32_t binding_count)
{
    VkDescriptorSetLayout layout = {0};

    VkDescriptorSetLayoutCreateInfo layout_info = vk_desc_set_layout_info_init(binding, binding_count);

    if (vkCreateDescriptorSetLayout(d->device, &layout_info, NULL, &layout) != VK_SUCCESS)
    {
        printf("Failed to create descriptor set layout\n");
    }

    return layout;
}

void vk_desc_set_compute_update(vk_uniform *ub, camera *c, frustum *f)
{
    camera_frustum_init(c, f);
    memcpy(ub->mapped, f->planes, sizeof(f->planes));
}

void vk_desc_set_graphics_update(vk_uniform *ub, camera *c, VkExtent2D img_extent)
{
    c->camera = camera_buffer_init(c, img_extent);
    memcpy(ub->mapped, &c->camera, sizeof(c->camera));
}

void vk_desc_set_galaxy_update(vk_uniform *ub, camera *c, VkExtent2D img_extent)
{
    c->view = camera_view_mat_init(c);
    c->camera = camera_buffer_init(c, img_extent);
    mat4s mats[2] = {c->view, c->camera};
    memcpy(ub->mapped, mats, sizeof(mats));
}

VkDescriptorPoolSize vk_desc_set_pool_size_init(VkDescriptorType type, uint32_t descriptor_count)
{
    VkDescriptorPoolSize size =
    {
        .type = type,
        .descriptorCount = descriptor_count
    };

    return size;
}

static VkDescriptorPoolCreateInfo vk_desc_set_pool_info_init(VkDescriptorPoolSize *size, uint32_t pool_count)
{
    VkDescriptorPoolCreateInfo pool_info =
    {
        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .maxSets = MAX_FRAMES_IN_FLIGHT,
        .poolSizeCount = pool_count,
        .pPoolSizes = size
    };

    return pool_info;
}

static VkDescriptorPool vk_desc_set_pool_init(vk_device *d, VkDescriptorPoolSize *size, uint32_t size_count)
{
    VkDescriptorPool pool = {0};

    VkDescriptorPoolCreateInfo pool_info = vk_desc_set_pool_info_init(size, size_count);

    if (vkCreateDescriptorPool(d->device, &pool_info, NULL, &pool) != VK_SUCCESS)
    {
        printf("Failed to create descriptor pool\n");
    }

    return pool;
}

static VkDescriptorSetAllocateInfo vk_desc_set_alloc_info_init(VkDescriptorPool pool, VkDescriptorSetLayout *layouts)
{
    VkDescriptorSetAllocateInfo alloc_info =
    {
        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
        .pNext = NULL,
        .descriptorPool = pool,
        .descriptorSetCount = MAX_FRAMES_IN_FLIGHT,
        .pSetLayouts = layouts
    };

    return alloc_info;
}

static VkDescriptorBufferInfo vk_desc_set_buffer_info_init(VkBuffer buffer, uint32_t offset, size_t size)
{
    VkDescriptorBufferInfo buffer_info =
    {
        .buffer = buffer,
        .offset = offset,
        .range = size
    };

    return buffer_info;
}

static VkWriteDescriptorSet vk_desc_set_write_info_init(VkDescriptorSet set, uint32_t binding, VkDescriptorType type, VkDescriptorBufferInfo *buffer_info)
{
    VkWriteDescriptorSet write_info =
    {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .pNext = NULL,
        .dstSet = set,
        .dstBinding = binding,
        .dstArrayElement = 0,
        .descriptorCount = 1,
        .descriptorType = type,
        .pImageInfo = NULL,
        .pBufferInfo = buffer_info,
        .pTexelBufferView = NULL
    };

    return write_info;
}

void vk_desc_compute_sets_init(vk_device *d, vk_desc_set *ds, vk_desc_set *galaxy)
{
    VkDescriptorSetLayout layouts[MAX_FRAMES_IN_FLIGHT] = {0};

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        layouts[i] = ds->layout;
        ds->compute_frustum[i] = vk_uniform_buffer_init(d, sizeof(vec4s) * 6);
        ds->compute_indirect_cmds[i] = vk_storage_buffer_init(d, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, sizeof(VkDrawIndirectCommand) * 6 * PARTICLE_COUNT);
        ds->compute_count[i] = vk_storage_buffer_init(d, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, sizeof(uint32_t) * PARTICLE_COUNT);
    }

    VkDescriptorSetAllocateInfo alloc_info = vk_desc_set_alloc_info_init(ds->pool, layouts);

    if (vkAllocateDescriptorSets(d->device, &alloc_info, ds->sets) != VK_SUCCESS)
    {
        printf("Failed to allocate compute descriptor sets\n");
    }

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        VkDescriptorBufferInfo uniform_info = vk_desc_set_buffer_info_init(ds->compute_frustum[i].b.buffer, 0, sizeof(vec4s) * 6);
        VkWriteDescriptorSet uniform_write_info = vk_desc_set_write_info_init(ds->sets[i], 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &uniform_info);

        VkDescriptorBufferInfo storage_info = vk_desc_set_buffer_info_init(galaxy->galaxy_particles[i].buffer, 0, VK_WHOLE_SIZE);
        VkWriteDescriptorSet storage_write_info = vk_desc_set_write_info_init(ds->sets[i], 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, &storage_info);

        VkDescriptorBufferInfo indirect_info = vk_desc_set_buffer_info_init(ds->compute_indirect_cmds[i].buffer, 0, VK_WHOLE_SIZE);
        VkWriteDescriptorSet indirect_write_info = vk_desc_set_write_info_init(ds->sets[i], 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, &indirect_info);

        VkDescriptorBufferInfo count_info = vk_desc_set_buffer_info_init(ds->compute_count[i].buffer, 0, VK_WHOLE_SIZE);
        VkWriteDescriptorSet count_write_info = vk_desc_set_write_info_init(ds->sets[i], 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, &count_info);

        VkWriteDescriptorSet desc_writes[4] = {uniform_write_info, storage_write_info, indirect_write_info, count_write_info};

        vkUpdateDescriptorSets(d->device, 4, desc_writes, 0, NULL);
    }
}

void vk_desc_graphics_sets_init(vk_device *d, vk_desc_set *ds)
{
    VkDescriptorSetLayout layouts[MAX_FRAMES_IN_FLIGHT] = {0};

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        layouts[i] = ds->layout;
        ds->graphics_camera[i] = vk_uniform_buffer_init(d, sizeof(mat4s));
    }

    VkDescriptorSetAllocateInfo alloc_info = vk_desc_set_alloc_info_init(ds->pool, layouts);

    if (vkAllocateDescriptorSets(d->device, &alloc_info, ds->sets) != VK_SUCCESS)
    {
        printf("Failed to allocate graphics descriptor sets\n");
    }

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        VkDescriptorBufferInfo uniform_info = vk_desc_set_buffer_info_init(ds->graphics_camera[i].b.buffer, 0, sizeof(mat4s));
        VkWriteDescriptorSet uniform_write_info = vk_desc_set_write_info_init(ds->sets[i], 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &uniform_info);

        vkUpdateDescriptorSets(d->device, 1, &uniform_write_info, 0, NULL);
    }
}

void vk_desc_galaxy_sets_init(vk_device *d, vk_desc_set *ds)
{
    VkDescriptorSetLayout layouts[MAX_FRAMES_IN_FLIGHT] = {0};

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        layouts[i] = ds->layout;
        ds->galaxy_camera[i] = vk_uniform_buffer_init(d, sizeof(galaxy_camera));
        ds->galaxy_particles[i] = vk_storage_buffer_init(d, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, sizeof(galaxy_particle) * PARTICLE_COUNT);
    }

    VkDescriptorSetAllocateInfo alloc_info = vk_desc_set_alloc_info_init(ds->pool, layouts);

    if (vkAllocateDescriptorSets(d->device, &alloc_info, ds->sets) != VK_SUCCESS)
    {
        printf("Failed to allocate galaxy descriptor sets\n");
    }

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        VkDescriptorBufferInfo uniform_info = vk_desc_set_buffer_info_init(ds->galaxy_camera[i].b.buffer, 0, sizeof(galaxy_camera));
        VkWriteDescriptorSet uniform_write_info = vk_desc_set_write_info_init(ds->sets[i], 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &uniform_info);

        VkDescriptorBufferInfo storage_info = vk_desc_set_buffer_info_init(ds->galaxy_particles[i].buffer, 0, VK_WHOLE_SIZE);
        VkWriteDescriptorSet storage_write_info = vk_desc_set_write_info_init(ds->sets[i], 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, &storage_info);

        VkWriteDescriptorSet desc_writes[2] = {uniform_write_info, storage_write_info};

        vkUpdateDescriptorSets(d->device, 2, desc_writes, 0, NULL);
    }
}

vk_desc_set vk_desc_set_init(vk_device *d, VkDescriptorSetLayoutBinding *binding, uint32_t binding_count, VkDescriptorPoolSize *size, uint32_t size_count)
{
    vk_desc_set ds =
    {
        .layout = vk_desc_set_layout_init(d, binding, binding_count),
        .pool = vk_desc_set_pool_init(d, size, size_count)
    };

    return ds;
}

static void vk_desc_set_layout_destroy(vk_device *d, VkDescriptorSetLayout layout)
{
    vkDestroyDescriptorSetLayout(d->device, layout, NULL);
}

static void vk_desc_set_pool_destroy(vk_device *d, VkDescriptorPool pool)
{
    vkDestroyDescriptorPool(d->device, pool, NULL);
}

void vk_desc_set_destroy(vk_device *d, vk_desc_set *ds)
{
   vk_desc_set_layout_destroy(d, ds->layout);
   vk_desc_set_pool_destroy(d, ds->pool);

    for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        vkDestroyBuffer(d->device, ds->compute_frustum[i].b.buffer, NULL);
        vkFreeMemory(d->device, ds->compute_frustum[i].b.memory, NULL);

        vkDestroyBuffer(d->device, ds->compute_indirect_cmds[i].buffer, NULL);
        vkFreeMemory(d->device, ds->compute_indirect_cmds[i].memory, NULL);

        vkDestroyBuffer(d->device, ds->compute_count[i].buffer, NULL);
        vkFreeMemory(d->device, ds->compute_count[i].memory, NULL);

        vkDestroyBuffer(d->device, ds->galaxy_particles[i].buffer, NULL);
        vkFreeMemory(d->device, ds->galaxy_particles[i].memory, NULL);

        vkDestroyBuffer(d->device, ds->graphics_camera[i].b.buffer, NULL);
        vkFreeMemory(d->device, ds->graphics_camera[i].b.memory, NULL);

        vkDestroyBuffer(d->device, ds->galaxy_camera[i].b.buffer, NULL);
        vkFreeMemory(d->device, ds->galaxy_camera[i].b.memory, NULL);
    }

   ds = NULL;
}