qvk.h File Reference

#include <windows.h>
#include <vulkan/vulkan.h>
#include "vk_mem_alloc.h"
#include "vk_shaders.h"

Go to the source code of this file.

Classes
struct	qvkdevice_t
struct	qvkswapchain_t
struct	qvktexture_t
struct	qvkrenderpass_t
struct	qvkbuffer_t
struct	qvkstagingbuffer_t
struct	qvkbufferopts_t
struct	qvkpipeline_t
struct	qvkshader_t

Macros
#define	QVVKTEXTURE_INIT
#define	QVVKTEXTURE_CLEAR(i)
#define	QVKPIPELINE_INIT
#define	QVk_DebugSetObjectName(a, b, c)
#define	QVk_DebugSetObjectTag(a, b, c, d, e)
#define	QVk_DebugLabelBegin(a, b, c, d, e)
#define	QVk_DebugLabelEnd(a)
#define	QVk_DebugLabelInsert(a, b, c, d, e)

Enumerations
enum	qvksampler_t {   S_NEAREST = 0, S_LINEAR = 1, S_MIPMAP_NEAREST = 2, S_MIPMAP_LINEAR = 3,   S_ANISO_NEAREST = 4, S_ANISO_LINEAR = 5, S_ANISO_MIPMAP_NEAREST = 6, S_ANISO_MIPMAP_LINEAR = 7,   S_SAMPLER_CNT = 8 }
enum	qvkrenderpasstype_t { RP_WORLD = 0, RP_UI = 1, RP_WORLD_WARP = 2, RP_COUNT = 3 }

Functions
qboolean	QVk_Init (void)
void	QVk_Shutdown (void)
void	QVk_CreateValidationLayers (void)
void	QVk_DestroyValidationLayers (void)
qboolean	QVk_CreateDevice (int preferredDeviceIdx)
VkResult	QVk_CreateSwapchain (void)
VkFormat	QVk_FindDepthFormat (void)
VkResult	QVk_CreateCommandPool (VkCommandPool *commandPool, uint32_t queueFamilyIndex)
VkResult	QVk_CreateImageView (const VkImage *image, VkImageAspectFlags aspectFlags, VkImageView *imageView, VkFormat format, uint32_t mipLevels)
VkResult	QVk_CreateImage (uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VmaMemoryUsage memUsage, qvktexture_t *texture)
void	QVk_CreateDepthBuffer (VkSampleCountFlagBits sampleCount, qvktexture_t *depthBuffer)
void	QVk_CreateColorBuffer (VkSampleCountFlagBits sampleCount, qvktexture_t *colorBuffer, int extraFlags)
void	QVk_CreateTexture (qvktexture_t *texture, const unsigned char *data, uint32_t width, uint32_t height, qvksampler_t samplerType)
void	QVk_UpdateTextureData (qvktexture_t *texture, const unsigned char *data, uint32_t offset_x, uint32_t offset_y, uint32_t width, uint32_t height)
VkSampler	QVk_UpdateTextureSampler (qvktexture_t *texture, qvksampler_t samplerType)
void	QVk_ReleaseTexture (qvktexture_t *texture)
void	QVk_ReadPixels (uint8_t *dstBuffer, uint32_t width, uint32_t height)
VkResult	QVk_BeginCommand (const VkCommandBuffer *commandBuffer)
void	QVk_SubmitCommand (const VkCommandBuffer *commandBuffer, const VkQueue *queue)
VkCommandBuffer	QVk_CreateCommandBuffer (const VkCommandPool *commandPool, VkCommandBufferLevel level)
const char *	QVk_GetError (VkResult errorCode)
VkResult	QVk_BeginFrame (void)
VkResult	QVk_EndFrame (qboolean force)
void	QVk_BeginRenderpass (qvkrenderpasstype_t rpType)
void	QVk_RecreateSwapchain (void)
VkResult	QVk_CreateBuffer (VkDeviceSize size, qvkbuffer_t *dstBuffer, const qvkbufferopts_t options)
void	QVk_FreeBuffer (qvkbuffer_t *buffer)
VkResult	QVk_CreateStagingBuffer (VkDeviceSize size, qvkbuffer_t *dstBuffer, VkMemoryPropertyFlags reqMemFlags, VkMemoryPropertyFlags prefMemFlags)
VkResult	QVk_CreateUniformBuffer (VkDeviceSize size, qvkbuffer_t *dstBuffer, VkMemoryPropertyFlags reqMemFlags, VkMemoryPropertyFlags prefMemFlags)
void	QVk_CreateVertexBuffer (const void *data, VkDeviceSize size, qvkbuffer_t *dstBuffer, qvkbuffer_t *stagingBuffer, VkMemoryPropertyFlags reqMemFlags, VkMemoryPropertyFlags prefMemFlags)
void	QVk_CreateIndexBuffer (const void *data, VkDeviceSize size, qvkbuffer_t *dstBuffer, qvkbuffer_t *stagingBuffer, VkMemoryPropertyFlags reqMemFlags, VkMemoryPropertyFlags prefMemFlags)
qvkshader_t	QVk_CreateShader (const uint32_t *shaderSrc, size_t shaderCodeSize, VkShaderStageFlagBits shaderStage)
void	QVk_CreatePipeline (const VkDescriptorSetLayout *descriptorLayout, const uint32_t desLayoutCount, const VkPipelineVertexInputStateCreateInfo *vertexInputInfo, qvkpipeline_t *pipeline, const qvkrenderpass_t *renderpass, const qvkshader_t *shaders, uint32_t shaderCount, VkPushConstantRange *pcRange)
void	QVk_DestroyPipeline (qvkpipeline_t *pipeline)
uint8_t *	QVk_GetVertexBuffer (VkDeviceSize size, VkBuffer *dstBuffer, VkDeviceSize *dstOffset)
uint8_t *	QVk_GetIndexBuffer (VkDeviceSize size, VkDeviceSize *dstOffset)
uint8_t *	QVk_GetUniformBuffer (VkDeviceSize size, uint32_t *dstOffset, VkDescriptorSet *dstUboDescriptorSet)
uint8_t *	QVk_GetStagingBuffer (VkDeviceSize size, int alignment, VkCommandBuffer *cmdBuffer, VkBuffer *buffer, uint32_t *dstOffset)
VkBuffer	QVk_GetTriangleFanIbo (VkDeviceSize indexCount)
void	QVk_DrawColorRect (float *ubo, VkDeviceSize uboSize, qvkrenderpasstype_t rpType)
void	QVk_DrawTexRect (float *ubo, VkDeviceSize uboSize, qvktexture_t *texture)
void	QVk_BindPipeline (qvkpipeline_t *pipeline)
void	QVk_SubmitStagingBuffers (void)

Variables
VkInstance	vk_instance
VkSurfaceKHR	vk_surface
qvkdevice_t	vk_device
VmaAllocator	vk_malloc
qvkswapchain_t	vk_swapchain
VkCommandBuffer	vk_activeCmdbuffer
VkCommandPool	vk_commandPool
VkCommandPool	vk_transferCommandPool
VkDescriptorPool	vk_descriptorPool
VkDescriptorSetLayout	vk_uboDescSetLayout
VkDescriptorSetLayout	vk_samplerDescSetLayout
qvkpipeline_t	vk_drawTexQuadPipeline
qvkpipeline_t	vk_drawColorQuadPipeline [2]
qvkpipeline_t	vk_drawModelPipelineStrip [2]
qvkpipeline_t	vk_drawModelPipelineFan [2]
qvkpipeline_t	vk_drawNoDepthModelPipelineStrip
qvkpipeline_t	vk_drawNoDepthModelPipelineFan
qvkpipeline_t	vk_drawLefthandModelPipelineStrip
qvkpipeline_t	vk_drawLefthandModelPipelineFan
qvkpipeline_t	vk_drawNullModelPipeline
qvkpipeline_t	vk_drawParticlesPipeline
qvkpipeline_t	vk_drawPointParticlesPipeline
qvkpipeline_t	vk_drawSpritePipeline
qvkpipeline_t	vk_drawPolyPipeline
qvkpipeline_t	vk_drawPolyLmapPipeline
qvkpipeline_t	vk_drawPolyWarpPipeline
qvkpipeline_t	vk_drawBeamPipeline
qvkpipeline_t	vk_drawSkyboxPipeline
qvkpipeline_t	vk_drawDLightPipeline
qvkpipeline_t	vk_showTrisPipeline
qvkpipeline_t	vk_shadowsPipelineStrip
qvkpipeline_t	vk_shadowsPipelineFan
qvkpipeline_t	vk_worldWarpPipeline
qvkpipeline_t	vk_postprocessPipeline
qvktexture_t	vk_colorbuffer
qvktexture_t	vk_colorbufferWarp
qboolean	vk_frameStarted
PFN_vkCreateDebugUtilsMessengerEXT	qvkCreateDebugUtilsMessengerEXT
PFN_vkDestroyDebugUtilsMessengerEXT	qvkDestroyDebugUtilsMessengerEXT
PFN_vkSetDebugUtilsObjectNameEXT	qvkSetDebugUtilsObjectNameEXT
PFN_vkSetDebugUtilsObjectTagEXT	qvkSetDebugUtilsObjectTagEXT
PFN_vkCmdBeginDebugUtilsLabelEXT	qvkCmdBeginDebugUtilsLabelEXT
PFN_vkCmdEndDebugUtilsLabelEXT	qvkCmdEndDebugUtilsLabelEXT
PFN_vkCmdInsertDebugUtilsLabelEXT	qvkInsertDebugUtilsLabelEXT

Macro Definition Documentation

QVk_DebugLabelBegin

#define QVk_DebugLabelBegin	(		a,
			b,
			c,
			d,
			e
	)

Definition at line 319 of file qvk.h.

QVk_DebugLabelEnd

#define QVk_DebugLabelEnd

(

a

)

Definition at line 320 of file qvk.h.

QVk_DebugLabelInsert

#define QVk_DebugLabelInsert	(		a,
			b,
			c,
			d,
			e
	)

Definition at line 321 of file qvk.h.

QVk_DebugSetObjectName

#define QVk_DebugSetObjectName	(		a,
			b,
			c
	)

Definition at line 317 of file qvk.h.

QVk_DebugSetObjectTag

#define QVk_DebugSetObjectTag	(		a,
			b,
			c,
			d,
			e
	)

Definition at line 318 of file qvk.h.

QVKPIPELINE_INIT

#define QVKPIPELINE_INIT

Value:

    { \
    .layout = VK_NULL_HANDLE, \
    .pl = VK_NULL_HANDLE, \
    .flags = 0, \
    .mode = VK_POLYGON_MODE_FILL, \
    .cullMode = VK_CULL_MODE_BACK_BIT, \
    .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, \
    .blendOpts = { \
        .blendEnable = VK_FALSE, \
        .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, \
        .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, \
        .colorBlendOp = VK_BLEND_OP_ADD, \
        .srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, \
        .dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, \
        .alphaBlendOp = VK_BLEND_OP_ADD, \
        .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT \
    }, \
    .depthTestEnable = VK_TRUE, \
    .depthWriteEnable = VK_TRUE \
}

Definition at line 172 of file qvk.h.

QVVKTEXTURE_CLEAR

#define QVVKTEXTURE_CLEAR

(

i

)

Value:

    { \
    (i).image = VK_NULL_HANDLE; \
    (i).allocation = VK_NULL_HANDLE; \
    (i).vmaFlags = 0; \
    (i).imageView = VK_NULL_HANDLE; \
    (i).sharingMode = VK_SHARING_MODE_MAX_ENUM; \
    (i).sampleCount = VK_SAMPLE_COUNT_1_BIT; \
    (i).format = VK_FORMAT_R8G8B8A8_UNORM; \
    (i).mipLevels = 1; \
}

Definition at line 104 of file qvk.h.

QVVKTEXTURE_INIT

#define QVVKTEXTURE_INIT

Value:

    { \
    .image = VK_NULL_HANDLE, \
    .allocation = VK_NULL_HANDLE, \
    .allocInfo = VK_NULL_HANDLE, \
    .vmaFlags = 0, \
    .imageView = VK_NULL_HANDLE, \
    .sharingMode = VK_SHARING_MODE_MAX_ENUM, \
    .sampleCount = VK_SAMPLE_COUNT_1_BIT, \
    .format = VK_FORMAT_R8G8B8A8_UNORM, \
    .descriptorSet = VK_NULL_HANDLE, \
    .mipLevels = 1, \
}

Definition at line 91 of file qvk.h.

Enumeration Type Documentation

qvkrenderpasstype_t

enum qvkrenderpasstype_t

Enumerator
RP_WORLD
RP_UI
RP_WORLD_WARP
RP_COUNT

Definition at line 194 of file qvk.h.

{
    RP_WORLD = 0,      // renders game world to offscreen buffer
    RP_UI = 1,         // render UI elements and game console
    RP_WORLD_WARP = 2, // perform postprocessing on RP_WORLD (underwater screen warp)
    RP_COUNT = 3
} qvkrenderpasstype_t;

qvksampler_t

enum qvksampler_t

Enumerator
S_NEAREST
S_LINEAR
S_MIPMAP_NEAREST
S_MIPMAP_LINEAR
S_ANISO_NEAREST
S_ANISO_LINEAR
S_ANISO_MIPMAP_NEAREST
S_ANISO_MIPMAP_LINEAR
S_SAMPLER_CNT

Definition at line 63 of file qvk.h.

{
    S_NEAREST = 0,
    S_LINEAR = 1,
    S_MIPMAP_NEAREST = 2,
    S_MIPMAP_LINEAR = 3,
    S_ANISO_NEAREST = 4,
    S_ANISO_LINEAR = 5,
    S_ANISO_MIPMAP_NEAREST = 6,
    S_ANISO_MIPMAP_LINEAR = 7,
    S_SAMPLER_CNT = 8
} qvksampler_t;

Function Documentation

QVk_BeginCommand()

VkResult QVk_BeginCommand

(

const VkCommandBuffer *

commandBuffer

)

Definition at line 23 of file vk_cmd.c.

{
    VkCommandBufferBeginInfo cmdInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .pNext = NULL,
        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
        .pInheritanceInfo = NULL
    };
 
    return vkBeginCommandBuffer(*commandBuffer, &cmdInfo);
}

Referenced by copyBuffer(), CreateStagingBuffers(), and QVk_ReadPixels().

QVk_BeginFrame()

VkResult QVk_BeginFrame

(

void

)

Definition at line 1824 of file vk_common.c.

