transparency.c File Reference

#include "shared/shared.h"
#include "vkpt.h"
#include "vk_util.h"

Go to the source code of this file.

Macros
#define	TR_PARTICLE_MAX_NUM   MAX_PARTICLES
#define	TR_BEAM_MAX_NUM   MAX_ENTITIES
#define	TR_SPRITE_MAX_NUM   MAX_ENTITIES
#define	TR_VERTEX_MAX_NUM   (TR_PARTICLE_MAX_NUM + TR_BEAM_MAX_NUM + TR_SPRITE_MAX_NUM) * 4
#define	TR_INDEX_MAX_NUM   (TR_PARTICLE_MAX_NUM + TR_BEAM_MAX_NUM + TR_SPRITE_MAX_NUM) * 6
#define	TR_POSITION_SIZE   3 * sizeof(float)
#define	TR_COLOR_SIZE   4 * sizeof(float)
#define	TR_SPRITE_INFO_SIZE   2 * sizeof(float)
#define	TR_BLAS_BUILD_FLAGS
#define	MAX_BEAMS   64

Functions
static void	create_buffers ()
static void	create_blas ()
static void	allocate_and_bind_memory_to_blas ()
static qboolean	allocate_and_bind_memory_to_buffers ()
static void	create_buffer_views ()
static void	fill_index_buffer ()
static void	write_particle_geometry (const float *view_matrix, const particle_t *particles, int particle_num)
static void	write_beam_geometry (const float *view_matrix, const entity_t *entities, int entity_num)
static void	write_sprite_geometry (const float *view_matrix, const entity_t *entities, int entity_num)
static void	upload_geometry (VkCommandBuffer command_buffer)
static void	update_particle_blas (VkCommandBuffer command_buffer)
static void	update_beam_blas (VkCommandBuffer command_buffer)
static void	update_sprite_blas (VkCommandBuffer command_buffer)
void	cast_u32_to_f32_color (int color_index, const color_t *pcolor, float *color_f32, float hdr_factor)
qboolean	initialize_transparency ()
void	destroy_transparency ()
void	update_transparency (VkCommandBuffer command_buffer, const float *view_matrix, const particle_t *particles, int particle_num, const entity_t *entities, int entity_num)
void	build_transparency_blas (VkCommandBuffer cmd_buf)
VkAccelerationStructureNV	get_transparency_particle_blas ()
VkAccelerationStructureNV	get_transparency_beam_blas ()
VkAccelerationStructureNV	get_transparency_sprite_blas ()
VkBufferView	get_transparency_particle_color_buffer_view ()
VkBufferView	get_transparency_beam_color_buffer_view ()
VkBufferView	get_transparency_sprite_info_buffer_view ()
void	get_transparency_counts (int *particle_num, int *beam_num, int *sprite_num)
static int	compare_beams (const void *_a, const void *_b)
qboolean	vkpt_build_cylinder_light (light_poly_t *light_list, int *num_lights, int max_lights, bsp_t *bsp, vec3_t begin, vec3_t end, vec3_t color, float radius)
void	vkpt_build_beam_lights (light_poly_t *light_list, int *num_lights, int max_lights, bsp_t *bsp, entity_t *entities, int num_entites, float adapted_luminance)
static size_t	calculate_scratch_buffer_size (VkAccelerationStructureNV blas)

Variables
struct {
size_t   vertex_position_host_offset
size_t   particle_color_host_offset
size_t   beam_color_host_offset
size_t   sprite_info_host_offset
size_t   beam_scratch_device_offset
size_t   beam_vertex_device_offset
size_t   sprite_scratch_device_offset
size_t   sprite_vertex_device_offset
size_t   host_buffer_size
size_t   host_frame_size
unsigned int   particle_num
unsigned int   beam_num
unsigned int   sprite_num
unsigned int   blas_beam_num
unsigned int   blas_particle_num
unsigned int   blas_sprite_num
unsigned int   host_frame_index
unsigned int   host_buffered_frame_num
char *   mapped_host_buffer
VkAccelerationStructureNV   particle_blas
VkAccelerationStructureNV   beam_blas
VkAccelerationStructureNV   sprite_blas
VkBuffer   host_buffer
VkBuffer   scratch_buffer
VkBuffer   vertex_buffer
VkBuffer   index_buffer
VkBuffer   particle_color_buffer
VkBuffer   beam_color_buffer
VkBuffer   sprite_info_buffer
VkDeviceMemory   host_buffer_memory
VkDeviceMemory   device_buffer_memory
VkDeviceMemory   device_blas_memory
VkBufferView   particle_color_buffer_view
VkBufferView   beam_color_buffer_view
VkBufferView   sprite_info_buffer_view
VkBufferMemoryBarrier   transfer_barriers [4]
}	transparency
cvar_t *	cvar_pt_particle_size = NULL
cvar_t *	cvar_pt_beam_width = NULL
cvar_t *	cvar_pt_beam_lights = NULL
cvar_t *	cvar_pt_enable_particles
cvar_t *	cvar_pt_particle_emissive
cvar_t *	cvar_pt_projection

Macro Definition Documentation

MAX_BEAMS

#define MAX_BEAMS   64

Definition at line 386 of file transparency.c.

TR_BEAM_MAX_NUM

#define TR_BEAM_MAX_NUM   MAX_ENTITIES

Definition at line 24 of file transparency.c.

TR_BLAS_BUILD_FLAGS

#define TR_BLAS_BUILD_FLAGS

Value:

                               VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV | \
                               VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV

Definition at line 32 of file transparency.c.

TR_COLOR_SIZE

#define TR_COLOR_SIZE   4 * sizeof(float)

Definition at line 29 of file transparency.c.

TR_INDEX_MAX_NUM

#define TR_INDEX_MAX_NUM   (TR_PARTICLE_MAX_NUM + TR_BEAM_MAX_NUM + TR_SPRITE_MAX_NUM) * 6

Definition at line 27 of file transparency.c.

TR_PARTICLE_MAX_NUM

#define TR_PARTICLE_MAX_NUM   MAX_PARTICLES

Definition at line 23 of file transparency.c.

TR_POSITION_SIZE

#define TR_POSITION_SIZE   3 * sizeof(float)

Definition at line 28 of file transparency.c.

TR_SPRITE_INFO_SIZE

#define TR_SPRITE_INFO_SIZE   2 * sizeof(float)

Definition at line 30 of file transparency.c.

TR_SPRITE_MAX_NUM

#define TR_SPRITE_MAX_NUM   MAX_ENTITIES

Definition at line 25 of file transparency.c.

TR_VERTEX_MAX_NUM

#define TR_VERTEX_MAX_NUM   (TR_PARTICLE_MAX_NUM + TR_BEAM_MAX_NUM + TR_SPRITE_MAX_NUM) * 4

Definition at line 26 of file transparency.c.

Function Documentation

allocate_and_bind_memory_to_blas()

static void allocate_and_bind_memory_to_blas ( )

static

Definition at line 1075 of file transparency.c.

