kotofyt/funnygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

brought back functionality from previous builds but now cross-platform

Browse Source
This commit is contained in:
kotofyt
2025-07-07 15:34:34 +03:00
parent 99eafb9443
commit 83bc9b7f16
61 changed files with 1210 additions and 581 deletions
Download Patch File Download Diff File Expand all files Collapse all files

481
engine/vk_video.cpp
View File

@@ -7,9 +7,9 @@
#include "rendering.h"
#include "vk_helper.h"
#include "vulkan/vulkan_core.h"
#include "tier0/mem.h"
#define STB_IMAGE_IMPLEMENTATION
#if defined(__APPLE__) && defined(__MACH__)
#include "TargetConditionals.h"
#if TARGET_OS_IPHONE
@@ -27,8 +27,13 @@
#include "vk_video.h"
VkSampler g_invalidTextureSampler;
static CVkImage s_SwapchainImage;
IBuffer *g_cameraProperties;
struct CameraProjection {
mat4 viewprojection;
};
vk_buffer_t g_cameraProperties;
CameraProjection *g_cameraDataMap;
mat4 g_cameraView;
@@ -41,6 +46,15 @@ class CVkGraphicsPipeline: public IGraphicsPipeline
{
public:
vk_tripipeline_t m_pipeline;
uint32_t nVertexSize;
CUtlVector<VkWriteDescriptorSet> m_writes;
VkDescriptorPool m_descriptorPool;
VkDescriptorSet m_descriptorSet;
CUtlVector<ShaderInput_t> m_inputs;
};
class CVkComputePipeline: public IComputePipeline
@@ -148,8 +162,8 @@ void IVulkan::Init()
samplerInfo.maxLod = 0.0f;
vkCreateSampler(g_vkDevice, &samplerInfo, nullptr, &g_invalidTextureSampler);
g_cameraProperties.Create(sizeof(CameraProjection), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
g_cameraDataMap = (CameraProjection*)g_cameraProperties.Map(0, 64);
g_cameraProperties = IRenderer::CreateUniformBuffer(sizeof(CameraProjection));
g_cameraDataMap = (CameraProjection*)g_cameraProperties->Map();
g_meshDepth = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, 1280, 720, 1);
g_meshDepthMSAA = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, 1280, 720, 4);
@@ -181,6 +195,12 @@ void IVulkan::Frame()
glm_rotate(perspective, glm_rad(90), (vec4){0,0,1,0});
glm_mat4_mul(perspective,g_cameraDataMap->viewprojection,g_cameraDataMap->viewprojection);
s_SwapchainImage.m_image.m_image = g_swapchainImage;
s_SwapchainImage.m_image.m_imageView = g_swapchainImageView;
s_SwapchainImage.m_image.m_format = g_swapchainFormat;
s_SwapchainImage.m_usage = IMAGE_USAGE_COLOR_ATTACHMENT;
s_SwapchainImage.format = IMAGE_FORMAT_R8G8B8A8;
if (g_bConfigNotify)
{
IRenderer::DestroyImage(g_meshDepth);
@@ -195,24 +215,82 @@ void IVulkan::Frame()
for (auto &step: g_StepPrepass)
step.pPipeline->Frame(0);
IRenderer::Barrier(BARRIER_STAGE_TOP, BARRIER_STAGE_COLOR_OUTPUT, {}, {
{
.in = BARRIER_MEMORY_PERMISSIONS_NONE,
.out = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
.pImage = g_meshColor,
},
{
.in = BARRIER_MEMORY_PERMISSIONS_NONE,
.out = BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE,
.pImage = g_meshDepth,
},
}
);
IRenderer::Begin(g_nWindowWidth, g_nWindowHeight,
{
{
0,
g_meshColor,
g_meshColorMSAA,
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_LOAD_MODE_CLEAR,
ATTACHMENT_STORE_MODE_STORE,
}
},
{
0,
g_meshDepth,
g_meshDepthMSAA,
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_LOAD_MODE_CLEAR,
ATTACHMENT_STORE_MODE_STORE,
});
for (auto &step: g_StepMeshRendering)
{
step.pPipeline->Frame(0);
}
IRenderer::End();
IRenderer::Barrier(BARRIER_STAGE_COLOR_OUTPUT, BARRIER_STAGE_BOTTOM, {}, {
{
.in = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
.out = BARRIER_MEMORY_PERMISSIONS_COPY_READ,
.pImage = g_meshColor,
},
{
.in = BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE,
.out = BARRIER_MEMORY_PERMISSIONS_NONE,
.pImage = g_meshDepth,
},
{
.in = BARRIER_MEMORY_PERMISSIONS_NONE,
.out = BARRIER_MEMORY_PERMISSIONS_COPY_WRITE,
.pImage = IRenderer::GetOutputImage(),
}
}
);
VkImageCopy imageCopyRegion = {};
imageCopyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageCopyRegion.srcSubresource.mipLevel = 0;
imageCopyRegion.srcSubresource.baseArrayLayer = 0;
imageCopyRegion.srcSubresource.layerCount = 1;
imageCopyRegion.srcOffset = {0, 0, 0};
imageCopyRegion.dstSubresource = imageCopyRegion.srcSubresource;
imageCopyRegion.dstOffset = {0, 0, 0};
imageCopyRegion.extent.width = g_nWindowWidth;
imageCopyRegion.extent.height = g_nWindowHeight;
imageCopyRegion.extent.depth = 1;
vkCmdCopyImage(
g_vkCommandBuffer,
((CVkImage*)g_meshColor)->m_image.m_image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
g_swapchainImage,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imageCopyRegion
);
for (auto &step: g_StepShading)
step.pPipeline->Frame(0);
for (auto &step: g_StepPostProcessing)
@@ -289,11 +367,8 @@ void vk_tripipeline_t::Create(
vkCreatePipelineLayout(g_vkDevice, &pipelineLayoutCreateInfo, NULL, &m_layout);
VkDynamicState dynamicStates[] = {
/* pVertexInputState */
VK_DYNAMIC_STATE_VERTEX_INPUT_EXT,
/* pInputAssemblyState */
VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,
VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
/* pViewportState */
VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
@@ -318,12 +393,6 @@ void vk_tripipeline_t::Create(
VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE,
VK_DYNAMIC_STATE_STENCIL_OP,
VK_DYNAMIC_STATE_DEPTH_BOUNDS,
/* pColorBlendState */
VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
VK_DYNAMIC_STATE_BLEND_CONSTANTS,
};
VkVertexInputBindingDescription vibd = {
@@ -340,8 +409,8 @@ void vk_tripipeline_t::Create(
CUtlVector<VkVertexInputAttributeDescription> viad(vertexFormat.GetSize());
for ( uint32_t i = 0; i < viad.GetSize(); i++ )
{
viad[i].location = 0;
viad[i].binding = vertexFormat[i].binding;
viad[i].location = vertexFormat[i].binding;
viad[i].binding = 0;
viad[i].format = IRenderer_VertexToVk(vertexFormat[i].format);
viad[i].offset = vertexFormat[i].offset;
}
@@ -350,7 +419,8 @@ void vk_tripipeline_t::Create(
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.vertexBindingDescriptionCount = 1,
.pVertexBindingDescriptions = &vibd,
.vertexAttributeDescriptionCount = (uint32_t)vertexFormat.GetSize(),
.vertexAttributeDescriptionCount = (uint32_t)viad.GetSize(),
.pVertexAttributeDescriptions = viad.GetData()
};
VkPipelineInputAssemblyStateCreateInfo piasci = {
@@ -358,7 +428,16 @@ void vk_tripipeline_t::Create(
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_TRUE,
};
VkPipelineColorBlendAttachmentState pcbas = {
.blendEnable = VK_FALSE,
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
};
VkPipelineColorBlendStateCreateInfo pcbsci = {};
pcbsci.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
pcbsci.logicOpEnable = VK_FALSE;
pcbsci.attachmentCount = 1;
pcbsci.pAttachments = &pcbas;
VkPipelineRenderingCreateInfo prci = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
@@ -372,8 +451,9 @@ void vk_tripipeline_t::Create(
graphicsPipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
graphicsPipelineCreateInfo.pVertexInputState = &pvisci;
graphicsPipelineCreateInfo.pInputAssemblyState = &piasci;
graphicsPipelineCreateInfo.layout = m_layout;
graphicsPipelineCreateInfo.pColorBlendState = &pcbsci;
graphicsPipelineCreateInfo.pDynamicState = &pipelineDynamicStateCreateInfo;
graphicsPipelineCreateInfo.layout = m_layout;
graphicsPipelineCreateInfo.stageCount = shaders.GetSize();
CUtlVector<VkPipelineShaderStageCreateInfo> stages(graphicsPipelineCreateInfo.stageCount);
uint32_t i = 0;
@@ -544,6 +624,18 @@ void CVkBuffer::Unmap()
CUtlVector<ITexture*> g_textures;
CUtlVector<ITexture*> g_newtextures;
uint32_t ITextureManager::GetTextureID(ITexture *pTexture)
{
uint32_t i = 0;
for (auto &t: g_textures)
{
if (pTexture == t)
return i;
i++;
}
return 0;
}
ITexture *ITextureManager::LoadTexture( void *pData, uint32_t X, uint32_t Y, uint32_t numChannels )
{
CVkTexture *pTexture = new CVkTexture;
@@ -614,13 +706,13 @@ ITexture *ITextureManager::LoadTexture( void *pData, uint32_t X, uint32_t Y, uin
region.imageOffset = {0, 0, 0};
region.imageExtent = {(uint32_t)X, (uint32_t)Y, 1};
vkCmdCopyBufferToImage(
commandBuffer,
gpu_buffer.m_buffer,
pTexture->image.m_image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&region
);
commandBuffer,
gpu_buffer.m_buffer,
pTexture->image.m_image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&region
);
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
@@ -666,7 +758,6 @@ ITexture *ITextureManager::LoadTexture( const char *szName )
FileHandle_t file = IFileSystem::Open(szName, IFILE_READ);
if (!file)
Plat_FatalErrorFunc("Failed to load %s\n", szName);
V_printf("cool %s\n",szName);
CUtlBuffer<stbi_uc> buffer(IFileSystem::Size(file));
IFileSystem::Read(file, buffer.GetMemory(), buffer.GetSize());
@@ -713,7 +804,7 @@ IIndexBuffer *IRenderer::CreateIndexBuffer( uint32_t uSize )
IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples )
{
VkFormat vkformat;
VkImageUsageFlags vkusage;
VkImageUsageFlags vkusage = 0;
CVkImage *pImage = new CVkImage();
VkSampleCountFlagBits samples;
switch (format)
@@ -727,6 +818,8 @@ IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nW
if (usage&IMAGE_USAGE_COLOR_ATTACHMENT) vkusage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
if (usage&IMAGE_USAGE_DEPTH_ATTACHMENT) vkusage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
if (usage&IMAGE_USAGE_STORAGE) vkusage |= VK_IMAGE_USAGE_STORAGE_BIT;
vkusage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
vkusage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
switch (nSamples)
{
@@ -734,6 +827,9 @@ IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nW
case 4: samples = VK_SAMPLE_COUNT_4_BIT; break;
default: samples = VK_SAMPLE_COUNT_1_BIT; break;
}
pImage->m_usage = usage;
pImage->m_image = {};
pImage->format = format;
pImage->m_image.Create(nWidth, nHeight, vkformat, vkusage, samples);
return pImage;
};
@@ -751,21 +847,157 @@ void IRenderer::DestroyImage( IImage *pImage )
pVkImage->m_image.Destroy();
}
IPipeline *g_pCurrentPipeline;
void IRenderer::SetConstants( uint32_t nSize, uint32_t nOffset, void *pData )
void IRenderer::SetConstants( uint32_t nSize, void *pData )
{
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
vkCmdPushConstants(g_vkCommandBuffer, pVkPipeline->m_pipeline.m_layout, VK_SHADER_STAGE_ALL, 0, nSize, pData);
}
}
void IRenderer::Barrier( EBarrierStage stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
void IRenderer::Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
{
VkPipelineStageFlags psfSrc = 0;
VkPipelineStageFlags psfDst = 0;
if (stageIn & BARRIER_STAGE_TOP) psfSrc |= VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
if (stageIn & BARRIER_STAGE_VERTEX_INPUT) psfSrc |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
if (stageIn & BARRIER_STAGE_VERTEX_SHADER) psfSrc |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
if (stageIn & BARRIER_STAGE_GEOMETRY_SHADER) psfSrc |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
if (stageIn & BARRIER_STAGE_FRAGMENT_SHADER) psfSrc |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
if (stageIn & BARRIER_STAGE_COLOR_OUTPUT) psfSrc |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
if (stageIn & BARRIER_STAGE_RAY_TRACING_SHADER) psfSrc |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
if (stageIn & BARRIER_STAGE_BOTTOM) psfSrc |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
if (stageOut & BARRIER_STAGE_TOP) psfDst |= VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
if (stageOut & BARRIER_STAGE_VERTEX_INPUT) psfDst |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
if (stageOut & BARRIER_STAGE_VERTEX_SHADER) psfDst |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
if (stageOut & BARRIER_STAGE_GEOMETRY_SHADER) psfDst |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
if (stageOut & BARRIER_STAGE_FRAGMENT_SHADER) psfDst |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
if (stageOut & BARRIER_STAGE_COLOR_OUTPUT) psfDst |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
if (stageOut & BARRIER_STAGE_RAY_TRACING_SHADER) psfDst |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
if (stageOut & BARRIER_STAGE_BOTTOM) psfDst |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
CUtlVector<VkImageMemoryBarrier> imb = {};
CUtlVector<VkBufferMemoryBarrier> bmb = {};
for (auto &buffer: buffers)
{
CVkBuffer *pVkBuffer = (CVkBuffer*)buffer.pBuffer;
VkBufferMemoryBarrier b = {};
b.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
b.buffer = pVkBuffer->m_buffer.m_buffer;
b.size = pVkBuffer->m_buffer.m_nSize;
b.srcQueueFamilyIndex = g_drawfamily;
b.dstQueueFamilyIndex = g_drawfamily;
switch (buffer.in)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
switch (buffer.out)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
bmb.AppendTail(b);
}
for (auto &image: images)
{
CVkImage *pVkImage = (CVkImage*)image.pImage;
VkImageMemoryBarrier b = {};
b.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
b.image = pVkImage->m_image.m_image;
VkImageSubresourceRange isr = {
.aspectMask = (pVkImage->format == IMAGE_FORMAT_DEPTH) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
};
b.subresourceRange = isr;
if (pVkImage->m_usage == IMAGE_USAGE_COLOR_ATTACHMENT)
{
b.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
b.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
if (pVkImage->m_usage == IMAGE_USAGE_DEPTH_ATTACHMENT)
{
b.oldLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
b.newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
}
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
switch (image.in)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_READ: b.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE: b.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
switch (image.out)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_READ: b.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE: b.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
imb.AppendTail(b);
}
vkCmdPipelineBarrier(g_vkCommandBuffer, psfSrc, psfDst, 0, 0, 0, bmb.GetSize(), bmb.GetData(), imb.GetSize(), imb.GetData());
}
void IRenderer::BindData( uint32_t binding, IBuffer *pBuffer, IImage* pImage)
{
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
CVkBuffer* pVkBuffer = (CVkBuffer*)pBuffer;
VkDescriptorBufferInfo dbi;
for (auto &input: pVkPipeline->m_inputs)
{
if (input.binding != binding)
continue;
switch (input.type)
{
case SHADER_INPUT_TYPE_STORAGE_BUFFER:
case SHADER_INPUT_TYPE_UNIFORM_BUFFER:
if (!pBuffer)
Plat_FatalErrorFunc("pBuffer is NULL\n");
if (pVkPipeline->m_writes[binding].pBufferInfo)
V_free((void*)pVkPipeline->m_writes[binding].pBufferInfo);
dbi = {
.buffer = pVkBuffer->m_buffer.m_buffer,
.offset = 0,
.range = pVkBuffer->m_buffer.m_nSize,
};
pVkPipeline->m_writes[binding].pBufferInfo = (VkDescriptorBufferInfo*)V_malloc(sizeof(VkDescriptorBufferInfo));
V_memcpy((void*)pVkPipeline->m_writes[binding].pBufferInfo, &dbi, sizeof(VkDescriptorBufferInfo));
break;
case SHADER_INPUT_TYPE_IMAGE:
break;
case SHADER_INPUT_TYPE_TLAS:
break;
case SHADER_INPUT_TYPE_TEXTURES:
break;
};
}
}
}
@@ -777,8 +1009,45 @@ void IRenderer::BindPipeline( IPipeline *pPipeline )
if (pPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)pPipeline;
vkCmdBindPipeline(g_vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pVkPipeline->m_pipeline.m_pipeline);
}
g_pCurrentPipeline = pPipeline;
}
void IRenderer::PushBindings()
{
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
CUtlVector<VkDescriptorImageInfo> textures;
textures.Reserve(g_textures.GetSize());
for (ITexture *t: g_textures)
{
CVkTexture *texture = (CVkTexture*)t;
VkDescriptorImageInfo image = {};
image.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
image.imageView = texture->image.m_imageView;
image.sampler = g_invalidTextureSampler;
textures.AppendTail(image);
};
for ( int i = 0; i < pVkPipeline->m_inputs.GetSize(); i++ )
{
if (pVkPipeline->m_inputs[i].type == SHADER_INPUT_TYPE_TEXTURES)
{
pVkPipeline->m_writes[i].descriptorCount = textures.GetSize();
pVkPipeline->m_writes[i].pImageInfo = textures.GetData();
}
}
textures[0].sampler = g_invalidTextureSampler;
vkUpdateDescriptorSets(g_vkDevice, pVkPipeline->m_writes.GetSize(), pVkPipeline->m_writes.GetData(), 0, NULL);
vkCmdBindDescriptorSets(g_vkCommandBuffer,VK_PIPELINE_BIND_POINT_GRAPHICS, pVkPipeline->m_pipeline.m_layout, 0, 1, &pVkPipeline->m_descriptorSet, 0, NULL);
}
}
@@ -823,6 +1092,7 @@ void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingCo
}
depthAttachment.loadOp = IRenderer_LoadOpVk(depth.loadMode);
depthAttachment.storeOp = IRenderer_StoreOpVk(depth.storeMode);
depthAttachment.clearValue = (VkClearValue){.depthStencil = {.depth = 1}};
VkRenderingInfo renderInfo = {
.sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
@@ -838,6 +1108,29 @@ void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingCo
void IRenderer::ResetState()
{
vkCmdSetRasterizerDiscardEnable(g_vkCommandBuffer, VK_FALSE);
vkCmdSetDepthBiasEnable(g_vkCommandBuffer, VK_FALSE);
vkCmdSetCullMode(g_vkCommandBuffer, VK_CULL_MODE_BACK_BIT);
vkCmdSetFrontFace(g_vkCommandBuffer, VK_FRONT_FACE_COUNTER_CLOCKWISE);
vkCmdSetDepthTestEnable(g_vkCommandBuffer, VK_TRUE);
vkCmdSetDepthWriteEnable(g_vkCommandBuffer, VK_TRUE);
vkCmdSetDepthCompareOp(g_vkCommandBuffer, VK_COMPARE_OP_LESS);
vkCmdSetStencilTestEnable(g_vkCommandBuffer, VK_FALSE);
_vkCmdSetPolygonModeEXT(g_vkCommandBuffer, VK_POLYGON_MODE_FILL);
_vkCmdSetRasterizationSamplesEXT(g_vkCommandBuffer, VK_SAMPLE_COUNT_1_BIT);
VkSampleMask sampleMask = 0xFFFFFFFF;
_vkCmdSetSampleMaskEXT(g_vkCommandBuffer, VK_SAMPLE_COUNT_1_BIT, &sampleMask);
_vkCmdSetAlphaToCoverageEnableEXT(g_vkCommandBuffer, VK_FALSE);
VkViewport viewport = {0, 0, (float)g_nWindowWidth, (float)g_nWindowHeight, 0.0f, 1.0f};
VkRect2D scissor = {{0, 0}, {g_nWindowWidth, g_nWindowHeight}};
vkCmdSetViewportWithCount(g_vkCommandBuffer, 1, &viewport);
vkCmdSetScissorWithCount(g_vkCommandBuffer, 1, &scissor);
vkCmdSetPrimitiveTopology(g_vkCommandBuffer, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
vkCmdSetPrimitiveRestartEnable(g_vkCommandBuffer, VK_FALSE);
}
void IRenderer::SetDepthMode( EDepthMode mode )
@@ -847,6 +1140,31 @@ void IRenderer::SetDepthMode( EDepthMode mode )
void IRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
{
CVkBuffer *pVkVertex = (CVkBuffer*)pVertex;
CVkBuffer *pVkIndex = (CVkBuffer*)pIndex;
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(g_vkCommandBuffer, 0, 1, &pVkVertex->m_buffer.m_buffer, &offset);
if (pVkIndex)
{
vkCmdBindIndexBuffer(
g_vkCommandBuffer,
pVkIndex->m_buffer.m_buffer,
0,
VK_INDEX_TYPE_UINT32
);
vkCmdDrawIndexed(g_vkCommandBuffer, pVkIndex->m_buffer.m_nSize/4, 1, 0, 0, 0);
}
else
{
vkCmdDraw(g_vkCommandBuffer, pVkVertex->m_buffer.m_nSize/pVkPipeline->nVertexSize,1,0,0);
}
}
}
@@ -855,15 +1173,14 @@ void IRenderer::End()
vkCmdEndRendering(g_vkCommandBuffer);
}
IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
CUtlVector<Shader_t> shaders,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize,
uint32_t nVertexSize,
CUtlVector<VertexAttribute_t> vertexFormats,
CUtlVector<EImageFormat> outputFormats
CUtlVector<EImageFormat> outputFormats,
bool bDepth
)
{
CVkGraphicsPipeline *pipeline = new CVkGraphicsPipeline;
@@ -884,6 +1201,8 @@ IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
{
vkbindings[i].binding = inputs[i].binding;
vkbindings[i].descriptorCount = 1;
vkbindings[i].stageFlags = VK_SHADER_STAGE_ALL;
if (inputs[i].type == SHADER_INPUT_TYPE_IMAGE) vkbindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
if (inputs[i].type == SHADER_INPUT_TYPE_UNIFORM_BUFFER) vkbindings[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
if (inputs[i].type == SHADER_INPUT_TYPE_STORAGE_BUFFER) vkbindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
@@ -898,50 +1217,66 @@ IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
{
vkformats[i] = IRenderer_FormatToVk(outputFormats[i]);
}
pipeline->m_pipeline.Create(vkshaders, vkbindings, nConstantsSize, nVertexSize, vertexFormats, vkformats);
pipeline->nVertexSize = nVertexSize;
CUtlVector<VkDescriptorPoolSize> pools = {};
for (auto &binding: vkbindings)
{
VkDescriptorPoolSize dps = {};
dps.type = binding.descriptorType;
dps.descriptorCount = binding.descriptorCount;
pools.AppendTail(dps);
}
VkDescriptorPoolCreateInfo poolInfo = {};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = pools.GetSize();
poolInfo.pPoolSizes = pools.GetData();
poolInfo.maxSets = 1;
vkCreateDescriptorPool(g_vkDevice, &poolInfo, NULL, &pipeline->m_descriptorPool);
VkDescriptorSetAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = pipeline->m_descriptorPool;
allocInfo.descriptorSetCount = 1;
allocInfo.pSetLayouts = &pipeline->m_pipeline.m_descriptorSetLayout;
vkAllocateDescriptorSets(g_vkDevice, &allocInfo, &pipeline->m_descriptorSet);
pipeline->m_writes = {};
for (auto &input: inputs)
{
VkWriteDescriptorSet write = {};
write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
write.dstSet = pipeline->m_descriptorSet;
write.dstArrayElement = 0;
write.dstBinding = input.binding;
write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
if (input.type == SHADER_INPUT_TYPE_IMAGE) write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
if (input.type == SHADER_INPUT_TYPE_UNIFORM_BUFFER) write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
if (input.type == SHADER_INPUT_TYPE_STORAGE_BUFFER) write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
if (input.type == SHADER_INPUT_TYPE_TLAS) write.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
if (input.type == SHADER_INPUT_TYPE_TEXTURES)
{
write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
write.descriptorCount = 1024;
} else
write.descriptorCount = 1;
pipeline->m_writes.AppendTail(write);
}
pipeline->m_inputs = inputs;
return pipeline;
};
CUtlVector<RenderingStep_t> g_StepPrepass;
CUtlVector<RenderingStep_t> g_StepMeshRendering;
CUtlVector<RenderingStep_t> g_StepShading;
CUtlVector<RenderingStep_t> g_StepPostProcessing;
CUtlVector<RenderingStep_t> g_StepUI;
CRenderingStep::CRenderingStep()
IBuffer *IRenderer::GetCameraMatrix()
{
return g_cameraProperties;
}
CRenderingStep::CRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
IImage *IRenderer::GetOutputImage()
{
}
CPrepassRenderingStep::CPrepassRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
{
g_StepPrepass.AppendTail({pfn(), szStepName});
}
CMeshRenderingStep::CMeshRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
{
g_StepMeshRendering.AppendTail({pfn(), szStepName});
}
CShadingRenderingStep::CShadingRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
{
g_StepShading.AppendTail({pfn(), szStepName});
}
CPostProcessingRenderingStep::CPostProcessingRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
{
g_StepPostProcessing.AppendTail({pfn(), szStepName});
}
CUIRenderingStep::CUIRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
{
g_StepUI.AppendTail({pfn(), szStepName});
return &s_SwapchainImage;
}