{
    // reset tracking variables
    vk_state.current_pipeline = VK_NULL_HANDLE;
    vk_config.vertex_buffer_usage  = 0;
    // triangle fan index buffer data will not be cleared between frames unless the buffer itself is too small
    vk_config.index_buffer_usage   = vk_triangleFanIboUsage;
    vk_config.uniform_buffer_usage = 0;
    vk_config.triangle_fan_index_usage = 0;
 
    ReleaseSwapBuffers();
 
    VkResult result = vkAcquireNextImageKHR(vk_device.logical, vk_swapchain.sc, UINT32_MAX, vk_imageAvailableSemaphores[vk_activeBufferIdx], VK_NULL_HANDLE, &vk_imageIndex);
    vk_activeCmdbuffer = vk_commandbuffers[vk_activeBufferIdx];
 
    // swap dynamic buffers
    vk_activeDynBufferIdx = (vk_activeDynBufferIdx + 1) % NUM_DYNBUFFERS;
    vk_dynUniformBuffers[vk_activeDynBufferIdx].currentOffset = 0;
    vk_dynVertexBuffers[vk_activeDynBufferIdx].currentOffset = 0;
    // triangle fan index data is placed in the beginning of the buffer
    vk_dynIndexBuffers[vk_activeDynBufferIdx].currentOffset = vk_triangleFanIboUsage;
    vmaInvalidateAllocation(vk_malloc, vk_dynUniformBuffers[vk_activeDynBufferIdx].allocation, 0, VK_WHOLE_SIZE);
    vmaInvalidateAllocation(vk_malloc, vk_dynVertexBuffers[vk_activeDynBufferIdx].allocation, 0, VK_WHOLE_SIZE);
    vmaInvalidateAllocation(vk_malloc, vk_dynIndexBuffers[vk_activeDynBufferIdx].allocation, 0, VK_WHOLE_SIZE);
 
    // for VK_OUT_OF_DATE_KHR and VK_SUBOPTIMAL_KHR it'd be fine to just rebuild the swapchain but let's take the easy way out and restart video system
    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || result == VK_ERROR_SURFACE_LOST_KHR)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_BeginFrame(): received %s after vkAcquireNextImageKHR - restarting video!\n", QVk_GetError(result));
        return result;
    }
    else if (result != VK_SUCCESS)
    {
        Sys_Error("QVk_BeginFrame(): unexpected error after vkAcquireNextImageKHR: %s", QVk_GetError(result));
    }
 
    VK_VERIFY(vkWaitForFences(vk_device.logical, 1, &vk_fences[vk_activeBufferIdx], VK_TRUE, UINT32_MAX));
    VK_VERIFY(vkResetFences(vk_device.logical, 1, &vk_fences[vk_activeBufferIdx]));
 
    // setup command buffers and render pass for drawing
    VkCommandBufferBeginInfo beginInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .pNext = NULL,
        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
        .pInheritanceInfo = NULL
    };
 
    VK_VERIFY(vkBeginCommandBuffer(vk_commandbuffers[vk_activeBufferIdx], &beginInfo));
 
    vkCmdSetViewport(vk_commandbuffers[vk_activeBufferIdx], 0, 1, &vk_viewport);
    vkCmdSetScissor(vk_commandbuffers[vk_activeBufferIdx], 0, 1, &vk_scissor);
 
    vk_frameStarted = true;
    return VK_SUCCESS;
}

Referenced by R_BeginFrame().

QVk_BeginRenderpass()

void QVk_BeginRenderpass

(

qvkrenderpasstype_t

rpType

)

Definition at line 1946 of file vk_common.c.

{
    VkClearValue clearColors[3] = {
        {.color = { 1.f, .0f, .5f, 1.f } },
        {.depthStencil = { 1.f, 0 } },
        {.color = { 1.f, .0f, .5f, 1.f } },
    };
 
    VkRenderPassBeginInfo renderBeginInfo[] = {
        // RP_WORLD
        {
            .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
            .renderPass = vk_renderpasses[RP_WORLD].rp,
            .framebuffer = vk_framebuffers[RP_WORLD][vk_imageIndex],
            .renderArea.offset = { 0, 0 },
            .renderArea.extent = vk_swapchain.extent,
            .clearValueCount = vk_renderpasses[RP_WORLD].sampleCount != VK_SAMPLE_COUNT_1_BIT ? 3 : 2,
            .pClearValues = clearColors
        },
        // RP_UI
        {
            .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
            .renderPass = vk_renderpasses[RP_UI].rp,
            .framebuffer = vk_framebuffers[RP_UI][vk_imageIndex],
            .renderArea.offset = { 0, 0 },
            .renderArea.extent = vk_swapchain.extent,
            .clearValueCount = 2,
            .pClearValues = clearColors
        },
        // RP_WORLD_WARP
        {
            .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
            .renderPass = vk_renderpasses[RP_WORLD_WARP].rp,
            .framebuffer = vk_framebuffers[RP_WORLD_WARP][vk_imageIndex],
            .renderArea.offset = { 0, 0 },
            .renderArea.extent = vk_swapchain.extent,
            .clearValueCount = 1,
            .pClearValues = clearColors
        }
    };
 
#if defined(_DEBUG) || defined(ENABLE_DEBUG_LABELS)
    if (rpType == RP_WORLD) {
        QVk_DebugLabelBegin(&vk_commandbuffers[vk_activeBufferIdx], "Draw World", 0.f, 1.f, 0.f);
    }
    if (rpType == RP_UI) {
        QVk_DebugLabelEnd(&vk_commandbuffers[vk_activeBufferIdx]);
        QVk_DebugLabelBegin(&vk_commandbuffers[vk_activeBufferIdx], "Draw UI", 1.f, 1.f, 0.f);
    }
    if (rpType == RP_WORLD_WARP) {
        QVk_DebugLabelEnd(&vk_commandbuffers[vk_activeBufferIdx]);
        QVk_DebugLabelBegin(&vk_commandbuffers[vk_activeBufferIdx], "Draw View Warp", 1.f, 0.f, .5f);
    }
#endif
 
    vkCmdBeginRenderPass(vk_commandbuffers[vk_activeBufferIdx], &renderBeginInfo[rpType], VK_SUBPASS_CONTENTS_INLINE);
}

Referenced by R_BeginFrame(), and R_EndWorldRenderpass().

QVk_BindPipeline()

void QVk_BindPipeline

(

qvkpipeline_t *

pipeline

)

Definition at line 2284 of file vk_common.c.

{
    if (vk_state.current_pipeline != pipeline->pl)
    {
        vkCmdBindPipeline(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->pl);
        vk_state.current_pipeline = pipeline->pl;
    }
}

Referenced by DrawVkFlowingPoly(), DrawVkPoly(), EmitWaterPolys(), QVk_DrawColorRect(), QVk_DrawTexRect(), R_DrawBeam(), R_DrawNullModel(), R_DrawParticles(), R_DrawSkyBox(), R_DrawSpriteModel(), R_DrawTriangleOutlines(), R_EndWorldRenderpass(), R_RenderDlight(), R_SetVulkan2D(), Vk_DrawAliasFrameLerp(), Vk_DrawAliasShadow(), Vk_DrawParticles(), and Vk_RenderLightmappedPoly().

QVk_CreateBuffer()

VkResult QVk_CreateBuffer	(	VkDeviceSize	size,
		qvkbuffer_t *	dstBuffer,
		const qvkbufferopts_t	options
	)

Definition at line 70 of file vk_buffer.c.

{
    VkBufferCreateInfo bcInfo = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .size = size,
        .usage = options.usage,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .queueFamilyIndexCount = 0,
        .pQueueFamilyIndices = NULL,
    };
 
    // separate transfer queue makes sense only if the buffer is targetted for being transfered to GPU, so ignore it if it's CPU-only
    uint32_t queueFamilies[] = { (uint32_t)vk_device.gfxFamilyIndex, (uint32_t)vk_device.transferFamilyIndex };
    if (options.vmaUsage != VMA_MEMORY_USAGE_CPU_ONLY && vk_device.gfxFamilyIndex != vk_device.transferFamilyIndex)
    {
        bcInfo.sharingMode = VK_SHARING_MODE_CONCURRENT;
        bcInfo.queueFamilyIndexCount = 2;
        bcInfo.pQueueFamilyIndices = queueFamilies;
    }
 
    VmaAllocationCreateInfo vmallocInfo = {
        .flags = options.vmaFlags,
        .usage = options.vmaUsage,
        .requiredFlags = options.reqMemFlags,
        .preferredFlags = options.prefMemFlags,
        .memoryTypeBits = 0,
        .pool = VK_NULL_HANDLE,
        .pUserData = NULL
    };
 
    dstBuffer->currentOffset = 0;
    return vmaCreateBuffer(vk_malloc, &bcInfo, &vmallocInfo, &dstBuffer->buffer, &dstBuffer->allocation, &dstBuffer->allocInfo);
}

Referenced by createStagedBuffer(), QVk_CreateStagingBuffer(), QVk_CreateUniformBuffer(), and QVk_ReadPixels().

QVk_CreateColorBuffer()

void QVk_CreateColorBuffer	(	VkSampleCountFlagBits	sampleCount,
		qvktexture_t *	colorBuffer,
		int	extraFlags
	)

Definition at line 367 of file vk_image.c.

{
    colorBuffer->format = vk_swapchain.format;
    colorBuffer->sampleCount = sampleCount;
    // On 64-bit builds, Intel drivers throw a warning:
    // "Mapping an image with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used."
    // Minor annoyance but we don't want any validation warnings, so we create dedicated allocation for color buffer.
    // more details: https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/issues/34
    // Note that this is a false positive which in other cases could be ignored: https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/general_considerations.html#general_considerations_validation_layer_warnings
    colorBuffer->vmaFlags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
 
    VK_VERIFY(QVk_CreateImage(vk_swapchain.extent.width, vk_swapchain.extent.height, colorBuffer->format, VK_IMAGE_TILING_OPTIMAL, extraFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VMA_MEMORY_USAGE_GPU_ONLY, colorBuffer));
    VK_VERIFY(QVk_CreateImageView(&colorBuffer->image, VK_IMAGE_ASPECT_COLOR_BIT, &colorBuffer->imageView, colorBuffer->format, colorBuffer->mipLevels));
}

Referenced by CreateDrawBuffers().

QVk_CreateCommandBuffer()

VkCommandBuffer QVk_CreateCommandBuffer	(	const VkCommandPool *	commandPool,
		VkCommandBufferLevel	level
	)

Definition at line 78 of file vk_cmd.c.

{
    VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
    VkCommandBufferAllocateInfo allocInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .pNext = NULL,
        .commandPool = *commandPool,
        .level = level,
        .commandBufferCount = 1
    };
 
    VK_VERIFY(vkAllocateCommandBuffers(vk_device.logical, &allocInfo, &commandBuffer));
    return commandBuffer;
}

Referenced by copyBuffer(), CreateStagingBuffers(), and QVk_ReadPixels().

QVk_CreateCommandPool()

VkResult QVk_CreateCommandPool	(	VkCommandPool *	commandPool,
		uint32_t	queueFamilyIndex
	)

Definition at line 65 of file vk_cmd.c.

{
    VkCommandPoolCreateInfo cpCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
        .pNext = NULL,
        // allow the command pool to be explicitly reset without reallocating it manually during recording each frame
        .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
        .queueFamilyIndex = queueFamilyIndex
    };
 
    return vkCreateCommandPool(vk_device.logical, &cpCreateInfo, NULL, commandPool);
}

Referenced by CreateStagingBuffers(), and QVk_Init().

QVk_CreateDepthBuffer()

void QVk_CreateDepthBuffer	(	VkSampleCountFlagBits	sampleCount,
		qvktexture_t *	depthBuffer
	)

Definition at line 352 of file vk_image.c.

{
    depthBuffer->format = QVk_FindDepthFormat();
    depthBuffer->sampleCount = sampleCount;
    // On 64-bit builds, Intel drivers throw a warning:
    // "Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used."
    // Minor annoyance but we don't want any validation warnings, so we create dedicated allocation for depth buffer.
    // more details: https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/issues/34
    // Note that this is a false positive which in other cases could be ignored: https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/general_considerations.html#general_considerations_validation_layer_warnings
    depthBuffer->vmaFlags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
 
    VK_VERIFY(QVk_CreateImage(vk_swapchain.extent.width, vk_swapchain.extent.height, depthBuffer->format, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VMA_MEMORY_USAGE_GPU_ONLY, depthBuffer));
    VK_VERIFY(QVk_CreateImageView(&depthBuffer->image, getDepthStencilAspect(depthBuffer->format), &depthBuffer->imageView, depthBuffer->format, depthBuffer->mipLevels));
}

Referenced by CreateDrawBuffers().

QVk_CreateDevice()

qboolean QVk_CreateDevice

(

int

preferredDeviceIdx

)

Definition at line 264 of file vk_device.c.

{
    if (!selectPhysicalDevice(preferredDeviceIdx))
        return false;
 
    vk_config.vendor_name = vendorNameString(vk_device.properties.vendorID);
    vk_config.device_type = deviceTypeString(vk_device.properties.deviceType);
 
    VkResult res = createLogicalDevice();
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "Could not create Vulkan logical device: %s\n", QVk_GetError(res));
        return false;
    }
 
    vkGetDeviceQueue(vk_device.logical, vk_device.gfxFamilyIndex, 0, &vk_device.gfxQueue);
    vkGetDeviceQueue(vk_device.logical, vk_device.presentFamilyIndex, 0, &vk_device.presentQueue);
    vkGetDeviceQueue(vk_device.logical, vk_device.transferFamilyIndex, 0, &vk_device.transferQueue);
 
    return true;
}

Referenced by QVk_Init().

QVk_CreateImage()

VkResult QVk_CreateImage	(	uint32_t	width,
		uint32_t	height,
		VkFormat	format,
		VkImageTiling	tiling,
		VkImageUsageFlags	usage,
		VmaMemoryUsage	memUsage,
		qvktexture_t *	texture
	)

Definition at line 316 of file vk_image.c.