{
    const VkAccelerationStructureMemoryRequirementsInfoNV blas_requirements_info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
        .type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
        .accelerationStructure = transparency.particle_blas
    };
 
    VkMemoryRequirements2 blas_memory_requirements = { 0 };
    blas_memory_requirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
    qvkGetAccelerationStructureMemoryRequirementsNV(qvk.device, &blas_requirements_info,
        &blas_memory_requirements);
 
    VkMemoryRequirements mem_req = blas_memory_requirements.memoryRequirements;
    size_t beam_memory_offset = align(mem_req.size, mem_req.alignment);
    mem_req.size += beam_memory_offset;
 
    size_t sprite_memory_offset = align(mem_req.size, mem_req.alignment);
    mem_req.size += sprite_memory_offset;
 
    _VK(allocate_gpu_memory(mem_req, &transparency.device_blas_memory));
 
    VkBindAccelerationStructureMemoryInfoNV bindings[3] = { 0 };
 
    bindings[0].sType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV;
    bindings[0].accelerationStructure = transparency.particle_blas;
    bindings[0].memory = transparency.device_blas_memory;
    bindings[1].sType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV;
    bindings[1].accelerationStructure = transparency.beam_blas;
    bindings[1].memory = transparency.device_blas_memory;
    bindings[1].memoryOffset = beam_memory_offset;
    bindings[2].sType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV;
    bindings[2].accelerationStructure = transparency.sprite_blas;
    bindings[2].memory = transparency.device_blas_memory;
    bindings[2].memoryOffset = sprite_memory_offset;
 
    _VK(qvkBindAccelerationStructureMemoryNV(qvk.device, LENGTH(bindings), bindings));
}

Referenced by initialize_transparency().

allocate_and_bind_memory_to_buffers()

static qboolean allocate_and_bind_memory_to_buffers ( )

static

Definition at line 932 of file transparency.c.

{
    // host buffer
 
    VkMemoryRequirements host_buffer_requirements;
    vkGetBufferMemoryRequirements(qvk.device, transparency.host_buffer, &host_buffer_requirements);
 
    const VkMemoryPropertyFlags host_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 
    const uint32_t host_memory_type = get_memory_type(host_buffer_requirements.memoryTypeBits, host_flags);
 
    const VkMemoryAllocateInfo host_memory_allocate_info = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .allocationSize = host_buffer_requirements.size,
        .memoryTypeIndex = host_memory_type
    };
 
    _VK(vkAllocateMemory(qvk.device, &host_memory_allocate_info, NULL, &transparency.host_buffer_memory));
 
    // device buffers
 
    const VkBuffer device_buffers[] = {
        transparency.scratch_buffer,
        transparency.vertex_buffer,
        transparency.index_buffer,
        transparency.particle_color_buffer,
        transparency.beam_color_buffer,
        transparency.sprite_info_buffer
    };
 
    const VkMemoryPropertyFlags device_flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    uint32_t memory_types[LENGTH(device_buffers)];
    VkMemoryRequirements requirements[LENGTH(device_buffers)];
 
    VkMemoryAllocateInfo memory_allocate_info = { .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
 
    for (size_t i = 0; i < LENGTH(device_buffers); i++)
    {
        vkGetBufferMemoryRequirements(qvk.device, device_buffers[i], &requirements[i]);
        memory_types[i] = get_memory_type(requirements[i].memoryTypeBits, device_flags);
        memory_allocate_info.allocationSize += requirements[i].size + ((i == 0) ? 0 : requirements[i].alignment);
    }
 
    // If the buffers need different memory types, the code that does allocation and binding must be changed
    for (size_t i = 1; i < LENGTH(device_buffers); i++)
    {
        if (memory_types[i] != memory_types[0])
            return qfalse;
    }
 
    memory_allocate_info.memoryTypeIndex = memory_types[0];
 
 
#ifdef VKPT_DEVICE_GROUPS
    VkMemoryAllocateFlagsInfoKHR mem_alloc_flags = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR,
        .flags = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR,
        .deviceMask = (1 << qvk.device_count) - 1
    };
 
    if (qvk.device_count > 1) {
        memory_allocate_info.pNext = &mem_alloc_flags;
    }
#endif
 
    _VK(vkAllocateMemory(qvk.device, &memory_allocate_info, NULL, &transparency.device_buffer_memory));
 
    // bind device buffers and a host buffer
    VkBindBufferMemoryInfo bindings[LENGTH(device_buffers) + 1] = { 0 };
 
    bindings[0].sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
    bindings[0].buffer = transparency.host_buffer;
    bindings[0].memory = transparency.host_buffer_memory;
    bindings[0].memoryOffset = 0;
 
    size_t offset = 0;
    for (size_t i = 0; i < LENGTH(device_buffers); i++)
    {
        VkBindBufferMemoryInfo* binding = bindings + i + 1;
 
        binding->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
        binding->buffer = device_buffers[i];
        binding->memory = transparency.device_buffer_memory;
 
        offset = align(offset, requirements[i].alignment);
        binding->memoryOffset = offset;
        offset += requirements[i].size;
    }
 
    _VK(vkBindBufferMemory2(qvk.device, LENGTH(bindings), bindings));
 
    const size_t host_buffer_size = transparency.host_buffered_frame_num * transparency.host_frame_size;
 
    _VK(vkMapMemory(qvk.device, transparency.host_buffer_memory, 0, host_buffer_size, 0,
        &transparency.mapped_host_buffer));
 
    return qtrue;
}

Referenced by initialize_transparency().

build_transparency_blas()

void build_transparency_blas

(

VkCommandBuffer

cmd_buf

)

Definition at line 217 of file transparency.c.

{
    update_particle_blas(cmd_buf);
    update_beam_blas(cmd_buf);
    update_sprite_blas(cmd_buf);
 
    // No barrier here because a single barrier is used later in the pipeline, after building all the BLAS-es
}

Referenced by R_RenderFrame_RTX().

calculate_scratch_buffer_size()

static size_t calculate_scratch_buffer_size ( VkAccelerationStructureNV  blas )

static

Definition at line 846 of file transparency.c.

{
    VkAccelerationStructureMemoryRequirementsInfoNV scratch_requirements_info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
        .type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
        .accelerationStructure = blas
    };
 
    VkMemoryRequirements2 build_memory_requirements = { 0 };
    build_memory_requirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
    qvkGetAccelerationStructureMemoryRequirementsNV(qvk.device, &scratch_requirements_info,
        &build_memory_requirements);
 
    scratch_requirements_info.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV;
 
    VkMemoryRequirements2 update_memory_requirements = { 0 };
    update_memory_requirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
    qvkGetAccelerationStructureMemoryRequirementsNV(qvk.device, &scratch_requirements_info,
        &update_memory_requirements);
 
    const uint64_t build_size = build_memory_requirements.memoryRequirements.size;
    const uint64_t update_size = update_memory_requirements.memoryRequirements.size;
 
    return max(build_size, update_size);
}

Referenced by create_buffers().

cast_u32_to_f32_color()

void cast_u32_to_f32_color	(	int	color_index,
		const color_t *	pcolor,
		float *	color_f32,
		float	hdr_factor
	)

Definition at line 102 of file transparency.c.

{
    color_t color;
    if (color_index < 0)
        color.u32 = pcolor->u32;
    else
        color.u32 = d_8to24table[color_index & 0xff];
 
    for (int i = 0; i < 3; i++)
        color_f32[i] = hdr_factor * ((float)color.u8[i] / 255.0);
}

Referenced by vkpt_build_beam_lights(), write_beam_geometry(), and write_particle_geometry().

compare_beams()

static int compare_beams ( const void *  _a, const void *  _b  )

static

Definition at line 388 of file transparency.c.

