vertex_buffer.c File Reference

#include "vkpt.h"
#include "shader/vertex_buffer.h"
#include "material.h"
#include <assert.h>
#include <stdio.h>
#include "precomputed_sky.h"

Go to the source code of this file.

Classes
union	Bits

Functions
VkResult	vkpt_vertex_buffer_upload_staging ()
VkResult	vkpt_light_buffer_upload_staging (VkCommandBuffer cmd_buf)
VkResult	vkpt_vertex_buffer_upload_bsp_mesh_to_staging (bsp_mesh_t *bsp_mesh)
void	vkpt_light_buffer_reset_counts ()
void	inject_model_lights (bsp_mesh_t *bsp_mesh, bsp_t *bsp, int num_model_lights, light_poly_t *transformed_model_lights, int model_light_offset, uint32_t *dst_list_offsets, uint32_t *dst_lists)
static void	copy_light (const light_poly_t *light, float *vblight, const float *sky_radiance)
static uint16_t	floatToHalf (float value)
VkResult	vkpt_light_buffer_upload_to_staging (qboolean render_world, bsp_mesh_t *bsp_mesh, bsp_t *bsp, int num_model_lights, light_poly_t *transformed_model_lights, const float *sky_radiance)
VkResult	vkpt_vertex_buffer_upload_models_to_staging ()
VkResult	vkpt_vertex_buffer_create ()
VkResult	vkpt_readback (ReadbackBuffer *dst)
VkResult	vkpt_vertex_buffer_destroy ()
VkResult	vkpt_light_stats_create (bsp_mesh_t *bsp_mesh)
VkResult	vkpt_light_stats_destroy ()
VkResult	vkpt_vertex_buffer_create_pipelines ()
VkResult	vkpt_vertex_buffer_destroy_pipelines ()
VkResult	vkpt_vertex_buffer_create_instance (VkCommandBuffer cmd_buf, uint32_t num_instances, qboolean update_world_animations)

Variables
static VkDescriptorPool	desc_pool_vertex_buffer
static VkPipeline	pipeline_instance_geometry
static VkPipeline	pipeline_animate_materials
static VkPipelineLayout	pipeline_layout_instance_geometry
static int	local_light_counts [MAX_MAP_LEAFS]
static int	cluster_light_counts [MAX_MAP_LEAFS]
static int	light_list_tails [MAX_MAP_LEAFS]
static int	max_cluster_model_lights [MAX_MAP_LEAFS]
static int	max_model_lights
vkpt_refdef_t	vkpt_refdef
char	cluster_debug_mask [VIS_MAX_BYTES]

Function Documentation

copy_light()

static void copy_light ( const light_poly_t *  light, float *  vblight, const float *  sky_radiance  )

inlinestatic

Definition at line 215 of file vertex_buffer.c.

{
    float style_scale = 1.f;
    float prev_style = 1.f;
    if (light->style != 0 && vkpt_refdef.fd->lightstyles)
    {
        style_scale = vkpt_refdef.fd->lightstyles[light->style].white;
        style_scale = max(0, min(1, style_scale));
 
        prev_style = vkpt_refdef.prev_lightstyles[light->style].white;
        prev_style = max(0, min(1, prev_style));
    }
 
    float mat_scale = light->material ? light->material->emissive_scale : 1.f;
 
    VectorCopy(light->positions + 0, vblight + 0);
    VectorCopy(light->positions + 3, vblight + 4);
    VectorCopy(light->positions + 6, vblight + 8);
 
    if (light->color[0] < 0.f)
    {
        vblight[3] = -sky_radiance[0] * 0.5f;
        vblight[7] = -sky_radiance[1] * 0.5f;
        vblight[11] = -sky_radiance[2] * 0.5f;
    }
    else
    {
        vblight[3] = light->color[0] * mat_scale;
        vblight[7] = light->color[1] * mat_scale;
        vblight[11] = light->color[2] * mat_scale;
    }
 
    vblight[12] = style_scale;
    vblight[13] = prev_style;
    vblight[14] = 0.f;
    vblight[15] = 0.f;
}

Referenced by vkpt_light_buffer_upload_to_staging().

floatToHalf()

static uint16_t floatToHalf ( float  value )

static

Definition at line 265 of file vertex_buffer.c.