{
    VkImageCreateInfo imageInfo = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .imageType = VK_IMAGE_TYPE_2D,
        .extent.width = width,
        .extent.height = height,
        .extent.depth = 1,
        .mipLevels = texture->mipLevels,
        .arrayLayers = 1,
        .format = format,
        .tiling = tiling,
        .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
        .usage = usage,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .samples = texture->sampleCount,
        .flags = 0
    };
 
    uint32_t queueFamilies[] = { (uint32_t)vk_device.gfxFamilyIndex, (uint32_t)vk_device.transferFamilyIndex };
    if (vk_device.gfxFamilyIndex != vk_device.transferFamilyIndex)
    {
        imageInfo.sharingMode = VK_SHARING_MODE_CONCURRENT;
        imageInfo.queueFamilyIndexCount = 2;
        imageInfo.pQueueFamilyIndices = queueFamilies;
    }
 
    VmaAllocationCreateInfo vmallocInfo = {
        .flags = texture->vmaFlags,
        .usage = memUsage
    };
 
    texture->sharingMode = imageInfo.sharingMode;
    return vmaCreateImage(vk_malloc, &imageInfo, &vmallocInfo, &texture->image, &texture->allocation, &texture->allocInfo);
}

Referenced by createTextureImage(), QVk_CreateColorBuffer(), and QVk_CreateDepthBuffer().

QVk_CreateImageView()

VkResult QVk_CreateImageView	(	const VkImage *	image,
		VkImageAspectFlags	aspectFlags,
		VkImageView *	imageView,
		VkFormat	format,
		uint32_t	mipLevels
	)

Definition at line 293 of file vk_image.c.

{
    VkImageViewCreateInfo ivCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .image = *image,
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format = format,
        .components.r = VK_COMPONENT_SWIZZLE_IDENTITY,
        .components.g = VK_COMPONENT_SWIZZLE_IDENTITY,
        .components.b = VK_COMPONENT_SWIZZLE_IDENTITY,
        .components.a = VK_COMPONENT_SWIZZLE_IDENTITY,
        .subresourceRange.aspectMask = aspectFlags,
        .subresourceRange.baseArrayLayer = 0,
        .subresourceRange.baseMipLevel = 0,
        .subresourceRange.layerCount = 1,
        .subresourceRange.levelCount = mipLevels
    };
 
    return vkCreateImageView(vk_device.logical, &ivCreateInfo, NULL, imageView);
}

Referenced by CreateImageViews(), QVk_CreateColorBuffer(), QVk_CreateDepthBuffer(), and QVk_CreateTexture().

QVk_CreateIndexBuffer()

void QVk_CreateIndexBuffer	(	const void *	data,
		VkDeviceSize	size,
		qvkbuffer_t *	dstBuffer,
		qvkbuffer_t *	stagingBuffer,
		VkMemoryPropertyFlags	reqMemFlags,
		VkMemoryPropertyFlags	prefMemFlags
	)

Definition at line 158 of file vk_buffer.c.

{
    qvkbufferopts_t dstOpts = {
        .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
        .reqMemFlags = reqMemFlags,
        .prefMemFlags = prefMemFlags,
        .vmaUsage = VMA_MEMORY_USAGE_GPU_ONLY,
        .vmaFlags = 0
    };
 
    createStagedBuffer(data, size, dstBuffer, dstOpts, stagingBuffer);
}

Referenced by CreateDynamicBuffers(), CreateStaticBuffers(), and QVk_GetIndexBuffer().

QVk_CreatePipeline()

void QVk_CreatePipeline	(	const VkDescriptorSetLayout *	descriptorLayout,
		const uint32_t	desLayoutCount,
		const VkPipelineVertexInputStateCreateInfo *	vertexInputInfo,
		qvkpipeline_t *	pipeline,
		const qvkrenderpass_t *	renderpass,
		const qvkshader_t *	shaders,
		uint32_t	shaderCount,
		VkPushConstantRange *	pcRange
	)

Definition at line 51 of file vk_pipeline.c.

{
    VkPipelineShaderStageCreateInfo *ssCreateInfos = (VkPipelineShaderStageCreateInfo *)malloc(shaderCount * sizeof(VkPipelineShaderStageCreateInfo));
    for (int i = 0; i < shaderCount; i++)
    {
        ssCreateInfos[i] = shaders[i].createInfo;
    }
 
    VkPipelineInputAssemblyStateCreateInfo iaCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .topology = pipeline->topology,
        .primitiveRestartEnable = VK_FALSE
    };
 
    VkViewport viewport = {
        .x = 0.f,
        .y = 0.f,
        .width = (float)vid.width,
        .height = (float)vid.height,
        .minDepth = 0.f,
        .maxDepth = 1.f,
    };
 
    VkRect2D scissor = {
        .offset.x = 0,
        .offset.y = 0,
        .extent = vk_swapchain.extent
    };
 
    VkPipelineViewportStateCreateInfo vpCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .viewportCount = 1,
        .pViewports = &viewport,
        .scissorCount = 1,
        .pScissors = &scissor
    };
 
    VkPipelineRasterizationStateCreateInfo rCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .depthClampEnable = VK_FALSE,
        .rasterizerDiscardEnable = VK_FALSE,
        .polygonMode = pipeline->mode,
        .cullMode = pipeline->cullMode,
        .frontFace = VK_FRONT_FACE_CLOCKWISE,
        .depthBiasEnable = VK_FALSE,
        .depthBiasConstantFactor = 0.f,
        .depthBiasClamp = 0.f,
        .depthBiasSlopeFactor = 0.f,
        .lineWidth = 1.f
    };
 
    VkPipelineMultisampleStateCreateInfo msCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .rasterizationSamples = renderpass->sampleCount,
        .sampleShadingEnable = (vk_sampleshading->value > 0 && vk_device.features.sampleRateShading) ? VK_TRUE : VK_FALSE,
        .minSampleShading = (vk_sampleshading->value > 0 && vk_device.features.sampleRateShading) ? 1.f : 0.f,
        .pSampleMask = NULL,
        .alphaToCoverageEnable = VK_FALSE,
        .alphaToOneEnable = VK_FALSE
    };
 
    VkPipelineDepthStencilStateCreateInfo dCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .depthTestEnable = pipeline->depthTestEnable,
        .depthWriteEnable = pipeline->depthTestEnable == VK_TRUE ? pipeline->depthWriteEnable : VK_FALSE, // there should be NO depth writes if depthTestEnable is false but Intel seems to not follow the specs fully...
        .depthCompareOp = VK_COMPARE_OP_LESS,
        .depthBoundsTestEnable = VK_FALSE,
        .stencilTestEnable = VK_FALSE,
        .front = { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_NEVER, 0, 0, 0 },
        .back = { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_NEVER, 0, 0, 0 },
        .minDepthBounds = 0.f,
        .maxDepthBounds = 1.f
    };
 
    VkPipelineColorBlendStateCreateInfo cbsCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .logicOpEnable = VK_FALSE,
        .logicOp = VK_LOGIC_OP_COPY,
        .attachmentCount = 1,
        .pAttachments = &pipeline->blendOpts,
        .blendConstants[0] = 0.f,
        .blendConstants[1] = 0.f,
        .blendConstants[2] = 0.f,
        .blendConstants[3] = 0.f
    };
 
    VkDynamicState dynamicStates[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
    VkPipelineDynamicStateCreateInfo dsCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .dynamicStateCount = 2,
        .pDynamicStates = dynamicStates
    };
 
    VkPipelineLayoutCreateInfo plCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .setLayoutCount = descLayoutCount,
        .pSetLayouts = descriptorLayout,
        .pushConstantRangeCount = pcRange ? 1 : 0, // for simplicity assume only one push constant range is passed, so it's not the most flexible approach
        .pPushConstantRanges = pcRange
    };
 
    VK_VERIFY(vkCreatePipelineLayout(vk_device.logical, &plCreateInfo, NULL, &pipeline->layout));
 
    // create THE pipeline
    VkGraphicsPipelineCreateInfo pCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .pNext = NULL,
        .flags = pipeline->flags,
        .stageCount = shaderCount,
        .pStages = ssCreateInfos,
        .pVertexInputState = vertexInputInfo,
        .pInputAssemblyState = &iaCreateInfo,
        .pTessellationState = NULL,
        .pViewportState = &vpCreateInfo,
        .pRasterizationState = &rCreateInfo,
        .pMultisampleState = &msCreateInfo,
        .pDepthStencilState = &dCreateInfo,
        .pColorBlendState = &cbsCreateInfo,
        .pDynamicState = &dsCreateInfo,
        .layout = pipeline->layout,
        .renderPass = renderpass->rp,
        .subpass = 0,
        .basePipelineHandle = VK_NULL_HANDLE,
        .basePipelineIndex = -1
    };
 
    VK_VERIFY(vkCreateGraphicsPipelines(vk_device.logical, VK_NULL_HANDLE, 1, &pCreateInfo, NULL, &pipeline->pl));
    free(ssCreateInfos);
}

Referenced by CreatePipelines().

QVk_CreateShader()

qvkshader_t QVk_CreateShader	(	const uint32_t *	shaderSrc,
		size_t	shaderCodeSize,
		VkShaderStageFlagBits	shaderStage
	)

Definition at line 23 of file vk_pipeline.c.

{
    qvkshader_t shader;
    VkShaderModuleCreateInfo smCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .codeSize = shaderCodeSize,
        .pCode = shaderSrc
    };
 
    VK_VERIFY(vkCreateShaderModule(vk_device.logical, &smCreateInfo, NULL, &shader.module));
 
    VkPipelineShaderStageCreateInfo vssCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .stage = shaderStage,
        .module = shader.module,
        .pName = "main",
        .pSpecializationInfo = NULL
    };
 
    shader.createInfo = vssCreateInfo;
 
    return shader;
}

QVk_CreateStagingBuffer()

VkResult QVk_CreateStagingBuffer	(	VkDeviceSize	size,
		qvkbuffer_t *	dstBuffer,
		VkMemoryPropertyFlags	reqMemFlags,
		VkMemoryPropertyFlags	prefMemFlags
	)

Definition at line 114 of file vk_buffer.c.

{
    qvkbufferopts_t stagingOpts = {
        .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
        .reqMemFlags = reqMemFlags,
        .prefMemFlags = prefMemFlags,
        .vmaUsage = VMA_MEMORY_USAGE_CPU_ONLY,
        .vmaFlags = 0
    };
 
    return QVk_CreateBuffer(size, dstBuffer, stagingOpts);
}

Referenced by createStagedBuffer(), and CreateStagingBuffers().

QVk_CreateSwapchain()

VkResult QVk_CreateSwapchain

(

void

)

Definition at line 117 of file vk_swapchain.c.

{
    VkSurfaceCapabilitiesKHR surfaceCaps;
    VkSurfaceFormatKHR *surfaceFormats = NULL;
    VkPresentModeKHR *presentModes = NULL;
    uint32_t formatCount, presentModesCount;
    VK_VERIFY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_device.physical, vk_surface, &surfaceCaps));
    VK_VERIFY(vkGetPhysicalDeviceSurfaceFormatsKHR(vk_device.physical, vk_surface, &formatCount, NULL));
    VK_VERIFY(vkGetPhysicalDeviceSurfacePresentModesKHR(vk_device.physical, vk_surface, &presentModesCount, NULL));
 
    if (formatCount > 0)
    {
        surfaceFormats = (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
        VK_VERIFY(vkGetPhysicalDeviceSurfaceFormatsKHR(vk_device.physical, vk_surface, &formatCount, surfaceFormats));
    }
 
    if (presentModesCount > 0)
    {
        presentModes = (VkPresentModeKHR *)malloc(presentModesCount * sizeof(VkPresentModeKHR));
        VK_VERIFY(vkGetPhysicalDeviceSurfacePresentModesKHR(vk_device.physical, vk_surface, &presentModesCount, presentModes));
 
        ri.Con_Printf(PRINT_ALL, "Supported present modes: ");
        for (int i = 0; i < presentModesCount; i++)
        {
            ri.Con_Printf(PRINT_ALL, "%s ", presentModeString(presentModes[i]));
            vk_config.supported_present_modes[i] = presentModeString(presentModes[i]);
        }
        ri.Con_Printf(PRINT_ALL, "\n");
    }
 
    VkSurfaceFormatKHR swapSurfaceFormat = getSwapSurfaceFormat(surfaceFormats, formatCount);
    VkPresentModeKHR swapPresentMode = getSwapPresentMode(presentModes, presentModesCount, vk_vsync->value > 0 ? VK_PRESENT_MODE_FIFO_KHR : VK_PRESENT_MODE_MAILBOX_KHR);
    free(surfaceFormats);
    free(presentModes);
 
    VkExtent2D extent = surfaceCaps.currentExtent;
    if(extent.width == UINT32_MAX || extent.height == UINT32_MAX)
    {
        extent.width = max(surfaceCaps.minImageExtent.width, min(surfaceCaps.maxImageExtent.width, vid.width));
        extent.height = max(surfaceCaps.minImageExtent.height, min(surfaceCaps.maxImageExtent.height, vid.height));
    }
 
    // request at least 2 images - this fixes fullscreen crashes on AMD when launching the game in fullscreen
    uint32_t imageCount = max(2, surfaceCaps.minImageCount);
    if (swapPresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
        imageCount = max(3, surfaceCaps.minImageCount);
 
    if (surfaceCaps.maxImageCount > 0)
        imageCount = min(imageCount, surfaceCaps.maxImageCount);
 
    VkSwapchainKHR oldSwapchain = vk_swapchain.sc;
    VkSwapchainCreateInfoKHR scCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
        .pNext = NULL,
        .flags = 0,
        .surface = vk_surface,
        .minImageCount = imageCount,
        .imageFormat = swapSurfaceFormat.format,
        .imageColorSpace = swapSurfaceFormat.colorSpace,
        .imageExtent = extent,
        .imageArrayLayers = 1,
        .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // TRANSFER_SRC_BIT is required for taking screenshots
        .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .queueFamilyIndexCount = 0,
        .pQueueFamilyIndices = NULL,
        .preTransform = surfaceCaps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ? VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR : surfaceCaps.currentTransform,
        .compositeAlpha = getSupportedCompositeAlpha(surfaceCaps.supportedCompositeAlpha),
        .presentMode = swapPresentMode,
        .clipped = VK_TRUE,
        .oldSwapchain = oldSwapchain
    };
 
    uint32_t queueFamilyIndices[] = { (uint32_t)vk_device.gfxFamilyIndex, (uint32_t)vk_device.presentFamilyIndex };
    if (vk_device.presentFamilyIndex != vk_device.gfxFamilyIndex)
    {
        scCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
        scCreateInfo.queueFamilyIndexCount = 2;
        scCreateInfo.pQueueFamilyIndices = queueFamilyIndices;
    }
 
    vk_swapchain.format = swapSurfaceFormat.format;
    vk_swapchain.extent = extent;
    ri.Con_Printf(PRINT_ALL, "...trying swapchain extent: %dx%d\n", vk_swapchain.extent.width, vk_swapchain.extent.height);
    ri.Con_Printf(PRINT_ALL, "...trying swapchain image format: %d\n", vk_swapchain.format);
 
    VkResult res = vkCreateSwapchainKHR(vk_device.logical, &scCreateInfo, NULL, &vk_swapchain.sc);
    if (res != VK_SUCCESS)
        return res;
 
    VK_VERIFY(vkGetSwapchainImagesKHR(vk_device.logical, vk_swapchain.sc, &imageCount, NULL));
    vk_swapchain.images = (VkImage *)malloc(imageCount * sizeof(VkImage));
    vk_swapchain.imageCount = imageCount;
    res = vkGetSwapchainImagesKHR(vk_device.logical, vk_swapchain.sc, &imageCount, vk_swapchain.images);
 
    if (oldSwapchain != VK_NULL_HANDLE)
        vkDestroySwapchainKHR(vk_device.logical, oldSwapchain, NULL);
 
    return res;
}