{
    const entity_t* a = *(void**)_a;
    const entity_t* b = *(void**)_b;
 
    if (a->origin[0] < b->origin[0]) return -1;
    if (a->origin[0] > b->origin[0]) return 1;
    if (a->origin[1] < b->origin[1]) return -1;
    if (a->origin[1] > b->origin[1]) return 1;
    if (a->origin[2] < b->origin[2]) return -1;
    if (a->origin[2] > b->origin[2]) return 1;
    if (a->oldorigin[0] < b->oldorigin[0]) return -1;
    if (a->oldorigin[0] > b->oldorigin[0]) return 1;
    if (a->oldorigin[1] < b->oldorigin[1]) return -1;
    if (a->oldorigin[1] > b->oldorigin[1]) return 1;
    if (a->oldorigin[2] < b->oldorigin[2]) return -1;
    if (a->oldorigin[2] > b->oldorigin[2]) return 1;
    return 0;
}

Referenced by vkpt_build_beam_lights().

create_blas()

static void create_blas ( )

static

Definition at line 1032 of file transparency.c.

{
    const VkGeometryTrianglesNV geometry_triangles = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
        .vertexCount = TR_VERTEX_MAX_NUM,
        .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
        .indexCount = TR_INDEX_MAX_NUM,
        .indexType = VK_INDEX_TYPE_UINT16
    };
 
    const VkGeometryAABBNV geometry_aabbs = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
    };
 
    const VkGeometryDataNV geometry_data = {
        .triangles = geometry_triangles,
        .aabbs = geometry_aabbs
    };
 
    const VkGeometryNV geometry = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_NV,
        .geometryType = VK_GEOMETRY_TYPE_TRIANGLES_NV,
        .geometry = geometry_data
    };
 
    const VkAccelerationStructureInfoNV info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
        .type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
        .flags = TR_BLAS_BUILD_FLAGS,
        .geometryCount = 1,
        .pGeometries = &geometry
    };
 
    const VkAccelerationStructureCreateInfoNV blas_info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
        .info = info
    };
 
    _VK(qvkCreateAccelerationStructureNV(qvk.device, &blas_info, NULL, &transparency.particle_blas));
    _VK(qvkCreateAccelerationStructureNV(qvk.device, &blas_info, NULL, &transparency.beam_blas));
    _VK(qvkCreateAccelerationStructureNV(qvk.device, &blas_info, NULL, &transparency.sprite_blas));
}

Referenced by initialize_transparency().

create_buffer_views()

static void create_buffer_views ( )

static

Definition at line 1114 of file transparency.c.

{
    const VkBufferViewCreateInfo particle_color_view_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
        .buffer = transparency.particle_color_buffer,
        .format = VK_FORMAT_R32G32B32A32_SFLOAT,
        .range = TR_PARTICLE_MAX_NUM * TR_COLOR_SIZE
    };
 
    const VkBufferViewCreateInfo beam_color_view_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
        .buffer = transparency.beam_color_buffer,
        .format = VK_FORMAT_R32G32B32A32_SFLOAT,
        .range = TR_BEAM_MAX_NUM * TR_COLOR_SIZE
    };
 
    const VkBufferViewCreateInfo sprite_info_view_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
        .buffer = transparency.sprite_info_buffer,
        .format = VK_FORMAT_R32G32_UINT,
        .range = TR_SPRITE_MAX_NUM * TR_SPRITE_INFO_SIZE
    };
 
    _VK(vkCreateBufferView(qvk.device, &particle_color_view_info, NULL,
        &transparency.particle_color_buffer_view));
 
    _VK(vkCreateBufferView(qvk.device, &beam_color_view_info, NULL,
        &transparency.beam_color_buffer_view));
 
    _VK(vkCreateBufferView(qvk.device, &sprite_info_view_info, NULL,
        &transparency.sprite_info_buffer_view));
}

Referenced by initialize_transparency().

create_buffers()

static void create_buffers ( )

static

Definition at line 872 of file transparency.c.

{
    const uint64_t particle_scratch_size = calculate_scratch_buffer_size(transparency.particle_blas);
    const uint64_t beam_scratch_size = calculate_scratch_buffer_size(transparency.beam_blas);
    const uint64_t sprite_scratch_size = calculate_scratch_buffer_size(transparency.sprite_blas);
 
    transparency.beam_scratch_device_offset = particle_scratch_size;
    transparency.sprite_scratch_device_offset = transparency.beam_scratch_device_offset + beam_scratch_size;
 
    const VkBufferCreateInfo host_buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = transparency.host_buffered_frame_num * transparency.host_frame_size,
        .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT
    };
 
    const VkBufferCreateInfo scratch_buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = particle_scratch_size + beam_scratch_size + sprite_scratch_size,
        .usage = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV
    };
 
    const VkBufferCreateInfo buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = transparency.host_frame_size,
        .usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT
    };
 
    const VkBufferCreateInfo index_buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = TR_INDEX_MAX_NUM * sizeof(uint16_t),
        .usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT
    };
 
    const VkBufferCreateInfo particle_color_buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = TR_PARTICLE_MAX_NUM * TR_COLOR_SIZE,
        .usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT
    };
 
    const VkBufferCreateInfo beam_color_buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = TR_BEAM_MAX_NUM * TR_COLOR_SIZE,
        .usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT
    };
 
    const VkBufferCreateInfo sprite_info_buffer_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = TR_SPRITE_MAX_NUM * TR_SPRITE_INFO_SIZE,
        .usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT
    };
 
    _VK(vkCreateBuffer(qvk.device, &host_buffer_info, NULL, &transparency.host_buffer));
    _VK(vkCreateBuffer(qvk.device, &scratch_buffer_info, NULL, &transparency.scratch_buffer));
    _VK(vkCreateBuffer(qvk.device, &buffer_info, NULL, &transparency.vertex_buffer));
    _VK(vkCreateBuffer(qvk.device, &index_buffer_info, NULL, &transparency.index_buffer));
    _VK(vkCreateBuffer(qvk.device, &particle_color_buffer_info, NULL, &transparency.particle_color_buffer));
    _VK(vkCreateBuffer(qvk.device, &beam_color_buffer_info, NULL, &transparency.beam_color_buffer));
    _VK(vkCreateBuffer(qvk.device, &sprite_info_buffer_info, NULL, &transparency.sprite_info_buffer));
}

Referenced by initialize_transparency().

destroy_transparency()

void destroy_transparency

(

)

Definition at line 151 of file transparency.c.

{
    vkDestroyBufferView(qvk.device, transparency.particle_color_buffer_view, NULL);
    vkDestroyBufferView(qvk.device, transparency.beam_color_buffer_view, NULL);
    vkDestroyBufferView(qvk.device, transparency.sprite_info_buffer_view, NULL);
    vkDestroyBuffer(qvk.device, transparency.host_buffer, NULL);
    vkDestroyBuffer(qvk.device, transparency.scratch_buffer, NULL);
    vkDestroyBuffer(qvk.device, transparency.vertex_buffer, NULL);
    vkDestroyBuffer(qvk.device, transparency.index_buffer, NULL);
    vkDestroyBuffer(qvk.device, transparency.particle_color_buffer, NULL);
    vkDestroyBuffer(qvk.device, transparency.beam_color_buffer, NULL);
    vkDestroyBuffer(qvk.device, transparency.sprite_info_buffer, NULL);
    qvkDestroyAccelerationStructureNV(qvk.device, transparency.particle_blas, NULL);
    qvkDestroyAccelerationStructureNV(qvk.device, transparency.beam_blas, NULL);
    qvkDestroyAccelerationStructureNV(qvk.device, transparency.sprite_blas, NULL);
    vkFreeMemory(qvk.device, transparency.host_buffer_memory, NULL);
    vkFreeMemory(qvk.device, transparency.device_buffer_memory, NULL);
    vkFreeMemory(qvk.device, transparency.device_blas_memory, NULL);
}