{
    static int const shift = 13;
    static int const shiftSign = 16;
 
    static int32_t const infN = 0x7F800000; // flt32 infinity
    static int32_t const maxN = 0x477FE000; // max flt16 normal as a flt32
    static int32_t const minN = 0x38800000; // min flt16 normal as a flt32
    static int32_t const signN = 0x80000000; // flt32 sign bit
 
    static int32_t const infC = 0x3FC00;
    static int32_t const nanN = 0x7F802000; // minimum flt16 nan as a flt32
    static int32_t const maxC = 0x23BFF;
    static int32_t const minC = 0x1C400;
    static int32_t const signC = 0x8000; // flt16 sign bit
 
    static int32_t const mulN = 0x52000000; // (1 << 23) / minN
    static int32_t const mulC = 0x33800000; // minN / (1 << (23 - shift))
 
    static int32_t const subC = 0x003FF; // max flt32 subnormal down shifted
    static int32_t const norC = 0x00400; // min flt32 normal down shifted
 
    static int32_t const maxD = 0x1C000;
    static int32_t const minD = 0x1C000;
 
    Bits v, s;
    v.f = value;
    uint32_t sign = v.si & signN;
    v.si ^= sign;
    sign >>= shiftSign; // logical shift
    s.si = mulN;
    s.si = s.f * v.f; // correct subnormals
    v.si ^= (s.si ^ v.si) & -(minN > v.si);
    v.si ^= (infN ^ v.si) & -((infN > v.si) & (v.si > maxN));
    v.si ^= (nanN ^ v.si) & -((nanN > v.si) & (v.si > infN));
    v.ui >>= shift; // logical shift
    v.si ^= ((v.si - maxD) ^ v.si) & -(v.si > maxC);
    v.si ^= ((v.si - minD) ^ v.si) & -(v.si > subC);
    return v.ui | sign;
}

Referenced by vkpt_light_buffer_upload_to_staging().

inject_model_lights()

void inject_model_lights	(	bsp_mesh_t *	bsp_mesh,
		bsp_t *	bsp,
		int	num_model_lights,
		light_poly_t *	transformed_model_lights,
		int	model_light_offset,
		uint32_t *	dst_list_offsets,
		uint32_t *	dst_lists
	)

Definition at line 138 of file vertex_buffer.c.

{
    memset(local_light_counts, 0, bsp_mesh->num_clusters * sizeof(int));
    memset(cluster_light_counts, 0, bsp_mesh->num_clusters * sizeof(int));
 
    // Count the number of model lights per cluster
 
    for (int nlight = 0; nlight < num_model_lights; nlight++)
    {
        local_light_counts[transformed_model_lights[nlight].cluster]++;
    }
 
    // Count the number of model lights visible from each cluster, using the PVS
 
    for (int c = 0; c < bsp_mesh->num_clusters; c++)
    {
        if (local_light_counts[c])
        {
            const char* mask = BSP_GetPvs(bsp, c);
 
            for (int j = 0; j < bsp->visrowsize; j++) {
                if (mask[j]) {
                    for (int k = 0; k < 8; ++k) {
                        if (mask[j] & (1 << k))
                            cluster_light_counts[j * 8 + k] += local_light_counts[c];
                    }
                }
            }
        }
    }
 
    // Update the max light counts per cluster
 
    for (int c = 0; c < bsp_mesh->num_clusters; c++)
    {
        max_cluster_model_lights[c] = max(max_cluster_model_lights[c], cluster_light_counts[c]);
    }
 
    // Copy the static light lists, and make room in these lists to inject the model lights
 
    int tail = 0;
    for (int c = 0; c < bsp_mesh->num_clusters; c++)
    {
        int original_size = bsp_mesh->cluster_light_offsets[c + 1] - bsp_mesh->cluster_light_offsets[c];
 
        dst_list_offsets[c] = tail;
        memcpy(dst_lists + tail, bsp_mesh->cluster_lights + bsp_mesh->cluster_light_offsets[c], sizeof(uint32_t) * original_size);
        tail += original_size;
        if (max_cluster_model_lights[c] > 0) {
            memset(dst_lists + tail, 0xff, sizeof(uint32_t) * max_cluster_model_lights[c]);
        }
        light_list_tails[c] = tail;
        tail += max_cluster_model_lights[c];
    }
    dst_list_offsets[bsp_mesh->num_clusters] = tail;
 
    // Write the model light indices into the light lists
 
    for (int nlight = 0; nlight < num_model_lights; nlight++)
    {
        const char* mask = BSP_GetPvs(bsp, transformed_model_lights[nlight].cluster);
 
        for (int j = 0; j < bsp->visrowsize; j++) {
            if (mask[j]) {
                for (int k = 0; k < 8; ++k) {
                    if (mask[j] & (1 << k))
                    {
                        int other_cluster = j * 8 + k;
                        dst_lists[light_list_tails[other_cluster]++] = model_light_offset + nlight;
                    }
                }
            }
        }
    }
}

Referenced by vkpt_light_buffer_upload_to_staging().

vkpt_light_buffer_reset_counts()

void vkpt_light_buffer_reset_counts

(

)

Definition at line 131 of file vertex_buffer.c.

{
    memset(max_cluster_model_lights, 0, sizeof(max_cluster_model_lights));
    max_model_lights = 0;
}

Referenced by R_BeginRegistration_RTX().