Referenced by QVk_Init(), and QVk_RecreateSwapchain().

QVk_CreateTexture()

void QVk_CreateTexture	(	qvktexture_t *	texture,
		const unsigned char *	data,
		uint32_t	width,
		uint32_t	height,
		qvksampler_t	samplerType
	)

Definition at line 382 of file vk_image.c.

{
    createTextureImage(texture, data, width, height);
    VK_VERIFY(QVk_CreateImageView(&texture->image, VK_IMAGE_ASPECT_COLOR_BIT, &texture->imageView, texture->format, texture->mipLevels));
 
    // create descriptor set for the texture
    VkDescriptorSetAllocateInfo dsAllocInfo = {
        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
        .pNext = NULL,
        .descriptorPool = vk_descriptorPool,
        .descriptorSetCount = 1,
        .pSetLayouts = &vk_samplerDescSetLayout
    };
 
    VK_VERIFY(vkAllocateDescriptorSets(vk_device.logical, &dsAllocInfo, &texture->descriptorSet));
 
    // attach sampler
    QVk_UpdateTextureSampler(texture, samplerType);
}

Referenced by Draw_StretchRaw(), LM_UploadBlock(), Vk_BeginBuildingLightmaps(), and Vk_LoadPic().

QVk_CreateUniformBuffer()

VkResult QVk_CreateUniformBuffer	(	VkDeviceSize	size,
		qvkbuffer_t *	dstBuffer,
		VkMemoryPropertyFlags	reqMemFlags,
		VkMemoryPropertyFlags	prefMemFlags
	)

Definition at line 127 of file vk_buffer.c.

{
    qvkbufferopts_t dstOpts = {
        .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
        .reqMemFlags = reqMemFlags,
        .prefMemFlags = prefMemFlags,
        .vmaUsage = VMA_MEMORY_USAGE_CPU_TO_GPU,
        // When resizing dynamic uniform buffers on Intel, the Linux driver may throw a warning:
        // "Mapping an image with layout VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used."
        // Minor annoyance but we don't want any validation warnings, so we create dedicated allocation for uniform buffer.
        // more details: https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/issues/34
        // Note that this is a false positive which in other cases could be ignored: https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/general_considerations.html#general_considerations_validation_layer_warnings
        .vmaFlags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
    };
 
    return QVk_CreateBuffer(size, dstBuffer, dstOpts);
}

Referenced by CreateDynamicBuffers(), and QVk_GetUniformBuffer().

QVk_CreateValidationLayers()

void QVk_CreateValidationLayers

(

void

)

Definition at line 74 of file vk_validation.c.

{
    VkDebugUtilsMessengerCreateInfoEXT callbackInfo = {
        .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = 0,
        .messageSeverity =  VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
                            VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
        .messageType =  VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
                        VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
                        VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
        .pfnUserCallback = debugUtilsCallback,
        .pUserData = NULL
    };
 
    if( vk_validation->value > 1 )
    {
        callbackInfo.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
                                        VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT;
    }
 
    VK_VERIFY(qvkCreateDebugUtilsMessengerEXT(vk_instance, &callbackInfo, NULL, &validationMessenger));
    ri.Con_Printf(PRINT_ALL, "...Vulkan validation layers enabled\n");
}

Referenced by QVk_Init().

QVk_CreateVertexBuffer()

void QVk_CreateVertexBuffer	(	const void *	data,
		VkDeviceSize	size,
		qvkbuffer_t *	dstBuffer,
		qvkbuffer_t *	stagingBuffer,
		VkMemoryPropertyFlags	reqMemFlags,
		VkMemoryPropertyFlags	prefMemFlags
	)

Definition at line 145 of file vk_buffer.c.

{
    qvkbufferopts_t dstOpts = {
        .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
        .reqMemFlags = reqMemFlags,
        .prefMemFlags = prefMemFlags,
        .vmaUsage = VMA_MEMORY_USAGE_GPU_ONLY,
        .vmaFlags = 0
    };
 
    createStagedBuffer(data, size, dstBuffer, dstOpts, stagingBuffer);
}

Referenced by CreateDynamicBuffers(), CreateStaticBuffers(), and QVk_GetVertexBuffer().

QVk_DestroyPipeline()

void QVk_DestroyPipeline

(

qvkpipeline_t *

pipeline

)

Definition at line 198 of file vk_pipeline.c.

{
    if (pipeline->layout != VK_NULL_HANDLE)
        vkDestroyPipelineLayout(vk_device.logical, pipeline->layout, NULL);
    if (pipeline->pl != VK_NULL_HANDLE)
        vkDestroyPipeline(vk_device.logical, pipeline->pl, NULL);
 
    pipeline->layout = VK_NULL_HANDLE;
    pipeline->pl = VK_NULL_HANDLE;
}

Referenced by QVk_Shutdown().

QVk_DestroyValidationLayers()

void QVk_DestroyValidationLayers

(

void

)

Definition at line 99 of file vk_validation.c.

{
    if( validationMessenger != VK_NULL_HANDLE )
    {
        qvkDestroyDebugUtilsMessengerEXT( vk_instance, validationMessenger, NULL );
        validationMessenger = VK_NULL_HANDLE;
    }
}

Referenced by QVk_Shutdown().

QVk_DrawColorRect()

void QVk_DrawColorRect	(	float *	ubo,
		VkDeviceSize	uboSize,
		qvkrenderpasstype_t	rpType
	)

Definition at line 2253 of file vk_common.c.

{
    uint32_t uboOffset;
    VkDescriptorSet uboDescriptorSet;
    uint8_t *vertData = QVk_GetUniformBuffer(uboSize, &uboOffset, &uboDescriptorSet);
    memcpy(vertData, ubo, uboSize);
 
    QVk_BindPipeline(&vk_drawColorQuadPipeline[rpType]);
    VkDeviceSize offsets = 0;
    vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawColorQuadPipeline[rpType].layout, 0, 1, &uboDescriptorSet, 1, &uboOffset);
    vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vk_colorRectVbo.buffer, &offsets);
    vkCmdBindIndexBuffer(vk_activeCmdbuffer, vk_rectIbo.buffer, 0, VK_INDEX_TYPE_UINT32);
    vkCmdDrawIndexed(vk_activeCmdbuffer, 6, 1, 0, 0, 0);
}

Referenced by Draw_FadeScreen(), Draw_Fill(), R_PolyBlend(), and R_SetupFrame().

QVk_DrawTexRect()

void QVk_DrawTexRect	(	float *	ubo,
		VkDeviceSize	uboSize,
		qvktexture_t *	texture
	)

Definition at line 2268 of file vk_common.c.

{
    uint32_t uboOffset;
    VkDescriptorSet uboDescriptorSet;
    uint8_t *uboData = QVk_GetUniformBuffer(uboSize, &uboOffset, &uboDescriptorSet);
    memcpy(uboData, ubo, uboSize);
 
    QVk_BindPipeline(&vk_drawTexQuadPipeline);
    VkDeviceSize offsets = 0;
    VkDescriptorSet descriptorSets[] = { texture->descriptorSet, uboDescriptorSet };
    vkCmdBindDescriptorSets(vk_activeCmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vk_drawTexQuadPipeline.layout, 0, 2, descriptorSets, 1, &uboOffset);
    vkCmdBindVertexBuffers(vk_activeCmdbuffer, 0, 1, &vk_texRectVbo.buffer, &offsets);
    vkCmdBindIndexBuffer(vk_activeCmdbuffer, vk_rectIbo.buffer, 0, VK_INDEX_TYPE_UINT32);
    vkCmdDrawIndexed(vk_activeCmdbuffer, 6, 1, 0, 0, 0);
}

Referenced by Draw_Char(), Draw_StretchPic(), Draw_StretchRaw(), and Draw_TileClear().

QVk_EndFrame()

VkResult QVk_EndFrame

(

qboolean

force

)

Definition at line 1880 of file vk_common.c.

{
    // continue only if QVk_BeginFrame() had been previously issued
    if (!vk_frameStarted)
        return VK_NOT_READY;
    // this may happen if Sys_Error is issued mid-frame, so we need to properly advance the draw pipeline
    if (force)
    {
        extern void R_EndWorldRenderpass(void);
        R_EndWorldRenderpass();
    }
 
    // submit
    QVk_SubmitStagingBuffers();
    vmaFlushAllocation(vk_malloc, vk_dynUniformBuffers[vk_activeDynBufferIdx].allocation, 0, VK_WHOLE_SIZE);
    vmaFlushAllocation(vk_malloc, vk_dynVertexBuffers[vk_activeDynBufferIdx].allocation, 0, VK_WHOLE_SIZE);
    vmaFlushAllocation(vk_malloc, vk_dynIndexBuffers[vk_activeDynBufferIdx].allocation, 0, VK_WHOLE_SIZE);
 
    vkCmdEndRenderPass(vk_commandbuffers[vk_activeBufferIdx]);
    QVk_DebugLabelEnd(&vk_commandbuffers[vk_activeBufferIdx]);
    VK_VERIFY(vkEndCommandBuffer(vk_commandbuffers[vk_activeBufferIdx]));
 
    VkPipelineStageFlags waitStages = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    VkSubmitInfo submitInfo = {
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores = &vk_imageAvailableSemaphores[vk_activeBufferIdx],
        .signalSemaphoreCount = 1,
        .pSignalSemaphores = &vk_renderFinishedSemaphores[vk_activeBufferIdx],
        .pWaitDstStageMask = &waitStages,
        .commandBufferCount = 1,
        .pCommandBuffers = &vk_commandbuffers[vk_activeBufferIdx]
    };
 
    VK_VERIFY(vkQueueSubmit(vk_device.gfxQueue, 1, &submitInfo, vk_fences[vk_activeBufferIdx]));
 
    // present
    VkPresentInfoKHR presentInfo = {
        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores = &vk_renderFinishedSemaphores[vk_activeBufferIdx],
        .swapchainCount = 1,
        .pSwapchains = &vk_swapchain.sc,
        .pImageIndices = &vk_imageIndex,
        .pResults = NULL
    };
 
    VkResult renderResult = vkQueuePresentKHR(vk_device.presentQueue, &presentInfo);
 
    // for VK_OUT_OF_DATE_KHR and VK_SUBOPTIMAL_KHR it'd be fine to just rebuild the swapchain but let's take the easy way out and restart video system
    if (renderResult == VK_ERROR_OUT_OF_DATE_KHR || renderResult == VK_SUBOPTIMAL_KHR || renderResult == VK_ERROR_SURFACE_LOST_KHR)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_EndFrame(): received %s after vkQueuePresentKHR - restarting video!\n", QVk_GetError(renderResult));
        vid_ref->modified = true;
    }
    else if (renderResult != VK_SUCCESS)
    {
        Sys_Error("QVk_EndFrame(): unexpected error after vkQueuePresentKHR: %s", QVk_GetError(renderResult));
    }
 
    vk_activeBufferIdx = (vk_activeBufferIdx + 1) % NUM_CMDBUFFERS;
 
    vk_frameStarted = false;
    return renderResult;
}

Referenced by R_BeginFrame(), and R_EndFrame().

QVk_FindDepthFormat()

VkFormat QVk_FindDepthFormat

(

void

)

Definition at line 267 of file vk_common.c.

{
    VkFormat depthFormats[] = {
        VK_FORMAT_D32_SFLOAT_S8_UINT,
        VK_FORMAT_D32_SFLOAT,
        VK_FORMAT_D24_UNORM_S8_UINT,
        VK_FORMAT_D16_UNORM_S8_UINT,
        VK_FORMAT_D16_UNORM
    };
 
    for (int i = 0; i < 5; ++i)
    {
        VkFormatProperties formatProps;
        vkGetPhysicalDeviceFormatProperties(vk_device.physical, depthFormats[i], &formatProps);
 
        if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
            return depthFormats[i];
    }
 
    return VK_FORMAT_D16_UNORM;
}

Referenced by CreateRenderpasses(), and QVk_CreateDepthBuffer().

QVk_FreeBuffer()

void QVk_FreeBuffer

(

qvkbuffer_t *

buffer

)

Definition at line 106 of file vk_buffer.c.

{
    vmaDestroyBuffer(vk_malloc, buffer->buffer, buffer->allocation);
    buffer->buffer = VK_NULL_HANDLE;
    buffer->allocation = VK_NULL_HANDLE;
    buffer->currentOffset = 0;
}

Referenced by createStagedBuffer(), QVk_ReadPixels(), QVk_Shutdown(), and ReleaseSwapBuffers().

QVk_GetError()

const char* QVk_GetError

(

VkResult

errorCode

)

Definition at line 2293 of file vk_common.c.

{
#define ERRSTR(r) case VK_ ##r: return "VK_"#r
    switch (errorCode)
    {
        ERRSTR(SUCCESS);
        ERRSTR(NOT_READY);
        ERRSTR(TIMEOUT);
        ERRSTR(EVENT_SET);
        ERRSTR(EVENT_RESET);
        ERRSTR(INCOMPLETE);
        ERRSTR(ERROR_OUT_OF_HOST_MEMORY);
        ERRSTR(ERROR_OUT_OF_DEVICE_MEMORY);
        ERRSTR(ERROR_INITIALIZATION_FAILED);
        ERRSTR(ERROR_DEVICE_LOST);
        ERRSTR(ERROR_MEMORY_MAP_FAILED);
        ERRSTR(ERROR_LAYER_NOT_PRESENT);
        ERRSTR(ERROR_EXTENSION_NOT_PRESENT);
        ERRSTR(ERROR_FEATURE_NOT_PRESENT);
        ERRSTR(ERROR_INCOMPATIBLE_DRIVER);
        ERRSTR(ERROR_TOO_MANY_OBJECTS);
        ERRSTR(ERROR_FORMAT_NOT_SUPPORTED);
        ERRSTR(ERROR_SURFACE_LOST_KHR);
        ERRSTR(ERROR_NATIVE_WINDOW_IN_USE_KHR);
        ERRSTR(SUBOPTIMAL_KHR);
        ERRSTR(ERROR_OUT_OF_DATE_KHR);
        ERRSTR(ERROR_INCOMPATIBLE_DISPLAY_KHR);
        ERRSTR(ERROR_VALIDATION_FAILED_EXT);
        ERRSTR(ERROR_INVALID_SHADER_NV);
        default: return "<unknown>";
    }
#undef ERRSTR
    return "UNKNOWN ERROR";
}