Referenced by vkpt_destroy_all().

fill_index_buffer()

static void fill_index_buffer ( )

static

Definition at line 1147 of file transparency.c.

{
    uint16_t* indices = (uint16_t*)transparency.mapped_host_buffer;
 
    for (size_t i = 0; i < TR_PARTICLE_MAX_NUM; i++)
    {
        uint16_t* quad = indices + i * 6;
 
        const uint16_t base_vertex = i * 4;
        quad[0] = base_vertex + 0;
        quad[1] = base_vertex + 1;
        quad[2] = base_vertex + 2;
        quad[3] = base_vertex + 2;
        quad[4] = base_vertex + 3;
        quad[5] = base_vertex + 0;
    }
 
    VkCommandBuffer cmd_buf = vkpt_begin_command_buffer(&qvk.cmd_buffers_transfer);
 
    const VkBufferMemoryBarrier pre_barrier = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
        .srcAccessMask = 0,
        .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .buffer = transparency.index_buffer,
        .size = VK_WHOLE_SIZE
    };
 
    vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
        0, 0, NULL, 1, &pre_barrier, 0, NULL);
 
    const VkBufferCopy region = {
        .size = TR_INDEX_MAX_NUM * sizeof(uint16_t)
    };
 
    vkCmdCopyBuffer(cmd_buf, transparency.host_buffer, transparency.index_buffer, 1, &region);
 
    const VkBufferMemoryBarrier post_barrier = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .buffer = transparency.index_buffer,
        .size = VK_WHOLE_SIZE
    };
 
    vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
        0, 0, NULL, 1, &post_barrier, 0, NULL);
 
    vkpt_submit_command_buffer_simple(cmd_buf, qvk.queue_transfer, qtrue);
    vkpt_wait_idle(qvk.queue_transfer, &qvk.cmd_buffers_transfer);
}

Referenced by initialize_transparency().

get_transparency_beam_blas()

VkAccelerationStructureNV get_transparency_beam_blas

(

)

Definition at line 231 of file transparency.c.

{
    return transparency.beam_blas;
}

Referenced by vkpt_pt_create_toplevel().

get_transparency_beam_color_buffer_view()

VkBufferView get_transparency_beam_color_buffer_view

(

)

Definition at line 246 of file transparency.c.

{
    return transparency.beam_color_buffer_view;
}

Referenced by vkpt_pt_update_descripter_set_bindings().

get_transparency_counts()

void get_transparency_counts	(	int *	particle_num,
		int *	beam_num,
		int *	sprite_num
	)

Definition at line 256 of file transparency.c.

{
    *particle_num = transparency.particle_num;
    *beam_num = transparency.beam_num;
    *sprite_num = transparency.sprite_num;
}

Referenced by vkpt_pt_create_toplevel().

get_transparency_particle_blas()

VkAccelerationStructureNV get_transparency_particle_blas

(

)

Definition at line 226 of file transparency.c.

{
    return transparency.particle_blas;
}

Referenced by vkpt_pt_create_toplevel().

get_transparency_particle_color_buffer_view()

VkBufferView get_transparency_particle_color_buffer_view

(

)

Definition at line 241 of file transparency.c.

{
    return transparency.particle_color_buffer_view;
}

Referenced by vkpt_pt_update_descripter_set_bindings().

get_transparency_sprite_blas()

VkAccelerationStructureNV get_transparency_sprite_blas

(

)

Definition at line 236 of file transparency.c.

{
    return transparency.sprite_blas;
}

Referenced by vkpt_pt_create_toplevel().

get_transparency_sprite_info_buffer_view()

VkBufferView get_transparency_sprite_info_buffer_view

(

)

Definition at line 251 of file transparency.c.

{
    return transparency.sprite_info_buffer_view;
}

Referenced by vkpt_pt_update_descripter_set_bindings().

initialize_transparency()

qboolean initialize_transparency

(

)

Definition at line 114 of file transparency.c.

{
    cvar_pt_particle_size = Cvar_Get("pt_particle_size", "0.35", 0);
    cvar_pt_beam_width = Cvar_Get("pt_beam_width", "1.0", 0);
    cvar_pt_beam_lights = Cvar_Get("pt_beam_lights", "1.0", 0);
 
    memset(&transparency, 0, sizeof(transparency));
 
    const size_t particle_vertex_position_max_size = TR_VERTEX_MAX_NUM * TR_POSITION_SIZE;
    const size_t particle_color_size = TR_PARTICLE_MAX_NUM * TR_COLOR_SIZE;
    const size_t particle_data_size = particle_vertex_position_max_size + particle_color_size;
 
    const size_t beam_vertex_position_max_size = TR_BEAM_MAX_NUM * TR_POSITION_SIZE;
    const size_t beam_color_size = TR_BEAM_MAX_NUM * TR_COLOR_SIZE;
    const size_t beam_data_size = beam_vertex_position_max_size + beam_color_size;
 
    const size_t sprite_vertex_position_max_size = TR_SPRITE_MAX_NUM * TR_POSITION_SIZE;
    const size_t sprite_info_size = TR_SPRITE_MAX_NUM * TR_SPRITE_INFO_SIZE;
    const size_t sprite_data_size = sprite_vertex_position_max_size + sprite_info_size;
    
    transparency.host_buffered_frame_num = MAX_FRAMES_IN_FLIGHT;
    transparency.host_frame_size = particle_data_size + beam_data_size + sprite_data_size;
    transparency.host_buffer_size = transparency.host_buffered_frame_num * transparency.host_frame_size;
 
    create_blas(transparency);
    create_buffers(transparency);
 
    if (allocate_and_bind_memory_to_buffers(transparency) != VK_TRUE)
        return qfalse;
 
    create_buffer_views(transparency);
    allocate_and_bind_memory_to_blas(transparency);
    fill_index_buffer(transparency);
 
    return qtrue;
}

Referenced by vkpt_initialize_all().

update_beam_blas()

static void update_beam_blas ( VkCommandBuffer  command_buffer )

static

Definition at line 747 of file transparency.c.

{
    if (transparency.beam_num == 0 && transparency.blas_beam_num == 0)
        return;
 
    const VkGeometryTrianglesNV triangles = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
        .vertexData = transparency.vertex_buffer,
        .vertexCount = transparency.beam_num * 4,
        .vertexStride = TR_POSITION_SIZE,
        .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
        .vertexOffset = transparency.beam_vertex_device_offset,
        .indexData = transparency.index_buffer,
        .indexCount = transparency.beam_num * 6,
        .indexType = VK_INDEX_TYPE_UINT16
    };
 
    const VkGeometryAABBNV aabbs = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
    };
 
    const VkGeometryDataNV geometry_data = {
        .triangles = triangles,
        .aabbs = aabbs
    };
 
    const VkGeometryNV geometry = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_NV,
        .geometryType = VK_GEOMETRY_TYPE_TRIANGLES_NV,
        .geometry = geometry_data
    };
 
    const VkAccelerationStructureInfoNV info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
        .type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
        .flags = TR_BLAS_BUILD_FLAGS,
        .instanceCount = 0,
        .geometryCount = 1,
        .pGeometries = &geometry
    };
 
    
    const VkBool32 update = transparency.blas_beam_num == transparency.beam_num ? VK_TRUE : VK_FALSE;
    transparency.blas_beam_num = transparency.beam_num;
 
    qvkCmdBuildAccelerationStructureNV(command_buffer, &info, VK_NULL_HANDLE, 0, update,
        transparency.beam_blas, transparency.beam_blas, transparency.scratch_buffer,
        transparency.beam_scratch_device_offset);
}