vkpt_light_buffer_upload_staging()

VkResult vkpt_light_buffer_upload_staging

(

VkCommandBuffer

cmd_buf

)

Definition at line 69 of file vertex_buffer.c.

{
    BufferResource_t* staging = qvk.buf_light_staging + qvk.current_frame_index;
 
    assert(!staging->is_mapped);
 
    VkBufferCopy copyRegion = {
        .size = sizeof(LightBuffer),
    };
    vkCmdCopyBuffer(cmd_buf, staging->buffer, qvk.buf_light.buffer, 1, &copyRegion);
 
    int buffer_idx = qvk.frame_counter % 3;
    if (qvk.buf_light_stats[buffer_idx].buffer)
    {
        vkCmdFillBuffer(cmd_buf, qvk.buf_light_stats[buffer_idx].buffer, 0, qvk.buf_light_stats[buffer_idx].size, 0);
    }
 
    return VK_SUCCESS;
}

Referenced by R_RenderFrame_RTX().

vkpt_light_buffer_upload_to_staging()

VkResult vkpt_light_buffer_upload_to_staging	(	qboolean	render_world,
		bsp_mesh_t *	bsp_mesh,
		bsp_t *	bsp,
		int	num_model_lights,
		light_poly_t *	transformed_model_lights,
		const float *	sky_radiance
	)

Definition at line 310 of file vertex_buffer.c.

{
    assert(bsp_mesh);
 
    BufferResource_t* staging = qvk.buf_light_staging + qvk.current_frame_index;
 
    LightBuffer *lbo = (LightBuffer *)buffer_map(staging);
    assert(lbo);
 
    if (render_world)
    {
        assert(bsp_mesh->num_clusters + 1 < MAX_LIGHT_LISTS);
        assert(bsp_mesh->num_cluster_lights < MAX_LIGHT_LIST_NODES);
        assert(MAT_GetNumPBRMaterials() < MAX_PBR_MATERIALS);
        assert(bsp_mesh->num_light_polys + num_model_lights < MAX_LIGHT_POLYS);
 
        int model_light_offset = bsp_mesh->num_light_polys;
        max_model_lights = max(max_model_lights, num_model_lights);
 
        if(max_model_lights > 0)
        {
            // If any of the BSP models contain lights, inject these lights right into the visibility lists.
            // The shader doesn't know that these lights are dynamic.
 
            inject_model_lights(bsp_mesh, bsp, num_model_lights, transformed_model_lights, model_light_offset, lbo->light_list_offsets, lbo->light_list_lights);
        }
        else
        {
            memcpy(lbo->light_list_offsets, bsp_mesh->cluster_light_offsets, (bsp_mesh->num_clusters + 1) * sizeof(uint32_t));
            memcpy(lbo->light_list_lights, bsp_mesh->cluster_lights, bsp_mesh->num_cluster_lights * sizeof(uint32_t));
        }
 
        for (int nlight = 0; nlight < bsp_mesh->num_light_polys; nlight++)
        {
            light_poly_t* light = bsp_mesh->light_polys + nlight;
            float* vblight = lbo->light_polys + nlight * (LIGHT_POLY_VEC4S * 4);
            copy_light(light, vblight, sky_radiance);
        }
 
        for (int nlight = 0; nlight < num_model_lights; nlight++)
        {
            light_poly_t* light = transformed_model_lights + nlight;
            float* vblight = lbo->light_polys + (nlight + model_light_offset) * (LIGHT_POLY_VEC4S * 4);
            copy_light(light, vblight, sky_radiance);
        }
    }
    else
    {
        lbo->light_list_offsets[0] = 0;
        lbo->light_list_offsets[1] = 0;
    }
 
    /* effects.c declares this - hence the assert below:
        typedef struct clightstyle_s {
            ...
            float   map[MAX_QPATH];
        } clightstyle_t;
    */
 
    assert(MAX_LIGHT_STYLES == MAX_QPATH);
    for (int nstyle = 0; nstyle < MAX_LIGHT_STYLES; nstyle++)
    {
        float style_scale = 1.f;
        if (vkpt_refdef.fd->lightstyles)
        {
            style_scale = vkpt_refdef.fd->lightstyles[nstyle].white;
            style_scale = max(0, min(1, style_scale));
        }
        lbo->light_styles[nstyle] = style_scale;
    }
 
    // materials
    int nmaterials = MAT_GetNumPBRMaterials();
    pbr_material_t const * materials = MAT_GetPBRMaterialsTable();
 
    for (int nmat = 0; nmat < nmaterials; nmat++)
    {
        pbr_material_t const * material = materials + nmat;
        uint32_t* mat_data = lbo->material_table + nmat * 4;
        memset(mat_data, 0, sizeof(uint32_t) * 4);
 
        if (material->image_diffuse) mat_data[0] |= (material->image_diffuse - r_images);
        if (material->image_normals) mat_data[0] |= (material->image_normals - r_images) << 16;
        if (material->image_emissive) mat_data[1] |= (material->image_emissive - r_images);
        mat_data[1] |= (material->num_frames & 0x000f) << 28;
        mat_data[1] |= (material->next_frame & 0x0fff) << 16;
 
        mat_data[2] = floatToHalf(material->bump_scale);
        mat_data[2] |= floatToHalf(material->rough_override) << 16;
        mat_data[3] = floatToHalf(material->specular_scale);
        mat_data[3] |= floatToHalf(material->emissive_scale) << 16;
    }
 
    memcpy(lbo->cluster_debug_mask, cluster_debug_mask, MAX_LIGHT_LISTS / 8);
 
    buffer_unmap(staging);
    lbo = NULL;
 
    return VK_SUCCESS;
}