Referenced by CreateFramebuffers(), CreateRenderpasses(), QVk_BeginFrame(), QVk_CreateDevice(), QVk_EndFrame(), and QVk_Init().

QVk_GetIndexBuffer()

uint8_t* QVk_GetIndexBuffer	(	VkDeviceSize	size,
		VkDeviceSize *	dstOffset
	)

Definition at line 2058 of file vk_common.c.

{
    // align to 4 bytes, so that we can reuse the buffer for both VK_INDEX_TYPE_UINT16 and VK_INDEX_TYPE_UINT32
    const int align_mod = size % 4;
    const uint32_t aligned_size = ((size % 4) == 0) ? size : (size + 4 - align_mod);
 
    if (vk_dynIndexBuffers[vk_activeDynBufferIdx].currentOffset + aligned_size > vk_config.index_buffer_size)
    {
        vk_config.index_buffer_size = max(vk_config.index_buffer_size * BUFFER_RESIZE_FACTOR, NextPow2(size));
 
        ri.Con_Printf(PRINT_ALL, "Resizing dynamic index buffer to %ukB\n", vk_config.index_buffer_size / 1024);
        int swapBufferOffset = vk_swapBuffersCnt[vk_activeSwapBufferIdx];
        vk_swapBuffersCnt[vk_activeSwapBufferIdx] += NUM_DYNBUFFERS;
 
        if (vk_swapBuffers[vk_activeSwapBufferIdx] == NULL)
            vk_swapBuffers[vk_activeSwapBufferIdx] = malloc(sizeof(qvkbuffer_t) * vk_swapBuffersCnt[vk_activeSwapBufferIdx]);
        else
            vk_swapBuffers[vk_activeSwapBufferIdx] = realloc(vk_swapBuffers[vk_activeSwapBufferIdx], sizeof(qvkbuffer_t) * vk_swapBuffersCnt[vk_activeSwapBufferIdx]);
 
        for (int i = 0; i < NUM_DYNBUFFERS; ++i)
        {
            vk_swapBuffers[vk_activeSwapBufferIdx][swapBufferOffset + i] = vk_dynIndexBuffers[i];
            vmaUnmapMemory(vk_malloc, vk_dynIndexBuffers[i].allocation);
 
            QVk_CreateIndexBuffer(NULL, vk_config.index_buffer_size, &vk_dynIndexBuffers[i], NULL, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
            VK_VERIFY(vmaMapMemory(vk_malloc, vk_dynIndexBuffers[i].allocation, &vk_dynIndexBuffers[i].allocInfo.pMappedData));
 
            QVk_DebugSetObjectName((uint64_t)vk_dynIndexBuffers[i].buffer, VK_OBJECT_TYPE_BUFFER, va("Dynamic Index Buffer #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_dynIndexBuffers[i].allocInfo.deviceMemory, VK_OBJECT_TYPE_DEVICE_MEMORY, va("Memory: Dynamic Index Buffer #%d", i));
        }
    }
 
    *dstOffset = vk_dynIndexBuffers[vk_activeDynBufferIdx].currentOffset;
    vk_dynIndexBuffers[vk_activeDynBufferIdx].currentOffset += aligned_size;
 
    vk_config.index_buffer_usage = vk_dynIndexBuffers[vk_activeDynBufferIdx].currentOffset;
    if (vk_config.index_buffer_max_usage < vk_config.index_buffer_usage)
        vk_config.index_buffer_max_usage = vk_config.index_buffer_usage;
 
    return (uint8_t *)vk_dynIndexBuffers[vk_activeDynBufferIdx].allocInfo.pMappedData + (*dstOffset);
}

Referenced by RebuildTriangleFanIndexBuffer().

QVk_GetStagingBuffer()

uint8_t* QVk_GetStagingBuffer	(	VkDeviceSize	size,
		int	alignment,
		VkCommandBuffer *	cmdBuffer,
		VkBuffer *	buffer,
		uint32_t *	dstOffset
	)

Definition at line 2153 of file vk_common.c.

{
    qvkstagingbuffer_t * stagingBuffer = &vk_stagingBuffers[vk_activeStagingBuffer];
    const int align_mod = stagingBuffer->buffer.currentOffset % alignment;
    stagingBuffer->buffer.currentOffset = ((stagingBuffer->buffer.currentOffset % alignment) == 0)
        ? stagingBuffer->buffer.currentOffset : (stagingBuffer->buffer.currentOffset + alignment - align_mod);
 
    if (size > STAGING_BUFFER_MAXSIZE)
        Sys_Error("QVk_GetStagingBuffer(): Cannot allocate staging buffer space!");
 
    if ((stagingBuffer->buffer.currentOffset + size) >= STAGING_BUFFER_MAXSIZE && !stagingBuffer->submitted)
        SubmitStagingBuffer(vk_activeStagingBuffer);
 
    stagingBuffer = &vk_stagingBuffers[vk_activeStagingBuffer];
    if (stagingBuffer->submitted)
    {
        VK_VERIFY(vkWaitForFences(vk_device.logical, 1, &stagingBuffer->fence, VK_TRUE, UINT64_MAX));
        VK_VERIFY(vkResetFences(vk_device.logical, 1, &stagingBuffer->fence));
 
        stagingBuffer->buffer.currentOffset = 0;
        stagingBuffer->submitted = false;
 
        VkCommandBufferBeginInfo beginInfo = {
            .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
            .pNext = NULL,
            .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
            .pInheritanceInfo = NULL
        };
 
        VK_VERIFY(vkBeginCommandBuffer(stagingBuffer->cmdBuffer, &beginInfo));
    }
 
    if (cmdBuffer)
        *cmdBuffer = stagingBuffer->cmdBuffer;
    if (buffer)
        *buffer = stagingBuffer->buffer.buffer;
    if (dstOffset)
        *dstOffset = stagingBuffer->buffer.currentOffset;
 
    unsigned char *data = (uint8_t *)stagingBuffer->buffer.allocInfo.pMappedData + stagingBuffer->buffer.currentOffset;
    stagingBuffer->buffer.currentOffset += size;
 
    return data;
}

Referenced by createTextureImage(), and QVk_UpdateTextureData().

QVk_GetTriangleFanIbo()

VkBuffer QVk_GetTriangleFanIbo

(

VkDeviceSize

indexCount

)

Definition at line 2198 of file vk_common.c.

{
    if (indexCount > vk_config.triangle_fan_index_usage)
        vk_config.triangle_fan_index_usage = indexCount;
 
    if (vk_config.triangle_fan_index_usage > vk_config.triangle_fan_index_max_usage)
        vk_config.triangle_fan_index_max_usage = vk_config.triangle_fan_index_usage;
 
    if (indexCount > vk_config.triangle_fan_index_count)
    {
        vk_config.triangle_fan_index_count *= BUFFER_RESIZE_FACTOR;
        ri.Con_Printf(PRINT_ALL, "Resizing triangle fan index buffer to %u indices.\n", vk_config.triangle_fan_index_count);
        RebuildTriangleFanIndexBuffer();
    }
 
    return *vk_triangleFanIbo;
}

Referenced by DrawVkFlowingPoly(), DrawVkPoly(), EmitWaterPolys(), R_DrawNullModel(), R_RenderDlight(), Vk_DrawAliasFrameLerp(), Vk_DrawAliasShadow(), and Vk_RenderLightmappedPoly().

QVk_GetUniformBuffer()

uint8_t* QVk_GetUniformBuffer	(	VkDeviceSize	size,
		uint32_t *	dstOffset,
		VkDescriptorSet *	dstUboDescriptorSet
	)

Definition at line 2100 of file vk_common.c.

{
    // 0x100 alignment is required by Vulkan spec
    const int align_mod = size % 256;
    const uint32_t aligned_size = ((size % 256) == 0) ? size : (size + 256 - align_mod);
 
    if (vk_dynUniformBuffers[vk_activeDynBufferIdx].currentOffset + UNIFORM_ALLOC_SIZE > vk_config.uniform_buffer_size)
    {
        vk_config.uniform_buffer_size = max(vk_config.uniform_buffer_size * BUFFER_RESIZE_FACTOR, NextPow2(size));
 
        ri.Con_Printf(PRINT_ALL, "Resizing dynamic uniform buffer to %ukB\n", vk_config.uniform_buffer_size / 1024);
        int swapBufferOffset   = vk_swapBuffersCnt[vk_activeSwapBufferIdx];
        int swapDescSetsOffset = vk_swapDescSetsCnt[vk_activeSwapBufferIdx];
        vk_swapBuffersCnt[vk_activeSwapBufferIdx]  += NUM_DYNBUFFERS;
        vk_swapDescSetsCnt[vk_activeSwapBufferIdx] += NUM_DYNBUFFERS;
 
        if (vk_swapBuffers[vk_activeSwapBufferIdx] == NULL)
            vk_swapBuffers[vk_activeSwapBufferIdx] = malloc(sizeof(qvkbuffer_t) * vk_swapBuffersCnt[vk_activeSwapBufferIdx]);
        else
            vk_swapBuffers[vk_activeSwapBufferIdx] = realloc(vk_swapBuffers[vk_activeSwapBufferIdx], sizeof(qvkbuffer_t) * vk_swapBuffersCnt[vk_activeSwapBufferIdx]);
 
        if (vk_swapDescriptorSets[vk_activeSwapBufferIdx] == NULL)
            vk_swapDescriptorSets[vk_activeSwapBufferIdx] = malloc(sizeof(VkDescriptorSet) * vk_swapDescSetsCnt[vk_activeSwapBufferIdx]);
        else
            vk_swapDescriptorSets[vk_activeSwapBufferIdx] = realloc(vk_swapDescriptorSets[vk_activeSwapBufferIdx], sizeof(VkDescriptorSet) * vk_swapDescSetsCnt[vk_activeSwapBufferIdx]);
 
        for (int i = 0; i < NUM_DYNBUFFERS; ++i)
        {
            vk_swapBuffers[vk_activeSwapBufferIdx][swapBufferOffset + i] = vk_dynUniformBuffers[i];
            vk_swapDescriptorSets[vk_activeSwapBufferIdx][swapDescSetsOffset + i] = vk_uboDescriptorSets[i];;
            vmaUnmapMemory(vk_malloc, vk_dynUniformBuffers[i].allocation);
 
            VK_VERIFY(QVk_CreateUniformBuffer(vk_config.uniform_buffer_size, &vk_dynUniformBuffers[i], VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT));
            VK_VERIFY(vmaMapMemory(vk_malloc, vk_dynUniformBuffers[i].allocation, &vk_dynUniformBuffers[i].allocInfo.pMappedData));
            CreateUboDescriptorSet(&vk_uboDescriptorSets[i], vk_dynUniformBuffers[i].buffer);
 
            QVk_DebugSetObjectName((uint64_t)vk_uboDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET, va("Dynamic UBO Descriptor Set #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_dynUniformBuffers[i].buffer, VK_OBJECT_TYPE_BUFFER, va("Dynamic Uniform Buffer #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_dynUniformBuffers[i].allocInfo.deviceMemory, VK_OBJECT_TYPE_DEVICE_MEMORY, va("Memory: Dynamic Uniform Buffer #%d", i));
        }
    }
 
    *dstOffset = vk_dynUniformBuffers[vk_activeDynBufferIdx].currentOffset;
    *dstUboDescriptorSet = vk_uboDescriptorSets[vk_activeDynBufferIdx];
    vk_dynUniformBuffers[vk_activeDynBufferIdx].currentOffset += aligned_size;
 
    vk_config.uniform_buffer_usage = vk_dynUniformBuffers[vk_activeDynBufferIdx].currentOffset;
    if (vk_config.uniform_buffer_max_usage < vk_config.uniform_buffer_usage)
        vk_config.uniform_buffer_max_usage = vk_config.uniform_buffer_usage;
 
    return (uint8_t *)vk_dynUniformBuffers[vk_activeDynBufferIdx].allocInfo.pMappedData + (*dstOffset);
}

Referenced by DrawVkFlowingPoly(), DrawVkPoly(), EmitWaterPolys(), QVk_DrawColorRect(), QVk_DrawTexRect(), R_DrawBeam(), R_DrawNullModel(), R_DrawParticles(), R_DrawSkyBox(), R_DrawTriangleOutlines(), R_RenderDlight(), Vk_DrawAliasFrameLerp(), Vk_DrawAliasShadow(), and Vk_RenderLightmappedPoly().

QVk_GetVertexBuffer()

uint8_t* QVk_GetVertexBuffer	(	VkDeviceSize	size,
		VkBuffer *	dstBuffer,
		VkDeviceSize *	dstOffset
	)

Definition at line 2019 of file vk_common.c.

{
    if (vk_dynVertexBuffers[vk_activeDynBufferIdx].currentOffset + size > vk_config.vertex_buffer_size)
    {
        vk_config.vertex_buffer_size = max(vk_config.vertex_buffer_size * BUFFER_RESIZE_FACTOR, NextPow2(size));
 
        ri.Con_Printf(PRINT_ALL, "Resizing dynamic vertex buffer to %ukB\n", vk_config.vertex_buffer_size / 1024);
        int swapBufferOffset = vk_swapBuffersCnt[vk_activeSwapBufferIdx];
        vk_swapBuffersCnt[vk_activeSwapBufferIdx] += NUM_DYNBUFFERS;
 
        if (vk_swapBuffers[vk_activeSwapBufferIdx] == NULL)
            vk_swapBuffers[vk_activeSwapBufferIdx] = malloc(sizeof(qvkbuffer_t) * vk_swapBuffersCnt[vk_activeSwapBufferIdx]);
        else
            vk_swapBuffers[vk_activeSwapBufferIdx] = realloc(vk_swapBuffers[vk_activeSwapBufferIdx], sizeof(qvkbuffer_t) * vk_swapBuffersCnt[vk_activeSwapBufferIdx]);
 
        for (int i = 0; i < NUM_DYNBUFFERS; ++i)
        {
            vk_swapBuffers[vk_activeSwapBufferIdx][swapBufferOffset + i] = vk_dynVertexBuffers[i];
            vmaUnmapMemory(vk_malloc, vk_dynVertexBuffers[i].allocation);
 
            QVk_CreateVertexBuffer(NULL, vk_config.vertex_buffer_size, &vk_dynVertexBuffers[i], NULL, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
            VK_VERIFY(vmaMapMemory(vk_malloc, vk_dynVertexBuffers[i].allocation, &vk_dynVertexBuffers[i].allocInfo.pMappedData));
 
            QVk_DebugSetObjectName((uint64_t)vk_dynVertexBuffers[i].buffer, VK_OBJECT_TYPE_BUFFER, va("Dynamic Vertex Buffer #%d", i));
            QVk_DebugSetObjectName((uint64_t)vk_dynVertexBuffers[i].allocInfo.deviceMemory, VK_OBJECT_TYPE_DEVICE_MEMORY, va("Memory: Dynamic Vertex Buffer #%d", i));
        }
    }
 
    *dstOffset = vk_dynVertexBuffers[vk_activeDynBufferIdx].currentOffset;
    *dstBuffer = vk_dynVertexBuffers[vk_activeDynBufferIdx].buffer;
    vk_dynVertexBuffers[vk_activeDynBufferIdx].currentOffset += size;
 
    vk_config.vertex_buffer_usage = vk_dynVertexBuffers[vk_activeDynBufferIdx].currentOffset;
    if (vk_config.vertex_buffer_max_usage < vk_config.vertex_buffer_usage)
        vk_config.vertex_buffer_max_usage = vk_config.vertex_buffer_usage;
    
    return (uint8_t *)vk_dynVertexBuffers[vk_activeDynBufferIdx].allocInfo.pMappedData + (*dstOffset);
}

Referenced by DrawVkFlowingPoly(), DrawVkPoly(), EmitWaterPolys(), R_DrawBeam(), R_DrawNullModel(), R_DrawParticles(), R_DrawSkyBox(), R_DrawSpriteModel(), R_DrawTriangleOutlines(), R_RenderDlight(), Vk_DrawAliasFrameLerp(), Vk_DrawAliasShadow(), Vk_DrawParticles(), and Vk_RenderLightmappedPoly().

QVk_Init()

qboolean QVk_Init

(

void

)

Definition at line 1510 of file vk_common.c.

{
    PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion)vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion");
    uint32_t instanceVersion = VK_API_VERSION_1_0;
 
    if (vkEnumerateInstanceVersion)
    {
        VK_VERIFY(vkEnumerateInstanceVersion(&instanceVersion));
    }
 
    VkApplicationInfo appInfo = {
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext = NULL,
        .pApplicationName = "Quake 2",
        .applicationVersion = VK_MAKE_VERSION(3, 21, 0),
        .pEngineName = "id Tech 2",
        .engineVersion = VK_MAKE_VERSION(2, 0, 0),
        .apiVersion = instanceVersion
    };
 
    uint32_t extCount;
    char **wantedExtensions;
    memset((char*)vk_config.supported_present_modes, 0, 256);
    memset((char*)vk_config.extensions, 0, 256);
    memset((char*)vk_config.layers, 0, 256);
    vk_config.vk_version = instanceVersion;
    vk_config.vertex_buffer_usage  = 0;
    vk_config.vertex_buffer_max_usage = 0;
    vk_config.vertex_buffer_size   = VERTEX_BUFFER_SIZE;
    vk_config.index_buffer_usage   = 0;
    vk_config.index_buffer_max_usage = 0;
    vk_config.index_buffer_size    = INDEX_BUFFER_SIZE;
    vk_config.uniform_buffer_usage = 0;
    vk_config.uniform_buffer_max_usage = 0;
    vk_config.uniform_buffer_size  = UNIFORM_BUFFER_SIZE;
    vk_config.triangle_fan_index_usage = 0;
    vk_config.triangle_fan_index_max_usage = 0;
    vk_config.triangle_fan_index_count = TRIANGLE_FAN_INDEX_CNT;
 
    Vkimp_GetSurfaceExtensions(NULL, &extCount);
 
    if (vk_validation->value)
        extCount++;
#if defined(_DEBUG) || defined(ENABLE_DEBUG_LABELS)
    else
        extCount++;
#endif
 
    wantedExtensions = (char **)malloc(extCount * sizeof(const char *));
    Vkimp_GetSurfaceExtensions(wantedExtensions, NULL);
 
    if (vk_validation->value)
        wantedExtensions[extCount - 1] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
#if defined(_DEBUG) || defined(ENABLE_DEBUG_LABELS)
    else
        wantedExtensions[extCount - 1] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
#endif
 
    ri.Con_Printf(PRINT_ALL, "Enabled extensions: ");
    for (int i = 0; i < extCount; i++)
    {
        ri.Con_Printf(PRINT_ALL, "%s ", wantedExtensions[i]);
        vk_config.extensions[i] = wantedExtensions[i];
    }
    ri.Con_Printf(PRINT_ALL, "\n");
 
    VkInstanceCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext = NULL,
        .pApplicationInfo = &appInfo,
        .enabledLayerCount = 0,
        .ppEnabledLayerNames = NULL,
        .enabledExtensionCount = extCount,
        .ppEnabledExtensionNames = (const char* const*)wantedExtensions
    };
 
#if VK_HEADER_VERSION > 101
    const char *validationLayers[] = { "VK_LAYER_KHRONOS_validation" };
#else
    const char *validationLayers[] = { "VK_LAYER_LUNARG_standard_validation" };
#endif
 
    if (vk_validation->value)
    {
        createInfo.enabledLayerCount = sizeof(validationLayers) / sizeof(validationLayers[0]);
        createInfo.ppEnabledLayerNames = validationLayers;
        for (int i = 0; i < createInfo.enabledLayerCount; i++)
        {
            vk_config.layers[i] = validationLayers[i];
        }
    }
 
    VkResult res = vkCreateInstance(&createInfo, NULL, &vk_instance);
    free(wantedExtensions);
 
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan instance: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created Vulkan instance\n");
 
    // initialize function pointers
    qvkCreateDebugUtilsMessengerEXT  = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(vk_instance, "vkCreateDebugUtilsMessengerEXT");
    qvkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(vk_instance, "vkDestroyDebugUtilsMessengerEXT");
    qvkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(vk_instance, "vkSetDebugUtilsObjectNameEXT");
    qvkSetDebugUtilsObjectTagEXT  = (PFN_vkSetDebugUtilsObjectTagEXT)vkGetInstanceProcAddr(vk_instance, "vkSetDebugUtilsObjectTagEXT");
    qvkCmdBeginDebugUtilsLabelEXT = (PFN_vkCmdBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(vk_instance, "vkCmdBeginDebugUtilsLabelEXT");
    qvkCmdEndDebugUtilsLabelEXT   = (PFN_vkCmdEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(vk_instance, "vkCmdEndDebugUtilsLabelEXT");
    qvkInsertDebugUtilsLabelEXT   = (PFN_vkCmdInsertDebugUtilsLabelEXT)vkGetInstanceProcAddr(vk_instance, "vkCmdInsertDebugUtilsLabelEXT");
 
    if (vk_validation->value)
        QVk_CreateValidationLayers();
 
    res = Vkimp_CreateSurface();
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan surface: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created Vulkan surface\n");
 
    // create Vulkan device - see if the user prefers any specific device if there's more than one GPU in the system
    QVk_CreateDevice((int)vk_device_idx->value);
    QVk_DebugSetObjectName((uint64_t)vk_device.physical, VK_OBJECT_TYPE_PHYSICAL_DEVICE, va("Physical Device: %s", vk_config.vendor_name));
 
    // create memory allocator
    VmaAllocatorCreateInfo allocInfo = {
        .flags = 0,
        .physicalDevice = vk_device.physical,
        .device = vk_device.logical,
        .preferredLargeHeapBlockSize = 0,
        .pAllocationCallbacks = NULL,
        .pDeviceMemoryCallbacks = NULL,
        .frameInUseCount = 0,
        .pHeapSizeLimit = NULL,
        .pVulkanFunctions = NULL,
        .pRecordSettings = NULL
    };
 
    res = vmaCreateAllocator(&allocInfo, &vk_malloc);
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan memory allocator: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created Vulkan memory allocator\n");
 
    // setup swapchain
    res = QVk_CreateSwapchain();
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan swapchain: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created Vulkan swapchain\n");
 
    // set viewport and scissor
    vk_viewport.x = 0.f;
    vk_viewport.y = 0.f;
    vk_viewport.minDepth = 0.f;
    vk_viewport.maxDepth = 1.f;
    vk_viewport.width = (float)vid.width;
    vk_viewport.height = (float)vid.height;
    vk_scissor.offset.x = 0;
    vk_scissor.offset.y = 0;
    vk_scissor.extent = vk_swapchain.extent;
 
    // setup fences and semaphores
    VkFenceCreateInfo fCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
        .pNext = NULL,
        .flags = VK_FENCE_CREATE_SIGNALED_BIT
    };
    VkSemaphoreCreateInfo sCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0
    };
    for (int i = 0; i < NUM_CMDBUFFERS; ++i)
    {
        VK_VERIFY(vkCreateFence(vk_device.logical, &fCreateInfo, NULL, &vk_fences[i]));
        VK_VERIFY(vkCreateSemaphore(vk_device.logical, &sCreateInfo, NULL, &vk_imageAvailableSemaphores[i]));
        VK_VERIFY(vkCreateSemaphore(vk_device.logical, &sCreateInfo, NULL, &vk_renderFinishedSemaphores[i]));
 
        QVk_DebugSetObjectName((uint64_t)vk_fences[i], VK_OBJECT_TYPE_FENCE, va("Fence #%d", i));
        QVk_DebugSetObjectName((uint64_t)vk_imageAvailableSemaphores[i], VK_OBJECT_TYPE_SEMAPHORE, va("Semaphore: image available #%d", i));
        QVk_DebugSetObjectName((uint64_t)vk_renderFinishedSemaphores[i], VK_OBJECT_TYPE_SEMAPHORE, va("Semaphore: render finished #%d", i));
    }
    ri.Con_Printf(PRINT_ALL, "...created synchronization objects\n");
 
    // setup render passes
    for (int i = 0; i < RP_COUNT; ++i)
    {
        vk_renderpasses[i].colorLoadOp = vk_clear->value ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    }
 
    VkSampleCountFlagBits msaaMode = GetSampleCount();
    VkSampleCountFlagBits supportedMsaa = vk_device.properties.limits.framebufferColorSampleCounts;
    if (!(supportedMsaa & msaaMode))
    {
        ri.Con_Printf(PRINT_ALL, "MSAAx%d mode not supported, aborting...\n", msaaMode);
        ri.Cvar_Set("vk_msaa", "0");
        msaaMode = VK_SAMPLE_COUNT_1_BIT;
        // avoid secondary video reload
        vk_msaa->modified = false;
    }
 
    // MSAA setting will be only relevant for the primary world render pass
    vk_renderpasses[RP_WORLD].sampleCount = msaaMode;
 
    res = CreateRenderpasses();
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan render passes: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created %d Vulkan render passes\n", RP_COUNT);
 
    // setup command pools
    res = QVk_CreateCommandPool(&vk_commandPool, vk_device.gfxFamilyIndex);
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan command pool for graphics: %s\n", QVk_GetError(res));
        return false;
    }
    res = QVk_CreateCommandPool(&vk_transferCommandPool, vk_device.transferFamilyIndex);
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan command pool for transfer: %s\n", QVk_GetError(res));
        return false;
    }
 
    QVk_DebugSetObjectName((uint64_t)vk_commandPool, VK_OBJECT_TYPE_COMMAND_POOL, "Command Pool: Graphics");
    QVk_DebugSetObjectName((uint64_t)vk_transferCommandPool, VK_OBJECT_TYPE_COMMAND_POOL, "Command Pool: Transfer");
    ri.Con_Printf(PRINT_ALL, "...created Vulkan command pools\n");
 
    // setup draw buffers
    CreateDrawBuffers();
 
    // setup image views
    res = CreateImageViews();
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan image views: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created %d Vulkan image view(s)\n", vk_swapchain.imageCount);
 
    // setup framebuffers
    res = CreateFramebuffers();
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan framebuffers: %s\n", QVk_GetError(res));
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created %d Vulkan framebuffers\n", vk_swapchain.imageCount);
 
    // setup command buffers (double buffering)
    vk_commandbuffers = (VkCommandBuffer *)malloc(NUM_CMDBUFFERS * sizeof(VkCommandBuffer));
 
    VkCommandBufferAllocateInfo cbInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .pNext = NULL,
        .commandPool = vk_commandPool,
        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = NUM_CMDBUFFERS
    };
 
    res = vkAllocateCommandBuffers(vk_device.logical, &cbInfo, vk_commandbuffers);
    if (res != VK_SUCCESS)
    {
        ri.Con_Printf(PRINT_ALL, "QVk_Init(): Could not create Vulkan commandbuffers: %s\n", QVk_GetError(res));
        free(vk_commandbuffers);
        vk_commandbuffers = NULL;
        return false;
    }
    ri.Con_Printf(PRINT_ALL, "...created %d Vulkan commandbuffers\n", NUM_CMDBUFFERS);
 
    // initialize tracker variables
    vk_activeCmdbuffer = vk_commandbuffers[vk_activeBufferIdx];
 
    CreateDescriptorSetLayouts();
    CreateDescriptorPool();
    // create static vertex/index buffers reused in the games
    CreateStaticBuffers();
    // create vertex, index and uniform buffer pools
    CreateDynamicBuffers();
    // create staging buffers
    CreateStagingBuffers();
    // assign a dynamic index buffer for triangle fan emulation
    RebuildTriangleFanIndexBuffer();
    CreatePipelines();
    CreateSamplers();
 
    // main and world warp color buffers will be sampled for postprocessing effects, so they need descriptors and samplers
    VkDescriptorSetAllocateInfo dsAllocInfo = {
        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
        .pNext = NULL,
        .descriptorPool = vk_descriptorPool,
        .descriptorSetCount = 1,
        .pSetLayouts = &vk_samplerDescSetLayout
    };
 
    VK_VERIFY(vkAllocateDescriptorSets(vk_device.logical, &dsAllocInfo, &vk_colorbuffer.descriptorSet));
    QVk_UpdateTextureSampler(&vk_colorbuffer, S_NEAREST);
    VK_VERIFY(vkAllocateDescriptorSets(vk_device.logical, &dsAllocInfo, &vk_colorbufferWarp.descriptorSet));
    QVk_UpdateTextureSampler(&vk_colorbufferWarp, S_NEAREST);
 
    QVk_DebugSetObjectName((uint64_t)vk_colorbuffer.descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET, "Descriptor Set: World Color Buffer");
    QVk_DebugSetObjectName((uint64_t)vk_colorbufferWarp.descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET, "Descriptor Set: Warp Postprocess Color Buffer");
    return true;
}

Referenced by R_Init().

QVk_ReadPixels()

void QVk_ReadPixels	(	uint8_t *	dstBuffer,
		uint32_t	width,
		uint32_t	height
	)

Definition at line 465 of file vk_image.c.

{
    qvkbuffer_t buff;
    VkCommandBuffer cmdBuffer;
    qvkbufferopts_t buffOpts = {
        .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
        .reqMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        .prefMemFlags = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
        .vmaUsage = VMA_MEMORY_USAGE_CPU_ONLY,
        // When taking a screenshot on Intel, the Linux driver may throw a warning:
        // "Mapping an image with layout VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used."
        // Minor annoyance but we don't want any validation warnings, so we create dedicated allocation for the image buffer.
        // more details: https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/issues/34
        // Note that this is a false positive which in other cases could be ignored: https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/general_considerations.html#general_considerations_validation_layer_warnings
        .vmaFlags = VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
    };
 
    VK_VERIFY(QVk_CreateBuffer(width * height * 4, &buff, buffOpts));
    cmdBuffer = QVk_CreateCommandBuffer(&vk_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
    VK_VERIFY(QVk_BeginCommand(&cmdBuffer));
    
    // transition the current swapchain image to be a source of data transfer to our buffer
    extern int vk_activeBufferIdx;
    VkImageMemoryBarrier imgBarrier = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .pNext = NULL,
        .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
        .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
        .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .image = vk_swapchain.images[vk_activeBufferIdx],
        .subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
        .subresourceRange.baseMipLevel = 0,
        .subresourceRange.baseArrayLayer = 0,
        .subresourceRange.layerCount = 1,
        .subresourceRange.levelCount = 1
    };
 
    vkCmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &imgBarrier);
 
    VkBufferImageCopy region = {
        .bufferOffset = 0,
        .bufferRowLength = width,
        .bufferImageHeight = height,
        .imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
        .imageSubresource.mipLevel = 0,
        .imageSubresource.baseArrayLayer = 0,
        .imageSubresource.layerCount = 1,
        .imageOffset = { 0, 0, 0 },
        .imageExtent = { width, height, 1 }
    };
 
    // copy the swapchain image
    vkCmdCopyImageToBuffer(cmdBuffer, vk_swapchain.images[vk_activeBufferIdx], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buff.buffer, 1, &region);
    VK_VERIFY(vkDeviceWaitIdle(vk_device.logical));
    QVk_SubmitCommand(&cmdBuffer, &vk_device.gfxQueue);
 
    // store image in destination buffer
    memcpy(dstBuffer, (uint8_t *)buff.allocInfo.pMappedData, width * height * 4);
 
    QVk_FreeBuffer(&buff);
}