Referenced by build_transparency_blas().

update_particle_blas()

static void update_particle_blas ( VkCommandBuffer  command_buffer )

static

Definition at line 697 of file transparency.c.

{
    if (transparency.particle_num == 0 && transparency.blas_particle_num == 0)
        return;
 
    vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
        0, 0, NULL, LENGTH(transparency.transfer_barriers), transparency.transfer_barriers, 0, NULL);
 
    const VkGeometryTrianglesNV triangles = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
        .vertexData = transparency.vertex_buffer,
        .vertexCount = transparency.particle_num * 4,
        .vertexStride = TR_POSITION_SIZE,
        .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
        .indexData = transparency.index_buffer,
        .indexCount = transparency.particle_num * 6,
        .indexType = VK_INDEX_TYPE_UINT16
    };
 
    const VkGeometryAABBNV aabbs = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
    };
 
    const VkGeometryDataNV geometry_data = {
        .triangles = triangles,
        .aabbs = aabbs
    };
 
    const VkGeometryNV geometry = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_NV,
        .geometryType = VK_GEOMETRY_TYPE_TRIANGLES_NV,
        .geometry = geometry_data
    };
 
    const VkAccelerationStructureInfoNV info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
        .type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
        .flags = TR_BLAS_BUILD_FLAGS,
        .instanceCount = 0,
        .geometryCount = 1,
        .pGeometries = &geometry
    };
 
    const VkBool32 update = transparency.blas_particle_num == transparency.particle_num ? VK_TRUE : VK_FALSE;
    transparency.blas_particle_num = transparency.particle_num;
 
    qvkCmdBuildAccelerationStructureNV(command_buffer, &info, VK_NULL_HANDLE, 0, update,
        transparency.particle_blas, transparency.particle_blas, transparency.scratch_buffer, 0);
}

Referenced by build_transparency_blas().

update_sprite_blas()

static void update_sprite_blas ( VkCommandBuffer  command_buffer )

static

Definition at line 797 of file transparency.c.

{
    if (transparency.sprite_num == 0 && transparency.blas_sprite_num == 0)
        return;
 
    const VkGeometryTrianglesNV triangles = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
        .vertexData = transparency.vertex_buffer,
        .vertexCount = transparency.sprite_num * 4,
        .vertexStride = TR_POSITION_SIZE,
        .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
        .vertexOffset = transparency.sprite_vertex_device_offset,
        .indexData = transparency.index_buffer,
        .indexCount = transparency.sprite_num * 6,
        .indexType = VK_INDEX_TYPE_UINT16
    };
 
    const VkGeometryAABBNV aabbs = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
    };
 
    const VkGeometryDataNV geometry_data = {
        .triangles = triangles,
        .aabbs = aabbs
    };
 
    const VkGeometryNV geometry = {
        .sType = VK_STRUCTURE_TYPE_GEOMETRY_NV,
        .geometryType = VK_GEOMETRY_TYPE_TRIANGLES_NV,
        .geometry = geometry_data
    };
 
    const VkAccelerationStructureInfoNV info = {
        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
        .type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
        .flags = TR_BLAS_BUILD_FLAGS,
        .instanceCount = 0,
        .geometryCount = 1,
        .pGeometries = &geometry
    };
 
    const VkBool32 update = transparency.blas_sprite_num == transparency.sprite_num ? VK_TRUE : VK_FALSE;
    transparency.blas_sprite_num = transparency.sprite_num;
 
    qvkCmdBuildAccelerationStructureNV(command_buffer, &info, VK_NULL_HANDLE, 0, update,
        transparency.sprite_blas, transparency.sprite_blas, transparency.scratch_buffer,
        transparency.sprite_scratch_device_offset);
}

Referenced by build_transparency_blas().

update_transparency()

void update_transparency	(	VkCommandBuffer	command_buffer,
		const float *	view_matrix,
		const particle_t *	particles,
		int	particle_num,
		const entity_t *	entities,
		int	entity_num
	)

Definition at line 171 of file transparency.c.

{
    transparency.host_frame_index = (transparency.host_frame_index + 1) % transparency.host_buffered_frame_num;
    particle_num = min(particle_num, TR_PARTICLE_MAX_NUM);
 
    uint32_t beam_num = 0;
    uint32_t sprite_num = 0;
    for (int i = 0; i < entity_num; i++)
    {
        if (entities[i].flags & RF_BEAM)
            ++beam_num;
        else if ((entities[i].model & 0x80000000) == 0)
        {
            const model_t* model = MOD_ForHandle(entities[i].model);
            if (model && model->type == MOD_SPRITE)
                ++sprite_num;
        }
    }
    beam_num = min(beam_num, TR_BEAM_MAX_NUM);
    sprite_num = min(sprite_num, TR_SPRITE_MAX_NUM);
 
    transparency.beam_num = beam_num;
    transparency.particle_num = particle_num;
    transparency.sprite_num = sprite_num;
 
    const size_t particle_vertices_size = particle_num * 4 * TR_POSITION_SIZE;
    const size_t beam_vertices_size = beam_num * 4 * TR_POSITION_SIZE;
    const size_t sprite_vertices_size = sprite_num * 4 * TR_POSITION_SIZE;
 
    const size_t host_buffer_offset = transparency.host_frame_index * transparency.host_frame_size;
 
    transparency.vertex_position_host_offset = host_buffer_offset;
    transparency.particle_color_host_offset = host_buffer_offset + particle_vertices_size + beam_vertices_size + sprite_vertices_size;
    transparency.beam_color_host_offset = transparency.particle_color_host_offset + particle_num * TR_COLOR_SIZE;
    transparency.sprite_info_host_offset = transparency.beam_color_host_offset + beam_num * TR_COLOR_SIZE;
 
    if (particle_num > 0 || beam_num > 0 || sprite_num > 0)
    {
        write_particle_geometry(view_matrix, particles, particle_num);
        write_beam_geometry(view_matrix, entities, entity_num);
        write_sprite_geometry(view_matrix, entities, entity_num);
        upload_geometry(command_buffer);
    }
}

Referenced by R_RenderFrame_RTX().

upload_geometry()

static void upload_geometry ( VkCommandBuffer  command_buffer )

static

Definition at line 635 of file transparency.c.