Referenced by R_RenderFrame_RTX().

vkpt_light_stats_create()

VkResult vkpt_light_stats_create

(

bsp_mesh_t *

bsp_mesh

)

Definition at line 699 of file vertex_buffer.c.

{
    vkpt_light_stats_destroy();
 
    // Light statistics: 2 uints (shadowed, unshadowed) per light per surface orientation (6) per cluster.
    uint32_t num_stats = bsp_mesh->num_clusters * bsp_mesh->num_light_polys * 6 * 2;
 
    // Handle rare cases when the map has zero lights
    if (num_stats == 0)
        num_stats = 1;
 
    for (int frame = 0; frame < NUM_LIGHT_STATS_BUFFERS; frame++)
    {
        buffer_create(qvk.buf_light_stats + frame, sizeof(uint32_t) * num_stats,
            VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
    }
 
    assert(NUM_LIGHT_STATS_BUFFERS == 3);
 
    VkDescriptorBufferInfo light_stats_buf_info[] = { {
            .buffer = qvk.buf_light_stats[0].buffer,
            .offset = 0,
            .range = qvk.buf_light_stats[0].size,
        }, {
            .buffer = qvk.buf_light_stats[1].buffer,
            .offset = 0,
            .range = qvk.buf_light_stats[1].size,
        }, {
            .buffer = qvk.buf_light_stats[2].buffer,
            .offset = 0,
            .range = qvk.buf_light_stats[2].size,
        } };
 
    VkWriteDescriptorSet output_buf_write = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .dstSet = qvk.desc_set_vertex_buffer,
        .dstBinding = 6,
        .dstArrayElement = 0,
        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
        .descriptorCount = LENGTH(light_stats_buf_info),
        .pBufferInfo = light_stats_buf_info,
    };
 
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
    return VK_SUCCESS;
}

Referenced by R_BeginRegistration_RTX().

vkpt_light_stats_destroy()

VkResult vkpt_light_stats_destroy

(

)

Definition at line 748 of file vertex_buffer.c.

{
    for (int frame = 0; frame < NUM_LIGHT_STATS_BUFFERS; frame++)
    {
        buffer_destroy(qvk.buf_light_stats + frame);
    }
 
    return VK_SUCCESS;
}

Referenced by vkpt_destroy_all(), and vkpt_light_stats_create().

vkpt_readback()

VkResult vkpt_readback

(

ReadbackBuffer *

dst

)

Definition at line 659 of file vertex_buffer.c.

{
    BufferResource_t* buffer = &qvk.buf_readback_staging[qvk.current_frame_index];
    void* mapped = buffer_map(buffer);
 
    if (mapped == NULL)
        return VK_ERROR_MEMORY_MAP_FAILED;
 
    memcpy(dst, mapped, sizeof(ReadbackBuffer));
 
    buffer_unmap(buffer);
 
    return VK_SUCCESS;
}

Referenced by process_render_feedback().

vkpt_vertex_buffer_create()

VkResult vkpt_vertex_buffer_create

(

)

Definition at line 492 of file vertex_buffer.c.