Referenced by Vk_ScreenShot_f().

QVk_RecreateSwapchain()

void QVk_RecreateSwapchain

(

void

)

Definition at line 2004 of file vk_common.c.

{
    vkDeviceWaitIdle( vk_device.logical );
    DestroyFramebuffers();
    DestroyImageViews();
    VK_VERIFY(QVk_CreateSwapchain());
    vk_viewport.width = (float)vid.width;
    vk_viewport.height = (float)vid.height;
    vk_scissor.extent = vk_swapchain.extent;
    DestroyDrawBuffers();
    CreateDrawBuffers();
    VK_VERIFY(CreateImageViews());
    VK_VERIFY(CreateFramebuffers());
}

QVk_ReleaseTexture()

void QVk_ReleaseTexture

(

qvktexture_t *

texture

)

Definition at line 448 of file vk_image.c.

{
    QVk_SubmitStagingBuffers();
    vkDeviceWaitIdle(vk_device.logical);
 
    if (texture->image != VK_NULL_HANDLE)
        vmaDestroyImage(vk_malloc, texture->image, texture->allocation);
    if (texture->imageView != VK_NULL_HANDLE)
        vkDestroyImageView(vk_device.logical, texture->imageView, NULL);
    if (texture->descriptorSet != VK_NULL_HANDLE)
        vkFreeDescriptorSets(vk_device.logical, vk_descriptorPool, 1, &texture->descriptorSet);
 
    texture->image = VK_NULL_HANDLE;
    texture->imageView = VK_NULL_HANDLE;
    texture->descriptorSet = VK_NULL_HANDLE;
}