{
    const size_t frame_offset = transparency.host_frame_index * transparency.host_frame_size;
 
    transparency.beam_vertex_device_offset = transparency.particle_num * 4 * TR_POSITION_SIZE;
    transparency.sprite_vertex_device_offset = transparency.beam_vertex_device_offset + transparency.beam_num * 4 * TR_POSITION_SIZE;
 
    const VkBufferCopy vertices = {
        .srcOffset = transparency.vertex_position_host_offset,
        .dstOffset = 0,
        .size = (transparency.particle_num + transparency.beam_num + transparency.sprite_num) * 4 * TR_POSITION_SIZE
    };
 
    const VkBufferCopy paritcle_colors = {
        .srcOffset = transparency.particle_color_host_offset,
        .dstOffset = 0,
        .size = transparency.particle_num * TR_COLOR_SIZE
    };
 
    const VkBufferCopy beam_colors = {
        .srcOffset = transparency.beam_color_host_offset,
        .dstOffset = 0,
        .size = transparency.beam_num * TR_COLOR_SIZE
    };
 
    const VkBufferCopy sprite_infos = {
        .srcOffset = transparency.sprite_info_host_offset,
        .dstOffset = 0,
        .size = transparency.sprite_num * TR_SPRITE_INFO_SIZE
    };
 
    vkCmdCopyBuffer(command_buffer, transparency.host_buffer, transparency.vertex_buffer,
        1, &vertices);
 
    vkCmdCopyBuffer(command_buffer, transparency.host_buffer, transparency.particle_color_buffer,
        1, &paritcle_colors);
 
    vkCmdCopyBuffer(command_buffer, transparency.host_buffer, transparency.beam_color_buffer,
        1, &beam_colors);
 
    vkCmdCopyBuffer(command_buffer, transparency.host_buffer, transparency.sprite_info_buffer,
        1, &sprite_infos);
 
    for (size_t i = 0; i < LENGTH(transparency.transfer_barriers); i++)
    {
        transparency.transfer_barriers[i].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
        transparency.transfer_barriers[i].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        transparency.transfer_barriers[i].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
        transparency.transfer_barriers[i].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        transparency.transfer_barriers[i].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    }
 
    transparency.transfer_barriers[0].buffer = transparency.vertex_buffer;
    transparency.transfer_barriers[0].size = vertices.size;
    transparency.transfer_barriers[1].buffer = transparency.particle_color_buffer;
    transparency.transfer_barriers[1].size = paritcle_colors.size;
    transparency.transfer_barriers[2].buffer = transparency.beam_color_buffer;
    transparency.transfer_barriers[2].size = beam_colors.size;
    transparency.transfer_barriers[3].buffer = transparency.sprite_info_buffer;
    transparency.transfer_barriers[3].size = sprite_infos.size;
}

Referenced by update_transparency().

vkpt_build_beam_lights()

void vkpt_build_beam_lights	(	light_poly_t *	light_list,
		int *	num_lights,
		int	max_lights,
		bsp_t *	bsp,
		entity_t *	entities,
		int	num_entites,
		float	adapted_luminance
	)

Definition at line 492 of file transparency.c.

{
    const float beam_width = cvar_pt_beam_width->value;
    const float hdr_factor = cvar_pt_beam_lights->value * adapted_luminance * 20.f;
 
    if (hdr_factor <= 0.f)
        return;
 
    int num_beams = 0;
 
    static entity_t* beams[MAX_BEAMS];
 
    for (int i = 0; i < num_entites; i++)
    {
        if(num_beams == MAX_BEAMS)
            break;
 
        if ((entities[i].flags & RF_BEAM) != 0)
            beams[num_beams++] = entities + i;
    }
 
    if (num_beams == 0)
        return;
 
    qsort(beams, num_beams, sizeof(entity_t*), compare_beams);
 
    for (int i = 0; i < num_beams; i++)
    {
        if (*num_lights >= max_lights)
            return;
        
        const entity_t* beam = beams[i];
 
        vec3_t begin;
        vec3_t end;
        VectorCopy(beam->oldorigin, begin);
        VectorCopy(beam->origin, end);
 
        vec3_t to_end;
        VectorSubtract(end, begin, to_end);
 
        vec3_t norm_dir;
        VectorCopy(to_end, norm_dir);
        VectorNormalize(norm_dir);
        VectorMA(begin, -5.f, norm_dir, begin);
        VectorMA(end, 5.f, norm_dir, end);
 
        vec3_t color;
        cast_u32_to_f32_color(beam->skinnum, &beam->rgba, color, hdr_factor);
 
        vkpt_build_cylinder_light(light_list, num_lights, max_lights, bsp, begin, end, color, beam_width);
    }
}

Referenced by R_RenderFrame_RTX().

vkpt_build_cylinder_light()

qboolean vkpt_build_cylinder_light	(	light_poly_t *	light_list,
		int *	num_lights,
		int	max_lights,
		bsp_t *	bsp,
		vec3_t	begin,
		vec3_t	end,
		vec3_t	color,
		float	radius
	)

Definition at line 408 of file transparency.c.

{
    vec3_t dir, norm_dir;
    VectorSubtract(end, begin, dir);
    VectorCopy(dir, norm_dir);
    VectorNormalize(norm_dir);
 
    vec3_t up = { 0.f, 0.f, 1.f };
    vec3_t left = { 1.f, 0.f, 0.f };
    if (fabsf(norm_dir[2]) < 0.9f)
    {
        CrossProduct(up, norm_dir, left);
        VectorNormalize(left);
        CrossProduct(norm_dir, left, up);
        VectorNormalize(up);
    }
    else
    {
        CrossProduct(norm_dir, left, up);
        VectorNormalize(up);
        CrossProduct(up, norm_dir, left);
        VectorNormalize(left);
    }
 
 
    vec3_t vertices[6] = {
        { 0.f, 1.f, 0.f },
        { 0.866f, -0.5f, 0.f },
        { -0.866f, -0.5f, 0.f },
        { 0.f, -1.f, 1.f },
        { -0.866f, 0.5f, 1.f },
        { 0.866f, 0.5f, 1.f },
    };
 
    const int indices[18] = {
        0, 4, 2,
        2, 4, 3,
        2, 3, 1,
        1, 3, 5,
        1, 5, 0,
        0, 5, 4
    };
 
    for (int vert = 0; vert < 6; vert++)
    {
        vec3_t transformed;
        VectorCopy(begin, transformed);
        VectorMA(transformed, vertices[vert][0] * radius, up, transformed);
        VectorMA(transformed, vertices[vert][1] * radius, left, transformed);
        VectorMA(transformed, vertices[vert][2], dir, transformed);
        VectorCopy(transformed, vertices[vert]);
    }
 
    for (int tri = 0; tri < 6; tri++)
    {
        if (*num_lights >= max_lights)
            return qfalse;
 
        int i0 = indices[tri * 3 + 0];
        int i1 = indices[tri * 3 + 1];
        int i2 = indices[tri * 3 + 2];
 
        light_poly_t* light = light_list + *num_lights;
 
        VectorCopy(vertices[i0], light->positions + 0);
        VectorCopy(vertices[i1], light->positions + 3);
        VectorCopy(vertices[i2], light->positions + 6);
        get_triangle_off_center(light->positions, light->off_center, NULL);
 
        light->cluster = BSP_PointLeaf(bsp->nodes, light->off_center)->cluster;
        light->material = NULL;
        light->style = 0;
 
        VectorCopy(color, light->color);
 
        if (light->cluster >= 0)
        {
            (*num_lights)++;
        }
    }
 
    return qtrue;
}

Referenced by process_regular_entity(), and vkpt_build_beam_lights().

write_beam_geometry()

static void write_beam_geometry ( const float *  view_matrix, const entity_t *  entities, int  entity_num  )

static

Definition at line 325 of file transparency.c.