{
    VkDescriptorSetLayoutBinding vbo_layout_bindings[] = {
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = 1,
            .binding = VERTEX_BUFFER_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        },
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = 1,
            .binding = LIGHT_BUFFER_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        },
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = 1,
            .binding = READBACK_BUFFER_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        },
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = 1,
            .binding = TONE_MAPPING_BUFFER_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        },
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = 1,
            .binding = SUN_COLOR_BUFFER_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        },
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .descriptorCount = 1,
            .binding = SUN_COLOR_UBO_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        },
        {
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .descriptorCount = 3,
            .binding = LIGHT_STATS_BUFFER_BINDING_IDX,
            .stageFlags = VK_SHADER_STAGE_ALL,
        }
    };
 
    VkDescriptorSetLayoutCreateInfo layout_info = {
        .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
        .bindingCount = LENGTH(vbo_layout_bindings),
        .pBindings    = vbo_layout_bindings,
    };
 
    _VK(vkCreateDescriptorSetLayout(qvk.device, &layout_info, NULL, &qvk.desc_set_layout_vertex_buffer));
 
    // Com_Printf("allocating %.02f MB of memory for vertex buffer\n", (double) sizeof(VertexBuffer) / (1024.0 * 1024.0));
    buffer_create(&qvk.buf_vertex, sizeof(VertexBuffer),
        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
    // Com_Printf("allocating %.02f MB of memory for staging vertex buffer\n", (double) sizeof(VertexBuffer) / (1024.0 * 1024.0));
    buffer_create(&qvk.buf_vertex_staging, sizeof(VertexBuffer),
        VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
 
    buffer_create(&qvk.buf_light, sizeof(LightBuffer),
        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
    for (int frame = 0; frame < MAX_FRAMES_IN_FLIGHT; frame++)
    {
        buffer_create(qvk.buf_light_staging + frame, sizeof(LightBuffer),
            VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
    }
 
    buffer_create(&qvk.buf_readback, sizeof(ReadbackBuffer),
        VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
    buffer_create(&qvk.buf_tonemap, sizeof(ToneMappingBuffer),
        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
    buffer_create(&qvk.buf_sun_color, sizeof(SunColorBuffer),
        VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
    for (int frame = 0; frame < MAX_FRAMES_IN_FLIGHT; frame++)
    {
        buffer_create(qvk.buf_readback_staging + frame, sizeof(ReadbackBuffer),
            VK_BUFFER_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
    }
 
    VkDescriptorPoolSize pool_size = {
        .type            = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
        .descriptorCount = LENGTH(vbo_layout_bindings),
    };
 
    VkDescriptorPoolCreateInfo pool_info = {
        .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
        .poolSizeCount = 1,
        .pPoolSizes    = &pool_size,
        .maxSets       = 1,
    };
 
    _VK(vkCreateDescriptorPool(qvk.device, &pool_info, NULL, &desc_pool_vertex_buffer));
 
    VkDescriptorSetAllocateInfo descriptor_set_alloc_info = {
        .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
        .descriptorPool     = desc_pool_vertex_buffer,
        .descriptorSetCount = 1,
        .pSetLayouts        = &qvk.desc_set_layout_vertex_buffer,
    };
 
    _VK(vkAllocateDescriptorSets(qvk.device, &descriptor_set_alloc_info, &qvk.desc_set_vertex_buffer));
 
    VkDescriptorBufferInfo buf_info = {
        .buffer = qvk.buf_vertex.buffer,
        .offset = 0,
        .range  = sizeof(VertexBuffer),
    };
 
    VkWriteDescriptorSet output_buf_write = {
        .sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .dstSet          = qvk.desc_set_vertex_buffer,
        .dstBinding      = 0,
        .dstArrayElement = 0,
        .descriptorType  = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
        .descriptorCount = 1,
        .pBufferInfo     = &buf_info,
    };
 
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
    output_buf_write.dstBinding = 1;
    buf_info.buffer = qvk.buf_light.buffer;
    buf_info.range = sizeof(LightBuffer);
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
    output_buf_write.dstBinding = 2;
    buf_info.buffer = qvk.buf_readback.buffer;
    buf_info.range = sizeof(ReadbackBuffer);
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
    output_buf_write.dstBinding = 3;
    buf_info.buffer = qvk.buf_tonemap.buffer;
    buf_info.range = sizeof(ToneMappingBuffer);
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
    output_buf_write.dstBinding = 4;
    buf_info.buffer = qvk.buf_sun_color.buffer;
    buf_info.range = sizeof(SunColorBuffer);
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
    output_buf_write.dstBinding = 5;
    output_buf_write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    buf_info.buffer = qvk.buf_sun_color.buffer;
    buf_info.range = sizeof(SunColorBuffer);
    vkUpdateDescriptorSets(qvk.device, 1, &output_buf_write, 0, NULL);
 
 
    return VK_SUCCESS;
}

vkpt_vertex_buffer_create_instance()

VkResult vkpt_vertex_buffer_create_instance	(	VkCommandBuffer	cmd_buf,
		uint32_t	num_instances,
		qboolean	update_world_animations
	)

Definition at line 818 of file vertex_buffer.c.

{
    VkDescriptorSet desc_sets[] = {
        qvk.desc_set_ubo,
        qvk.desc_set_vertex_buffer
    };
    vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_instance_geometry);
    vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE,
        pipeline_layout_instance_geometry, 0, LENGTH(desc_sets), desc_sets, 0, 0);
 
    vkCmdDispatch(cmd_buf, num_instances, 1, 1);
 
    if (update_world_animations)
    {
        vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_animate_materials);
 
        int num_groups = (((vkpt_refdef.bsp_mesh_world.world_idx_count + vkpt_refdef.bsp_mesh_world.world_transparent_count) / 3) + 255) / 256;
        vkCmdDispatch(cmd_buf, num_groups, 1, 1);
    }
 
    VkBufferMemoryBarrier barrier = {
        .sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
        .srcAccessMask       = VK_ACCESS_SHADER_WRITE_BIT,
        .dstAccessMask       = VK_ACCESS_SHADER_READ_BIT,
        .buffer              = qvk.buf_vertex.buffer,
        .size                = qvk.buf_vertex.size,
        .srcQueueFamilyIndex = qvk.queue_idx_graphics,
        .dstQueueFamilyIndex = qvk.queue_idx_graphics
    };
 
    vkCmdPipelineBarrier(
            cmd_buf,
            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
            0,
            0, NULL,
            1, &barrier,
            0, NULL);
 
    return VK_SUCCESS;
}

Referenced by R_RenderFrame_RTX().

vkpt_vertex_buffer_create_pipelines()

VkResult vkpt_vertex_buffer_create_pipelines

(

)

Definition at line 759 of file vertex_buffer.c.

{
    assert(!pipeline_instance_geometry);
    assert(!pipeline_animate_materials);
    assert(!pipeline_layout_instance_geometry);
 
    assert(qvk.desc_set_layout_ubo);
    assert(qvk.desc_set_layout_vertex_buffer); 
 
    VkDescriptorSetLayout desc_set_layouts[] = {
        qvk.desc_set_layout_ubo, qvk.desc_set_layout_vertex_buffer
    };
 
    CREATE_PIPELINE_LAYOUT(qvk.device, &pipeline_layout_instance_geometry, 
        .setLayoutCount         = LENGTH(desc_set_layouts),
        .pSetLayouts            = desc_set_layouts,
    );
 
    VkComputePipelineCreateInfo compute_pipeline_info[] = {
        {
            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
            .stage = SHADER_STAGE(QVK_MOD_INSTANCE_GEOMETRY_COMP, VK_SHADER_STAGE_COMPUTE_BIT),
            .layout = pipeline_layout_instance_geometry
        },
        {
            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
            .stage = SHADER_STAGE(QVK_MOD_ANIMATE_MATERIALS_COMP, VK_SHADER_STAGE_COMPUTE_BIT),
            .layout = pipeline_layout_instance_geometry
        },
    };
 
    VkPipeline pipelines[2];
    _VK(vkCreateComputePipelines(qvk.device, 0, LENGTH(compute_pipeline_info), compute_pipeline_info, 0, pipelines));
 
    pipeline_instance_geometry = pipelines[0];
    pipeline_animate_materials = pipelines[1];
 
    return VK_SUCCESS;
}

vkpt_vertex_buffer_destroy()

VkResult vkpt_vertex_buffer_destroy

(

)

Definition at line 675 of file vertex_buffer.c.

{
    vkDestroyDescriptorPool(qvk.device, desc_pool_vertex_buffer, NULL);
    vkDestroyDescriptorSetLayout(qvk.device, qvk.desc_set_layout_vertex_buffer, NULL);
    desc_pool_vertex_buffer = VK_NULL_HANDLE;
    qvk.desc_set_layout_vertex_buffer = VK_NULL_HANDLE;
 
    buffer_destroy(&qvk.buf_vertex);
    buffer_destroy(&qvk.buf_vertex_staging);
 
    buffer_destroy(&qvk.buf_light);
    buffer_destroy(&qvk.buf_readback);
    for (int frame = 0; frame < MAX_FRAMES_IN_FLIGHT; frame++)
    {
        buffer_destroy(qvk.buf_light_staging + frame);
        buffer_destroy(qvk.buf_readback_staging + frame);
    }
 
    buffer_destroy(&qvk.buf_tonemap);
    buffer_destroy(&qvk.buf_sun_color);
 
    return VK_SUCCESS;
}

vkpt_vertex_buffer_destroy_pipelines()

VkResult vkpt_vertex_buffer_destroy_pipelines

(

)

Definition at line 800 of file vertex_buffer.c.

{
    assert(pipeline_instance_geometry);
    assert(pipeline_animate_materials);
    assert(pipeline_layout_instance_geometry);
 
    vkDestroyPipeline(qvk.device, pipeline_instance_geometry, NULL);
    vkDestroyPipeline(qvk.device, pipeline_animate_materials, NULL);
    vkDestroyPipelineLayout(qvk.device, pipeline_layout_instance_geometry, NULL);
 
    pipeline_instance_geometry = VK_NULL_HANDLE;
    pipeline_animate_materials = VK_NULL_HANDLE;
    pipeline_layout_instance_geometry = VK_NULL_HANDLE;
 
    return VK_SUCCESS;
}

vkpt_vertex_buffer_upload_bsp_mesh_to_staging()

VkResult vkpt_vertex_buffer_upload_bsp_mesh_to_staging

(

bsp_mesh_t *

bsp_mesh

)

Definition at line 90 of file vertex_buffer.c.

{
    assert(bsp_mesh);
    VertexBuffer *vbo = (VertexBuffer *) buffer_map(&qvk.buf_vertex_staging);
    assert(vbo);
 
    int num_vertices = bsp_mesh->num_vertices;
    if (num_vertices > MAX_VERT_BSP)
    {
        assert(!"Vertex buffer overflow");
        num_vertices = MAX_VERT_BSP;
    }
 
    memcpy(vbo->positions_bsp,  bsp_mesh->positions, num_vertices * sizeof(float) * 3   );
    memcpy(vbo->tex_coords_bsp, bsp_mesh->tex_coords,num_vertices * sizeof(float) * 2   );
    memcpy(vbo->tangents_bsp,   bsp_mesh->tangents,  num_vertices * sizeof(float));
    memcpy(vbo->materials_bsp,  bsp_mesh->materials, num_vertices * sizeof(uint32_t) / 3);
    memcpy(vbo->clusters_bsp, bsp_mesh->clusters, num_vertices * sizeof(uint32_t) / 3);
    memcpy(vbo->texel_density_bsp, bsp_mesh->texel_density, num_vertices * sizeof(float) / 3);
 
    int num_clusters = bsp_mesh->num_clusters;
    if (num_clusters > MAX_LIGHT_LISTS)
    {
        assert(!"Visibility buffer overflow");
        num_clusters = MAX_LIGHT_LISTS;
    }
 
    memcpy(vbo->sky_visibility, bsp_mesh->sky_visibility, (num_clusters + 7) / 8);
 
    buffer_unmap(&qvk.buf_vertex_staging);
    vbo = NULL;
 
    return VK_SUCCESS;
}

Referenced by R_BeginRegistration_RTX().

vkpt_vertex_buffer_upload_models_to_staging()

VkResult vkpt_vertex_buffer_upload_models_to_staging

(

)

Definition at line 412 of file vertex_buffer.c.

{
    VertexBuffer *vbo = (VertexBuffer *) buffer_map(&qvk.buf_vertex_staging);
    assert(vbo);
 
    int idx_offset = 0;
    int vertex_offset = 0;
    for(int i = 0; i < MAX_MODELS; i++) {
        if(!r_models[i].meshes) {
            continue;
        }
 
        for (int nmesh = 0; nmesh < r_models[i].nummeshes; nmesh++)
        {
            maliasmesh_t *m = r_models[i].meshes + nmesh;
 
            m->idx_offset = idx_offset;
            m->vertex_offset = vertex_offset;
 
            assert(r_models[i].numframes > 0);
 
            int num_verts = r_models[i].numframes * m->numverts;
            assert(num_verts > 0);
#if 0
            for (int j = 0; j < num_verts; j++)
                Com_Printf("%f %f %f\n",
                    m->positions[j][0],
                    m->positions[j][1],
                    m->positions[j][2]);
 
            for (int j = 0; j < m->numtris; j++)
                Com_Printf("%d %d %d\n",
                    m->indices[j * 3 + 0],
                    m->indices[j * 3 + 1],
                    m->indices[j * 3 + 2]);
#endif
 
#if 0
            char buf[1024];
            snprintf(buf, sizeof buf, "model_%04d.obj", i);
            FILE *f = fopen(buf, "wb+");
            assert(f);
            for (int j = 0; j < m->numverts; j++) {
                fprintf(f, "v %f %f %f\n",
                    m->positions[j][0],
                    m->positions[j][1],
                    m->positions[j][2]);
            }
            for (int j = 0; j < m->numindices / 3; j++) {
                fprintf(f, "f %d %d %d\n",
                    m->indices[j * 3 + 0] + 1,
                    m->indices[j * 3 + 1] + 1,
                    m->indices[j * 3 + 2] + 1);
            }
            fclose(f);
#endif
 
            memcpy(vbo->positions_model + vertex_offset * 3, m->positions, sizeof(float) * 3 * num_verts);
            memcpy(vbo->normals_model + vertex_offset * 3, m->normals, sizeof(float) * 3 * num_verts);
            memcpy(vbo->tex_coords_model + vertex_offset * 2, m->tex_coords, sizeof(float) * 2 * num_verts);
            memcpy(vbo->tangents_model + vertex_offset * 4, m->tangents, sizeof(float) * 4 * num_verts);
            memcpy(vbo->idx_model + idx_offset, m->indices, sizeof(uint32_t) * m->numindices);
 
            vertex_offset += num_verts;
            idx_offset += m->numtris * 3;
 
            assert(vertex_offset < MAX_VERT_MODEL);
            assert(idx_offset < MAX_IDX_MODEL);
        }
    }
 
    buffer_unmap(&qvk.buf_vertex_staging);
    vbo = NULL;
 
    // Com_Printf("uploaded %d vert, %d idx\n", vertex_offset, idx_offset);
 
    return VK_SUCCESS;
}

Referenced by R_BeginFrame_RTX().

vkpt_vertex_buffer_upload_staging()

VkResult vkpt_vertex_buffer_upload_staging

(

)

Definition at line 36 of file vertex_buffer.c.

{
    vkWaitForFences(qvk.device, 1, &qvk.fence_vertex_sync, VK_TRUE, ~((uint64_t)0));
    vkResetFences(qvk.device, 1, &qvk.fence_vertex_sync);
    
    VkCommandBuffer cmd_buf = vkpt_begin_command_buffer(&qvk.cmd_buffers_graphics);
 
    VkBufferCopy copyRegion = {
        .size = sizeof(VertexBuffer),
    };
    vkCmdCopyBuffer(cmd_buf, qvk.buf_vertex_staging.buffer, qvk.buf_vertex.buffer, 1, &copyRegion);
 
    BUFFER_BARRIER(cmd_buf,
        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
        .buffer = qvk.buf_vertex.buffer,
        .offset = 0,
        .size = VK_WHOLE_SIZE,
    );
 
    if (qvk.buf_light_stats[0].buffer)
    {
        vkCmdFillBuffer(cmd_buf, qvk.buf_light_stats[0].buffer, 0, qvk.buf_light_stats[0].size, 0);
        vkCmdFillBuffer(cmd_buf, qvk.buf_light_stats[1].buffer, 0, qvk.buf_light_stats[1].size, 0);
        vkCmdFillBuffer(cmd_buf, qvk.buf_light_stats[2].buffer, 0, qvk.buf_light_stats[2].size, 0);
    }
 
    vkpt_submit_command_buffer(cmd_buf, qvk.queue_graphics, (1 << qvk.device_count) - 1, 0, NULL, NULL, NULL, 0, NULL, NULL, qvk.fence_vertex_sync);
 
    return VK_SUCCESS;
}

Referenced by R_BeginFrame_RTX(), and R_BeginRegistration_RTX().

Variable Documentation

cluster_debug_mask

char cluster_debug_mask[VIS_MAX_BYTES]

Definition at line 83 of file main.c.

Referenced by R_BeginRegistration_RTX(), vkpt_light_buffer_upload_to_staging(), and vkpt_show_pvs().

cluster_light_counts

int cluster_light_counts[MAX_MAP_LEAFS]

static

Definition at line 126 of file vertex_buffer.c.

Referenced by collect_cluster_lights(), and inject_model_lights().

desc_pool_vertex_buffer

VkDescriptorPool desc_pool_vertex_buffer

static

Definition at line 30 of file vertex_buffer.c.

Referenced by vkpt_vertex_buffer_create(), and vkpt_vertex_buffer_destroy().

light_list_tails

int light_list_tails[MAX_MAP_LEAFS]

static

Definition at line 127 of file vertex_buffer.c.

Referenced by inject_model_lights().

local_light_counts

int local_light_counts[MAX_MAP_LEAFS]

static

Definition at line 125 of file vertex_buffer.c.

Referenced by inject_model_lights().

max_cluster_model_lights

int max_cluster_model_lights[MAX_MAP_LEAFS]

static

Definition at line 128 of file vertex_buffer.c.

Referenced by inject_model_lights(), and vkpt_light_buffer_reset_counts().

max_model_lights

int max_model_lights

static

Definition at line 129 of file vertex_buffer.c.

Referenced by vkpt_light_buffer_reset_counts(), and vkpt_light_buffer_upload_to_staging().

pipeline_animate_materials

VkPipeline pipeline_animate_materials

static

Definition at line 32 of file vertex_buffer.c.

Referenced by vkpt_vertex_buffer_create_instance(), vkpt_vertex_buffer_create_pipelines(), and vkpt_vertex_buffer_destroy_pipelines().

pipeline_instance_geometry

VkPipeline pipeline_instance_geometry

static

Definition at line 31 of file vertex_buffer.c.

Referenced by vkpt_vertex_buffer_create_instance(), vkpt_vertex_buffer_create_pipelines(), and vkpt_vertex_buffer_destroy_pipelines().

pipeline_layout_instance_geometry

VkPipelineLayout pipeline_layout_instance_geometry

static

Definition at line 33 of file vertex_buffer.c.

Referenced by vkpt_vertex_buffer_create_instance(), vkpt_vertex_buffer_create_pipelines(), and vkpt_vertex_buffer_destroy_pipelines().

vkpt_refdef

vkpt_refdef_t vkpt_refdef

Definition at line 372 of file main.c.

Referenced by copy_light(), vkpt_light_buffer_upload_to_staging(), and vkpt_vertex_buffer_create_instance().