Referenced by Vk_FreeUnusedImages(), and Vk_ShutdownImages().

QVk_Shutdown()

void QVk_Shutdown

(

void

)

Definition at line 1376 of file vk_common.c.

{
    if (vk_instance != VK_NULL_HANDLE)
    {
        ri.Con_Printf(PRINT_ALL, "Shutting down Vulkan\n");
 
        for (int i = 0; i < 2; ++i)
        {
            QVk_DestroyPipeline(&vk_drawColorQuadPipeline[i]);
            QVk_DestroyPipeline(&vk_drawModelPipelineStrip[i]);
            QVk_DestroyPipeline(&vk_drawModelPipelineFan[i]);
        }
        QVk_DestroyPipeline(&vk_drawTexQuadPipeline);
        QVk_DestroyPipeline(&vk_drawNullModelPipeline);
        QVk_DestroyPipeline(&vk_drawNoDepthModelPipelineStrip);
        QVk_DestroyPipeline(&vk_drawNoDepthModelPipelineFan);
        QVk_DestroyPipeline(&vk_drawLefthandModelPipelineStrip);
        QVk_DestroyPipeline(&vk_drawLefthandModelPipelineFan);
        QVk_DestroyPipeline(&vk_drawParticlesPipeline);
        QVk_DestroyPipeline(&vk_drawPointParticlesPipeline);
        QVk_DestroyPipeline(&vk_drawSpritePipeline);
        QVk_DestroyPipeline(&vk_drawPolyPipeline);
        QVk_DestroyPipeline(&vk_drawPolyLmapPipeline);
        QVk_DestroyPipeline(&vk_drawPolyWarpPipeline);
        QVk_DestroyPipeline(&vk_drawBeamPipeline);
        QVk_DestroyPipeline(&vk_drawSkyboxPipeline);
        QVk_DestroyPipeline(&vk_drawDLightPipeline);
        QVk_DestroyPipeline(&vk_showTrisPipeline);
        QVk_DestroyPipeline(&vk_shadowsPipelineStrip);
        QVk_DestroyPipeline(&vk_shadowsPipelineFan);
        QVk_DestroyPipeline(&vk_worldWarpPipeline);
        QVk_DestroyPipeline(&vk_postprocessPipeline);
        QVk_FreeBuffer(&vk_texRectVbo);
        QVk_FreeBuffer(&vk_colorRectVbo);
        QVk_FreeBuffer(&vk_rectIbo);
        for (int i = 0; i < NUM_DYNBUFFERS; ++i)
        {
            if (vk_dynUniformBuffers[i].buffer != VK_NULL_HANDLE)
            {
                vmaUnmapMemory(vk_malloc, vk_dynUniformBuffers[i].allocation);
                QVk_FreeBuffer(&vk_dynUniformBuffers[i]);
            }
            if (vk_dynIndexBuffers[i].buffer != VK_NULL_HANDLE)
            {
                vmaUnmapMemory(vk_malloc, vk_dynIndexBuffers[i].allocation);
                QVk_FreeBuffer(&vk_dynIndexBuffers[i]);
            }
            if (vk_dynVertexBuffers[i].buffer != VK_NULL_HANDLE)
            {
                vmaUnmapMemory(vk_malloc, vk_dynVertexBuffers[i].allocation);
                QVk_FreeBuffer(&vk_dynVertexBuffers[i]);
            }
            if (vk_stagingBuffers[i].buffer.buffer != VK_NULL_HANDLE)
            {
                vmaUnmapMemory(vk_malloc, vk_stagingBuffers[i].buffer.allocation);
                QVk_FreeBuffer(&vk_stagingBuffers[i].buffer);
                vkDestroyFence(vk_device.logical, vk_stagingBuffers[i].fence, NULL);
            }
        }
        if (vk_descriptorPool != VK_NULL_HANDLE)
            vkDestroyDescriptorPool(vk_device.logical, vk_descriptorPool, NULL);
        if (vk_uboDescSetLayout != VK_NULL_HANDLE)
            vkDestroyDescriptorSetLayout(vk_device.logical, vk_uboDescSetLayout, NULL);
        if (vk_samplerDescSetLayout != VK_NULL_HANDLE)
            vkDestroyDescriptorSetLayout(vk_device.logical, vk_samplerDescSetLayout, NULL);
        if (vk_samplerLightmapDescSetLayout != VK_NULL_HANDLE)
            vkDestroyDescriptorSetLayout(vk_device.logical, vk_samplerLightmapDescSetLayout, NULL);
        for (int i = 0; i < RP_COUNT; i++)
        {
            if (vk_renderpasses[i].rp != VK_NULL_HANDLE)
                vkDestroyRenderPass(vk_device.logical, vk_renderpasses[i].rp, NULL);
            vk_renderpasses[i].rp = VK_NULL_HANDLE;
        }
        if (vk_commandbuffers)
        {
            vkFreeCommandBuffers(vk_device.logical, vk_commandPool, NUM_CMDBUFFERS, vk_commandbuffers);
            free(vk_commandbuffers);
            vk_commandbuffers = NULL;
        }
        if (vk_commandPool != VK_NULL_HANDLE)
            vkDestroyCommandPool(vk_device.logical, vk_commandPool, NULL);
        if (vk_transferCommandPool != VK_NULL_HANDLE)
            vkDestroyCommandPool(vk_device.logical, vk_transferCommandPool, NULL);
        if (vk_stagingCommandPool != VK_NULL_HANDLE)
            vkDestroyCommandPool(vk_device.logical, vk_stagingCommandPool, NULL);
        DestroySamplers();
        DestroyFramebuffers();
        DestroyImageViews();
        DestroyDrawBuffers();
        if (vk_swapchain.sc != VK_NULL_HANDLE)
        {
            vkDestroySwapchainKHR(vk_device.logical, vk_swapchain.sc, NULL);
            free(vk_swapchain.images);
            vk_swapchain.sc = VK_NULL_HANDLE;
            vk_swapchain.images = NULL;
            vk_swapchain.imageCount = 0;
        }
        for (int i = 0; i < NUM_CMDBUFFERS; ++i)
        {
            vkDestroySemaphore(vk_device.logical, vk_imageAvailableSemaphores[i], NULL);
            vkDestroySemaphore(vk_device.logical, vk_renderFinishedSemaphores[i], NULL);
            vkDestroyFence(vk_device.logical, vk_fences[i], NULL);
        }
        if (vk_malloc != VK_NULL_HANDLE)
            vmaDestroyAllocator(vk_malloc);
        if (vk_device.logical != VK_NULL_HANDLE)
            vkDestroyDevice(vk_device.logical, NULL);
        if(vk_surface != VK_NULL_HANDLE)
            vkDestroySurfaceKHR(vk_instance, vk_surface, NULL);
        QVk_DestroyValidationLayers();
 
        vkDestroyInstance(vk_instance, NULL);
        vk_instance = VK_NULL_HANDLE;
        vk_activeCmdbuffer = VK_NULL_HANDLE;
        vk_descriptorPool = VK_NULL_HANDLE;
        vk_uboDescSetLayout = VK_NULL_HANDLE;
        vk_samplerDescSetLayout = VK_NULL_HANDLE;
        vk_samplerLightmapDescSetLayout = VK_NULL_HANDLE;
        vk_commandPool = VK_NULL_HANDLE;
        vk_transferCommandPool = VK_NULL_HANDLE;
        vk_stagingCommandPool = VK_NULL_HANDLE;
        vk_activeBufferIdx = 0;
        vk_imageIndex = 0;
    }
}

Referenced by R_Shutdown().

QVk_SubmitCommand()

void QVk_SubmitCommand	(	const VkCommandBuffer *	commandBuffer,
		const VkQueue *	queue
	)

Definition at line 35 of file vk_cmd.c.

{
    VK_VERIFY(vkEndCommandBuffer(*commandBuffer));
 
    VkSubmitInfo submitInfo = {
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .pNext = NULL,
        .waitSemaphoreCount = 0,
        .pWaitSemaphores = NULL,
        .pWaitDstStageMask = NULL,
        .commandBufferCount = 1,
        .pCommandBuffers = commandBuffer,
        .signalSemaphoreCount = 0,
        .pSignalSemaphores = NULL
    };
 
    VkFenceCreateInfo fCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0
    };
 
    VkFence queueFence;
    VK_VERIFY(vkCreateFence(vk_device.logical, &fCreateInfo, NULL, &queueFence));
    VK_VERIFY(vkQueueSubmit(*queue, 1, &submitInfo, queueFence));
    VK_VERIFY(vkWaitForFences(vk_device.logical, 1, &queueFence, VK_TRUE, UINT64_MAX));
 
    vkDestroyFence(vk_device.logical, queueFence, NULL);
}

Referenced by copyBuffer(), and QVk_ReadPixels().

QVk_SubmitStagingBuffers()

void QVk_SubmitStagingBuffers

(

void

)

Definition at line 2216 of file vk_common.c.

{
    for (int i = 0; i < NUM_DYNBUFFERS; ++i)
    {
        if (!vk_stagingBuffers[i].submitted && vk_stagingBuffers[i].buffer.currentOffset > 0)
            SubmitStagingBuffer(i);
    }
}

Referenced by QVk_EndFrame(), and QVk_ReleaseTexture().

QVk_UpdateTextureData()

void QVk_UpdateTextureData	(	qvktexture_t *	texture,
		const unsigned char *	data,
		uint32_t	offset_x,
		uint32_t	offset_y,
		uint32_t	width,
		uint32_t	height
	)

Definition at line 402 of file vk_image.c.