{
    const float beam_width = cvar_pt_beam_width->value;
    const float hdr_factor = cvar_pt_particle_emissive->value;
 
    const vec3_t view_y = { view_matrix[1], view_matrix[5], view_matrix[9] };
 
    if (transparency.beam_num == 0)
        return;
 
    // TODO: remove vkpt_refdef.fd, it's better to calculate it from the view matrix
    const vec3_t view_origin = { vkpt_refdef.fd->vieworg[0], vkpt_refdef.fd->vieworg[1], vkpt_refdef.fd->vieworg[2] };
 
    const size_t particle_vertex_data_size = transparency.particle_num * 4 * TR_POSITION_SIZE;
    const size_t beam_vertex_offset = transparency.vertex_position_host_offset + particle_vertex_data_size;
 
    // TODO: use better alignment?
    vec3_t* vertex_positions = (vec3_t*)(transparency.mapped_host_buffer + beam_vertex_offset);
    float* beam_colors = (float*)(transparency.mapped_host_buffer + transparency.beam_color_host_offset);
 
    for (int i = 0; i < entity_num; i++)
    {
        if ((entities[i].flags & RF_BEAM) == 0)
            continue;
 
        const entity_t* beam = entities + i;
 
        cast_u32_to_f32_color(beam->skinnum, &beam->rgba, beam_colors, hdr_factor);
        beam_colors[3] = beam->alpha;
        beam_colors = beam_colors + 4;
 
        vec3_t begin;
        vec3_t end;
        VectorCopy(beam->oldorigin, begin);
        VectorCopy(beam->origin, end);
 
        vec3_t to_end;
        VectorSubtract(end, begin, to_end);
 
        vec3_t norm_dir;
        VectorCopy(to_end, norm_dir);
        VectorNormalize(norm_dir);
        VectorMA(begin, -5.f, norm_dir, begin);
        VectorMA(end, 5.f, norm_dir, end);
 
        vec3_t to_view;
        VectorSubtract(view_origin, begin, to_view);
 
        vec3_t x_axis;
        CrossProduct(to_end, to_view, x_axis);
        VectorNormalize(x_axis);
        VectorScale(x_axis, beam_width, x_axis);
 
        VectorSubtract(end, x_axis, vertex_positions[0]);
        VectorAdd(end, x_axis, vertex_positions[1]);
        VectorAdd(begin, x_axis, vertex_positions[2]);
        VectorSubtract(begin, x_axis, vertex_positions[3]);
        vertex_positions += 4;
    }
}

Referenced by update_transparency().

write_particle_geometry()

static void write_particle_geometry ( const float *  view_matrix, const particle_t *  particles, int  particle_num  )

static

Definition at line 263 of file transparency.c.

{
    const float particle_size = cvar_pt_particle_size->value;
 
    const vec3_t view_y = { view_matrix[1], view_matrix[5], view_matrix[9] };
 
    // TODO: remove vkpt_refdef.fd, it's better to calculate it from the view matrix
    const vec3_t view_origin = { vkpt_refdef.fd->vieworg[0], vkpt_refdef.fd->vieworg[1], vkpt_refdef.fd->vieworg[2] };
 
    // TODO: use better alignment?
    vec3_t* vertex_positions = (vec3_t*)(transparency.mapped_host_buffer + transparency.vertex_position_host_offset);
    float* particle_colors = (float*)(transparency.mapped_host_buffer + transparency.particle_color_host_offset);
 
    for (int i = 0; i < particle_num; i++)
    {
        const particle_t* particle = particles + i;
 
        cast_u32_to_f32_color(particle->color, &particle->rgba, particle_colors, particle->brightness);
        particle_colors[3] = particle->alpha;
        particle_colors = particle_colors + 4;
 
        vec3_t origin;
        VectorCopy(particle->origin, origin);
 
        vec3_t z_axis;
        VectorSubtract(view_origin, origin, z_axis);
        VectorNormalize(z_axis);
 
        vec3_t x_axis;
        vec3_t y_axis;
        CrossProduct(z_axis, view_y, x_axis);
        CrossProduct(x_axis, z_axis, y_axis);
 
        const float size_factor = pow(particle->alpha, 0.05f);
        if (particle->radius == 0.f)
        {
            VectorScale(y_axis, particle_size * size_factor, y_axis);
            VectorScale(x_axis, particle_size * size_factor, x_axis);
        }
        else
        {
            VectorScale(y_axis, particle->radius, y_axis);
            VectorScale(x_axis, particle->radius, x_axis);
        }
 
        vec3_t temp;
        VectorSubtract(origin, x_axis, temp);
        VectorAdd(temp, y_axis, vertex_positions[0]);
 
        VectorAdd(origin, x_axis, temp);
        VectorAdd(temp, y_axis, vertex_positions[1]);
 
        VectorAdd(origin, x_axis, temp);
        VectorSubtract(temp, y_axis, vertex_positions[2]);
 
        VectorSubtract(origin, x_axis, temp);
        VectorSubtract(temp, y_axis, vertex_positions[3]);
 
        vertex_positions += 4;
    }
}

Referenced by update_transparency().

write_sprite_geometry()

static void write_sprite_geometry ( const float *  view_matrix, const entity_t *  entities, int  entity_num  )

static

Definition at line 546 of file transparency.c.

{
    if (transparency.sprite_num == 0)
        return;
 
    const vec3_t view_x = { view_matrix[0], view_matrix[4], view_matrix[8] };
    const vec3_t view_y = { view_matrix[1], view_matrix[5], view_matrix[9] };
    const vec3_t world_y = { 0.f, 0.f, 1.f };
 
    // TODO: remove vkpt_refdef.fd, it's better to calculate it from the view matrix
    const vec3_t view_origin = { vkpt_refdef.fd->vieworg[0], vkpt_refdef.fd->vieworg[1], vkpt_refdef.fd->vieworg[2] };
 
    const size_t particle_vertex_data_size = transparency.particle_num * 4 * TR_POSITION_SIZE;
    const size_t beam_vertex_data_size = transparency.beam_num * 4 * TR_POSITION_SIZE;
    const size_t sprite_vertex_offset = transparency.vertex_position_host_offset + particle_vertex_data_size + beam_vertex_data_size;
 
    // TODO: use better alignment?
    vec3_t* vertex_positions = (vec3_t*)(transparency.mapped_host_buffer + sprite_vertex_offset);
    uint32_t* sprite_info = (int*)(transparency.mapped_host_buffer + transparency.sprite_info_host_offset);
 
    int sprite_count = 0;
    for (int i = 0; i < entity_num; i++)
    {
        const entity_t *e = entities + i;
 
        if (e->model & 0x80000000)
            continue;
 
        const model_t* model = MOD_ForHandle(e->model);
        if (!model || model->type != MOD_SPRITE)
            continue;
 
        mspriteframe_t *frame = &model->spriteframes[e->frame % model->numframes];
        image_t *image = frame->image;
 
        sprite_info[0] = image - r_images;
        sprite_info[1] = *(uint32_t*)&e->alpha;
 
        // set up the quad - reference code is in function GL_DrawSpriteModel
 
        vec3_t up, down, left, right;
 
        if (cvar_pt_projection->integer == 1)
        {
            // make the sprite always face the camera and always vertical in cylindrical projection mode
 
            vec3_t to_camera;
            VectorSubtract(view_origin, e->origin, to_camera);
            
            vec3_t cyl_x;
            CrossProduct(world_y, to_camera, cyl_x);
            VectorNormalize(cyl_x);
 
            VectorScale(cyl_x, frame->origin_x, left);
            VectorScale(cyl_x, frame->origin_x - frame->width, right);
 
            VectorScale(world_y, -frame->origin_y, down);
            VectorScale(world_y, frame->height - frame->origin_y, up);
        }
        else
        {
            VectorScale(view_x, frame->origin_x, left);
            VectorScale(view_x, frame->origin_x - frame->width, right);
 
            if (model->sprite_vertical)
            {
                VectorScale(world_y, -frame->origin_y, down);
                VectorScale(world_y, frame->height - frame->origin_y, up);
            }
            else
            {
                VectorScale(view_y, -frame->origin_y, down);
                VectorScale(view_y, frame->height - frame->origin_y, up);
            }
        }
 
        VectorAdd3(e->origin, down, left, vertex_positions[0]);
        VectorAdd3(e->origin, up, left, vertex_positions[1]);
        VectorAdd3(e->origin, up, right, vertex_positions[2]);
        VectorAdd3(e->origin, down, right, vertex_positions[3]);
 
        vertex_positions += 4;
        sprite_info += TR_SPRITE_INFO_SIZE / sizeof(int);
 
        if (++sprite_count >= TR_SPRITE_MAX_NUM)
            return;
    }
}