{
    int unifiedTransferAndGfx = vk_device.transferQueue == vk_device.gfxQueue ? 1 : 0;
    // assuming 32bit images
    uint32_t imageSize = width * height * 4;
 
    VkBuffer staging_buffer;
    VkCommandBuffer command_buffer;
    uint32_t staging_offset;
    void *imgData = QVk_GetStagingBuffer(imageSize, 4, &command_buffer, &staging_buffer, &staging_offset);
    memcpy(imgData, data, (size_t)imageSize);
 
    transitionImageLayout(&command_buffer, &vk_device.transferQueue, texture, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
    // copy buffer to image
    VkBufferImageCopy region = {
        .bufferOffset = staging_offset,
        .bufferRowLength = 0,
        .bufferImageHeight = 0,
        .imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
        .imageSubresource.mipLevel = 0,
        .imageSubresource.baseArrayLayer = 0,
        .imageSubresource.layerCount = 1,
        .imageOffset = { offset_x, offset_y, 0 },
        .imageExtent = { width, height, 1 }
    };
 
    vkCmdCopyBufferToImage(command_buffer, staging_buffer, texture->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
 
    if (texture->mipLevels > 1)
    {
        // vkCmdBlitImage requires a queue with GRAPHICS_BIT present
        generateMipmaps(&command_buffer, texture, width, height);
    }
    else
    {
        // for non-unified transfer and graphics, this step begins queue ownership transfer to graphics queue (for exclusive sharing only)
        if (unifiedTransferAndGfx || texture->sharingMode == VK_SHARING_MODE_EXCLUSIVE)
            transitionImageLayout(&command_buffer, &vk_device.transferQueue, texture, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 
        if (!unifiedTransferAndGfx)
        {
            transitionImageLayout(&command_buffer, &vk_device.gfxQueue, texture, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
        }
    }
}

Referenced by Draw_StretchRaw(), LM_UploadBlock(), R_RenderBrushPoly(), Vk_LoadPic(), and Vk_RenderLightmappedPoly().

QVk_UpdateTextureSampler()

VkSampler QVk_UpdateTextureSampler	(	qvktexture_t *	texture,
		qvksampler_t	samplerType
	)

Definition at line 2225 of file vk_common.c.

{
    assert((vk_samplers[samplerType] != VK_NULL_HANDLE) && "Sampler is VK_NULL_HANDLE!");
 
    VkDescriptorImageInfo dImgInfo = {
        .sampler = vk_samplers[samplerType],
        .imageView = texture->imageView,
        .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
    };
 
    VkWriteDescriptorSet writeSet = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .pNext = NULL,
        .dstSet = texture->descriptorSet,
        .dstBinding = 0,
        .dstArrayElement = 0,
        .descriptorCount = 1,
        .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
        .pImageInfo = &dImgInfo,
        .pBufferInfo = NULL,
        .pTexelBufferView = NULL
    };
 
    vkUpdateDescriptorSets(vk_device.logical, 1, &writeSet, 0, NULL);
 
    return vk_samplers[samplerType];
}

Referenced by QVk_CreateTexture(), QVk_Init(), Vk_LmapTextureMode(), and Vk_TextureMode().

Variable Documentation

qvkCmdBeginDebugUtilsLabelEXT

PFN_vkCmdBeginDebugUtilsLabelEXT qvkCmdBeginDebugUtilsLabelEXT

Definition at line 170 of file vk_common.c.

Referenced by QVk_Init().

qvkCmdEndDebugUtilsLabelEXT

PFN_vkCmdEndDebugUtilsLabelEXT qvkCmdEndDebugUtilsLabelEXT

Definition at line 171 of file vk_common.c.

Referenced by QVk_Init().

qvkCreateDebugUtilsMessengerEXT

PFN_vkCreateDebugUtilsMessengerEXT qvkCreateDebugUtilsMessengerEXT

Definition at line 166 of file vk_common.c.

Referenced by QVk_CreateValidationLayers(), and QVk_Init().

qvkDestroyDebugUtilsMessengerEXT

PFN_vkDestroyDebugUtilsMessengerEXT qvkDestroyDebugUtilsMessengerEXT

Definition at line 167 of file vk_common.c.

Referenced by QVk_DestroyValidationLayers(), and QVk_Init().

qvkInsertDebugUtilsLabelEXT

PFN_vkCmdInsertDebugUtilsLabelEXT qvkInsertDebugUtilsLabelEXT

Definition at line 172 of file vk_common.c.

Referenced by QVk_Init().

qvkSetDebugUtilsObjectNameEXT

PFN_vkSetDebugUtilsObjectNameEXT qvkSetDebugUtilsObjectNameEXT

Definition at line 168 of file vk_common.c.

Referenced by QVk_Init().

qvkSetDebugUtilsObjectTagEXT

PFN_vkSetDebugUtilsObjectTagEXT qvkSetDebugUtilsObjectTagEXT

Definition at line 169 of file vk_common.c.

Referenced by QVk_Init().

vk_activeCmdbuffer

VkCommandBuffer vk_activeCmdbuffer

Definition at line 127 of file vk_common.c.

Referenced by DrawVkFlowingPoly(), DrawVkPoly(), EmitWaterPolys(), QVk_BeginFrame(), QVk_BindPipeline(), QVk_DrawColorRect(), QVk_DrawTexRect(), QVk_Init(), QVk_Shutdown(), R_DrawAliasModel(), R_DrawBeam(), R_DrawNullModel(), R_DrawParticles(), R_DrawSkyBox(), R_DrawSpriteModel(), R_DrawTriangleOutlines(), R_EndWorldRenderpass(), R_RenderDlight(), R_RenderView(), R_SetupVulkan(), R_SetVulkan2D(), Vk_DrawAliasFrameLerp(), Vk_DrawAliasShadow(), Vk_DrawParticles(), and Vk_RenderLightmappedPoly().

vk_colorbuffer

qvktexture_t vk_colorbuffer

Definition at line 104 of file vk_common.c.

Referenced by CreateDrawBuffers(), CreateFramebuffers(), DestroyDrawBuffers(), QVk_Init(), and R_EndWorldRenderpass().

vk_colorbufferWarp

qvktexture_t vk_colorbufferWarp

Definition at line 106 of file vk_common.c.

Referenced by CreateDrawBuffers(), CreateFramebuffers(), DestroyDrawBuffers(), QVk_Init(), and R_SetVulkan2D().

vk_commandPool

VkCommandPool vk_commandPool

Definition at line 95 of file vk_common.c.

Referenced by QVk_Init(), QVk_ReadPixels(), and QVk_Shutdown().

vk_descriptorPool

VkDescriptorPool vk_descriptorPool

Definition at line 97 of file vk_common.c.

Referenced by CreateDescriptorPool(), CreateUboDescriptorSet(), QVk_CreateTexture(), QVk_Init(), QVk_ReleaseTexture(), QVk_Shutdown(), and ReleaseSwapBuffers().

vk_device

qvkdevice_t vk_device

Definition at line 51 of file vk_common.c.

Referenced by copyBuffer(), CreateDescriptorPool(), CreateDescriptorSetLayouts(), CreateFramebuffers(), createLogicalDevice(), CreatePipelines(), CreateRenderpasses(), CreateSamplers(), CreateStagingBuffers(), createTextureImage(), CreateUboDescriptorSet(), DestroyDrawBuffer(), DestroyFramebuffers(), DestroyImageViews(), DestroySamplers(), getBestPhysicalDevice(), QVk_BeginFrame(), QVk_CreateBuffer(), QVk_CreateCommandBuffer(), QVk_CreateCommandPool(), QVk_CreateDevice(), QVk_CreateImage(), QVk_CreateImageView(), QVk_CreatePipeline(), QVk_CreateShader(), QVk_CreateSwapchain(), QVk_CreateTexture(), QVk_DestroyPipeline(), QVk_EndFrame(), QVk_FindDepthFormat(), QVk_GetStagingBuffer(), QVk_Init(), QVk_ReadPixels(), QVk_RecreateSwapchain(), QVk_ReleaseTexture(), QVk_Shutdown(), QVk_SubmitCommand(), QVk_UpdateTextureData(), QVk_UpdateTextureSampler(), R_RenderView(), R_Shutdown(), ReleaseSwapBuffers(), selectPhysicalDevice(), SubmitStagingBuffer(), transitionImageLayout(), Vk_LmapTextureMode(), Vk_Strings_f(), and Vk_TextureMode().

vk_drawBeamPipeline

qvkpipeline_t vk_drawBeamPipeline

Definition at line 153 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_DrawBeam().

vk_drawColorQuadPipeline

qvkpipeline_t vk_drawColorQuadPipeline[2]

Definition at line 139 of file vk_common.c.

Referenced by CreatePipelines(), QVk_DrawColorRect(), and QVk_Shutdown().

vk_drawDLightPipeline

qvkpipeline_t vk_drawDLightPipeline

Definition at line 155 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_RenderDlight().

vk_drawLefthandModelPipelineFan

qvkpipeline_t vk_drawLefthandModelPipelineFan

Definition at line 145 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasFrameLerp().

vk_drawLefthandModelPipelineStrip

qvkpipeline_t vk_drawLefthandModelPipelineStrip

Definition at line 144 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasFrameLerp().

vk_drawModelPipelineFan

qvkpipeline_t vk_drawModelPipelineFan[2]

Definition at line 141 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasFrameLerp().

vk_drawModelPipelineStrip

qvkpipeline_t vk_drawModelPipelineStrip[2]

Definition at line 140 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasFrameLerp().

vk_drawNoDepthModelPipelineFan

qvkpipeline_t vk_drawNoDepthModelPipelineFan

Definition at line 143 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasFrameLerp().

vk_drawNoDepthModelPipelineStrip

qvkpipeline_t vk_drawNoDepthModelPipelineStrip

Definition at line 142 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasFrameLerp().

vk_drawNullModelPipeline

qvkpipeline_t vk_drawNullModelPipeline

Definition at line 146 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_DrawNullModel().

vk_drawParticlesPipeline

qvkpipeline_t vk_drawParticlesPipeline

Definition at line 147 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawParticles().

vk_drawPointParticlesPipeline

qvkpipeline_t vk_drawPointParticlesPipeline

Definition at line 148 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_DrawParticles().

vk_drawPolyLmapPipeline

qvkpipeline_t vk_drawPolyLmapPipeline

Definition at line 151 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_RenderLightmappedPoly().

vk_drawPolyPipeline

qvkpipeline_t vk_drawPolyPipeline

Definition at line 150 of file vk_common.c.

Referenced by CreatePipelines(), DrawVkFlowingPoly(), DrawVkPoly(), and QVk_Shutdown().

vk_drawPolyWarpPipeline

qvkpipeline_t vk_drawPolyWarpPipeline

Definition at line 152 of file vk_common.c.

Referenced by CreatePipelines(), EmitWaterPolys(), and QVk_Shutdown().

vk_drawSkyboxPipeline

qvkpipeline_t vk_drawSkyboxPipeline

Definition at line 154 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_DrawSkyBox().

vk_drawSpritePipeline

qvkpipeline_t vk_drawSpritePipeline

Definition at line 149 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_DrawSpriteModel().

vk_drawTexQuadPipeline

qvkpipeline_t vk_drawTexQuadPipeline

Definition at line 138 of file vk_common.c.

Referenced by CreatePipelines(), QVk_DrawTexRect(), QVk_Shutdown(), R_DrawAliasModel(), and R_SetupVulkan().

vk_frameStarted

qboolean vk_frameStarted

Definition at line 135 of file vk_common.c.

Referenced by QVk_BeginFrame(), QVk_EndFrame(), and R_EndWorldRenderpass().

vk_instance

VkInstance vk_instance

Definition at line 46 of file vk_common.c.

Referenced by QVk_CreateValidationLayers(), QVk_DestroyValidationLayers(), QVk_Init(), QVk_Shutdown(), selectPhysicalDevice(), Vk_Strings_f(), and Vkimp_CreateSurface().

vk_malloc

VmaAllocator vk_malloc

Definition at line 48 of file vk_common.c.

Referenced by CreateDynamicBuffers(), createStagedBuffer(), CreateStagingBuffers(), DestroyDrawBuffer(), QVk_BeginFrame(), QVk_CreateBuffer(), QVk_CreateImage(), QVk_EndFrame(), QVk_FreeBuffer(), QVk_GetIndexBuffer(), QVk_GetUniformBuffer(), QVk_GetVertexBuffer(), QVk_Init(), QVk_ReleaseTexture(), QVk_Shutdown(), and RebuildTriangleFanIndexBuffer().

vk_postprocessPipeline

qvkpipeline_t vk_postprocessPipeline

Definition at line 160 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_SetVulkan2D().

vk_samplerDescSetLayout

VkDescriptorSetLayout vk_samplerDescSetLayout

Definition at line 261 of file vk_common.c.

Referenced by CreateDescriptorSetLayouts(), CreatePipelines(), QVk_CreateTexture(), QVk_Init(), and QVk_Shutdown().

vk_shadowsPipelineFan

qvkpipeline_t vk_shadowsPipelineFan

Definition at line 158 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasShadow().

vk_shadowsPipelineStrip

qvkpipeline_t vk_shadowsPipelineStrip

Definition at line 157 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and Vk_DrawAliasShadow().

vk_showTrisPipeline

qvkpipeline_t vk_showTrisPipeline

Definition at line 156 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_DrawTriangleOutlines().

vk_surface

VkSurfaceKHR vk_surface

Definition at line 47 of file vk_common.c.

Referenced by getBestPhysicalDevice(), QVk_CreateSwapchain(), QVk_Shutdown(), and Vkimp_CreateSurface().

vk_swapchain

qvkswapchain_t vk_swapchain

Definition at line 63 of file vk_common.c.

Referenced by CreateFramebuffers(), CreateImageViews(), CreateRenderpasses(), DestroyFramebuffers(), DestroyImageViews(), QVk_BeginFrame(), QVk_BeginRenderpass(), QVk_CreateColorBuffer(), QVk_CreateDepthBuffer(), QVk_CreatePipeline(), QVk_CreateSwapchain(), QVk_EndFrame(), QVk_Init(), QVk_ReadPixels(), QVk_RecreateSwapchain(), QVk_Shutdown(), Vk_ScreenShot_f(), and Vk_Strings_f().

vk_transferCommandPool

VkCommandPool vk_transferCommandPool

Definition at line 96 of file vk_common.c.

Referenced by copyBuffer(), QVk_Init(), and QVk_Shutdown().

vk_uboDescSetLayout

VkDescriptorSetLayout vk_uboDescSetLayout

Definition at line 260 of file vk_common.c.

Referenced by CreateDescriptorSetLayouts(), CreatePipelines(), CreateUboDescriptorSet(), and QVk_Shutdown().

vk_worldWarpPipeline

qvkpipeline_t vk_worldWarpPipeline

Definition at line 159 of file vk_common.c.

Referenced by CreatePipelines(), QVk_Shutdown(), and R_EndWorldRenderpass().