Referenced by update_transparency().

Variable Documentation

beam_blas

VkAccelerationStructureNV beam_blas

Definition at line 60 of file transparency.c.

beam_color_buffer

VkBuffer beam_color_buffer

Definition at line 67 of file transparency.c.

beam_color_buffer_view

VkBufferView beam_color_buffer_view

Definition at line 73 of file transparency.c.

Referenced by vkpt_pt_update_descripter_set_bindings().

beam_color_host_offset

size_t beam_color_host_offset

Definition at line 39 of file transparency.c.

beam_num

unsigned int beam_num

Definition at line 51 of file transparency.c.

Referenced by get_transparency_counts(), update_transparency(), and vkpt_pt_create_toplevel().

beam_scratch_device_offset

size_t beam_scratch_device_offset

Definition at line 42 of file transparency.c.

beam_vertex_device_offset

size_t beam_vertex_device_offset

Definition at line 43 of file transparency.c.

blas_beam_num

unsigned int blas_beam_num

Definition at line 53 of file transparency.c.

blas_particle_num

unsigned int blas_particle_num

Definition at line 54 of file transparency.c.

blas_sprite_num

unsigned int blas_sprite_num

Definition at line 55 of file transparency.c.

cvar_pt_beam_lights

cvar_t* cvar_pt_beam_lights = NULL

Definition at line 97 of file transparency.c.

Referenced by CL_RailTrail(), initialize_transparency(), and vkpt_build_beam_lights().

cvar_pt_beam_width

cvar_t* cvar_pt_beam_width = NULL

Definition at line 96 of file transparency.c.

Referenced by initialize_transparency(), vkpt_build_beam_lights(), and write_beam_geometry().

cvar_pt_enable_particles

cvar_t* cvar_pt_enable_particles

Definition at line 101 of file path_tracer.c.

Referenced by vkpt_pt_create_toplevel(), and vkpt_pt_init().

cvar_pt_particle_emissive

cvar_t* cvar_pt_particle_emissive

Definition at line 835 of file effects.c.

Referenced by CL_BFGExplosionParticles(), CL_BfgParticles(), CL_BlasterParticles(), CL_BlasterTrail(), CL_ExplosionParticles(), CL_OldRailTrail(), CL_ParticleEffect(), CL_QuadTrail(), CL_RocketTrail(), FX_Init(), and write_beam_geometry().

cvar_pt_particle_size

cvar_t* cvar_pt_particle_size = NULL

Definition at line 95 of file transparency.c.

Referenced by initialize_transparency(), and write_particle_geometry().

cvar_pt_projection

cvar_t* cvar_pt_projection

Definition at line 56 of file main.c.

Referenced by prepare_ubo(), R_Init_RTX(), and write_sprite_geometry().

device_blas_memory

VkDeviceMemory device_blas_memory

Definition at line 71 of file transparency.c.

device_buffer_memory

VkDeviceMemory device_buffer_memory

Definition at line 70 of file transparency.c.

host_buffer

VkBuffer host_buffer

Definition at line 62 of file transparency.c.

host_buffer_memory

VkDeviceMemory host_buffer_memory

Definition at line 69 of file transparency.c.

host_buffer_size

size_t host_buffer_size

Definition at line 48 of file transparency.c.

Referenced by allocate_and_bind_memory_to_buffers().

host_buffered_frame_num

unsigned int host_buffered_frame_num

Definition at line 57 of file transparency.c.

host_frame_index

unsigned int host_frame_index

Definition at line 56 of file transparency.c.

host_frame_size

size_t host_frame_size

Definition at line 49 of file transparency.c.

index_buffer

VkBuffer index_buffer

Definition at line 65 of file transparency.c.

mapped_host_buffer

char* mapped_host_buffer

Definition at line 58 of file transparency.c.

particle_blas

VkAccelerationStructureNV particle_blas

Definition at line 59 of file transparency.c.

particle_color_buffer

VkBuffer particle_color_buffer

Definition at line 66 of file transparency.c.

particle_color_buffer_view

VkBufferView particle_color_buffer_view

Definition at line 72 of file transparency.c.

Referenced by vkpt_pt_update_descripter_set_bindings().

particle_color_host_offset

size_t particle_color_host_offset

Definition at line 38 of file transparency.c.

particle_num

unsigned int particle_num

Definition at line 50 of file transparency.c.

Referenced by get_transparency_counts(), update_transparency(), vkpt_pt_create_toplevel(), and write_particle_geometry().

scratch_buffer

VkBuffer scratch_buffer

Definition at line 63 of file transparency.c.

sprite_blas

VkAccelerationStructureNV sprite_blas

Definition at line 61 of file transparency.c.

sprite_info_buffer

VkBuffer sprite_info_buffer

Definition at line 68 of file transparency.c.

sprite_info_buffer_view

VkBufferView sprite_info_buffer_view

Definition at line 74 of file transparency.c.

Referenced by vkpt_pt_update_descripter_set_bindings().

sprite_info_host_offset

size_t sprite_info_host_offset

Definition at line 40 of file transparency.c.

sprite_num

unsigned int sprite_num

Definition at line 52 of file transparency.c.

Referenced by get_transparency_counts(), update_transparency(), and vkpt_pt_create_toplevel().

sprite_scratch_device_offset

size_t sprite_scratch_device_offset

Definition at line 45 of file transparency.c.

sprite_vertex_device_offset

size_t sprite_vertex_device_offset

Definition at line 46 of file transparency.c.

transfer_barriers

VkBufferMemoryBarrier transfer_barriers[4]

Definition at line 75 of file transparency.c.

transparency

struct { ... } transparency

Referenced by allocate_and_bind_memory_to_blas(), allocate_and_bind_memory_to_buffers(), create_blas(), create_buffer_views(), create_buffers(), destroy_transparency(), fill_index_buffer(), get_transparency_beam_blas(), get_transparency_beam_color_buffer_view(), get_transparency_counts(), get_transparency_particle_blas(), get_transparency_particle_color_buffer_view(), get_transparency_sprite_blas(), get_transparency_sprite_info_buffer_view(), initialize_transparency(), update_beam_blas(), update_particle_blas(), update_sprite_blas(), update_transparency(), upload_geometry(), write_beam_geometry(), write_particle_geometry(), and write_sprite_geometry().

vertex_buffer

VkBuffer vertex_buffer

Definition at line 64 of file transparency.c.

Referenced by vkpt_pt_create_accel_bottom(), vkpt_pt_create_dynamic(), vkpt_pt_create_explosions(), vkpt_pt_create_static(), vkpt_pt_create_transparent_models(), vkpt_pt_create_viewer_models(), and vkpt_pt_create_viewer_weapon().

vertex_position_host_offset

size_t vertex_position_host_offset

Definition at line 37 of file transparency.c.