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

compute shaders

Browse Source
This commit is contained in:
kotofyt
2026-06-13 01:51:28 +03:00
parent 3b128315e7
commit b8aa36ccc0
28 changed files with 498 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
materialsystem/vulkan/commandbuffer.cpp
View File

@@ -373,7 +373,7 @@ public:
private:
VkDevice m_hDevice;
CUtlVector<VkCommandBuffer> m_commands;
CUtlVector<VkCommandBuffer> m_commands = {};
};
EXPOSE_INTERFACE(CVkCommandBufferManager, IVkCommandBufferManager, VULKAN_COMMAND_BUFFER_MANAGER_INTERFACE_NAME);

8
materialsystem/vulkan/commands.h
View File

@@ -7,6 +7,12 @@
BEGIN_VULKAN_COMMAND(Empty)
END_VULKAN_COMMAND(Empty)
BEGIN_VULKAN_COMMAND(Dispatch)
uint32_t uX = 0;
uint32_t uY = 0;
uint32_t uZ = 0;
END_VULKAN_COMMAND(Dispatch)
BEGIN_VULKAN_COMMAND(Blit)
VkFrameObject_t stInputImage;
VkFrameObject_t stOutputImage;
@@ -43,7 +49,7 @@ BEGIN_VULKAN_COMMAND(SetVertexBuffer)
END_VULKAN_COMMAND(SetVertexBuffer)
BEGIN_VULKAN_COMMAND(SetShader)
IShader *pShader;
IBaseShader *pShader;
END_VULKAN_COMMAND(SetShader)
BEGIN_VULKAN_COMMAND(SetShaderData)

5
materialsystem/vulkan/commands/base.cpp
View File

@@ -5,3 +5,8 @@
DECLARE_VULKAN_COMMAND(Empty)
{
}
DECLARE_VULKAN_COMMAND(Dispatch)
{
vkCmdDispatch(hCommandBuffer, uX, uY, uZ);
}

37
materialsystem/vulkan/commands/draw.cpp
View File

@@ -76,13 +76,22 @@ DECLARE_VULKAN_COMMAND(End)
DECLARE_VULKAN_COMMAND(SetShader)
{
CVkShader *pVkShader = (CVkShader*)pShader;
vkCmdBindPipeline(hCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pVkShader->m_hPipeline);
CVkShader *pS = dynamic_cast<CVkShader*>(pShader);
CVkComputeShader *pCS = dynamic_cast<CVkComputeShader*>(pShader);
if (pS)
vkCmdBindPipeline(hCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pS->m_hPipeline);
if (pCS)
vkCmdBindPipeline(hCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pCS->m_hPipeline);
}
DECLARE_VULKAN_COMMAND(SetShaderData)
{
CVkMaterial *pMat = (CVkMaterial*)pShaderData;
vkCmdBindDescriptorSets(hCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pMat->m_pVkShader->m_hPipelineLayout, 0, pMat->m_hSets.GetSize(), pMat->m_hSets.GetData(), 0, 0 );
CVkShader *pS = dynamic_cast<CVkShader*>(pMat->m_pShader);
CVkComputeShader *pCS = dynamic_cast<CVkComputeShader*>(pMat->m_pShader);
if (pS)
vkCmdBindDescriptorSets(hCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pS->m_hPipelineLayout, 0, pMat->m_hSets.GetSize(), pMat->m_hSets.GetData(), 0, 0 );
if (pCS)
vkCmdBindDescriptorSets(hCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pCS->m_hPipelineLayout, 0, pMat->m_hSets.GetSize(), pMat->m_hSets.GetData(), 0, 0 );
}
DECLARE_VULKAN_COMMAND(SetVertexBuffer)
@@ -153,24 +162,4 @@ DECLARE_VULKAN_COMMAND(ResolveImage)
};
vkCmdResolveImage2(hCommandBuffer, &i);
}
DECLARE_VULKAN_COMMAND(CopyBufferToImage)
{
VkBufferImageCopy2 r = {
.sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
.imageSubresource = {
.aspectMask = ((CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame))->m_range.aspectMask,
.layerCount = 1,
},
.imageOffset = {iOffsetX, iOffsetY, iOffsetZ},
.imageExtent = {iImageX, iImageY, iImageZ},
};
VkCopyBufferToImageInfo2 c = {
.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,
.srcBuffer = ((CVkBuffer*)pBuffer)->m_buffer,
.dstImage = ((CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame))->m_image,
.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.regionCount = 1,
.pRegions = &r,
};
vkCmdCopyBufferToImage2(hCommandBuffer, &c);
}

22
materialsystem/vulkan/commands/transfer.cpp
View File

@@ -33,3 +33,25 @@ DECLARE_VULKAN_COMMAND(Blit)
vkCmdBlitImage(hCommandBuffer, pVkInputImage->m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, pVkOutputImage->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &stBlit, VK_FILTER_NEAREST);
}
DECLARE_VULKAN_COMMAND(CopyBufferToImage)
{
VkBufferImageCopy2 r = {
.sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
.imageSubresource = {
.aspectMask = ((CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame))->m_range.aspectMask,
.layerCount = 1,
},
.imageOffset = {iOffsetX, iOffsetY, iOffsetZ},
.imageExtent = {iImageX, iImageY, iImageZ},
};
VkCopyBufferToImageInfo2 c = {
.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,
.srcBuffer = ((CVkBuffer*)pBuffer)->m_buffer,
.dstImage = ((CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame))->m_image,
.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.regionCount = 1,
.pRegions = &r,
};
vkCmdCopyBufferToImage2(hCommandBuffer, &c);
}

81
materialsystem/vulkan/csshader.cpp Normal file
View File

@@ -0,0 +1,81 @@
#include "vulkan_state.h"
void CVkComputeShader::Build()
{
VkPipelineShaderStageCreateInfo stage = {};
VkShaderModuleCreateInfo mod = {};
ShaderObject_t *s = m_shader.FindShaderObject(SHADER_BACKEND_SPIRV_VULKAN, SHADER_STAGE_COMPUTE);
VulkanInputMetaData_t *pMetaData = (VulkanInputMetaData_t*)m_shader.GetLumpPtr(s->m_nMetadataLump);
VkPipelineLayoutCreateInfo stPipelineLayout = {};
CUtlVector<CUtlVector<VkDescriptorSetLayoutBinding>> bindings = {};
for ( int u = 0; u < pMetaData->nDescriptorsCount; u++ )
{
VulkanDescriptor_t stDescriptor = ((VulkanDescriptor_t*)m_shader.GetLumpPtr(pMetaData->pDescriptorSets))[u];
bool bFound = false;
if (bindings.GetSize()<=stDescriptor.uSet)
bindings.Resize(stDescriptor.uSet+1);
uint32_t i = 0;
for ( auto &set: bindings )
{
for ( auto &b: set )
{
if (i != stDescriptor.uSet)
continue;
if (b.binding != stDescriptor.uBinding)
continue;
bFound = true;
break;
}
i++;
if (bFound)
break;
}
if (bFound)
continue;
VkDescriptorSetLayoutBinding bind = {};
bind.binding = stDescriptor.uBinding;
bind.descriptorCount = stDescriptor.uCount;
bind.descriptorType = stDescriptor.eDescriptorType;
bind.stageFlags = VK_SHADER_STAGE_ALL;
bindings[stDescriptor.uSet].AppendTail(bind);
m_bindings.AppendTail(stDescriptor);
}
mod.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
mod.pCode = (uint32_t*)m_shader.GetLumpPtr(s->m_nDataLump);
mod.codeSize = m_shader.GetLumpSize(s->m_nDataLump);
stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stage.pNext = &mod;
stage.pName = "main";
stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
if ( bindings.GetSize() >= 0 )
{
m_setLayouts.Reserve(bindings.GetSize());
for ( int u = 0; u < bindings.GetSize(); u++ )
{
VkDescriptorSetLayoutCreateInfo stSetLayoutCreateInfo = {};
VkDescriptorSetLayout l = NULL;
stSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
stSetLayoutCreateInfo.pBindings = bindings[u].GetData();
stSetLayoutCreateInfo.bindingCount = bindings[u].GetSize();
stSetLayoutCreateInfo.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;
vkCreateDescriptorSetLayout(m_hDevice, &stSetLayoutCreateInfo, NULL, &l);
m_setLayouts.AppendTail(l);
}
stPipelineLayout.setLayoutCount = m_setLayouts.GetSize();
stPipelineLayout.pSetLayouts = m_setLayouts.GetData();
}
stPipelineLayout.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
vkCreatePipelineLayout(m_hDevice, &stPipelineLayout, NULL, &m_hPipelineLayout);
VkComputePipelineCreateInfo ci = {};
ci.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
ci.layout = m_hPipelineLayout;
ci.stage = stage;
vkCreateComputePipelines(m_hDevice, NULL, 1, &ci, NULL, &m_hPipeline);
}

122
materialsystem/vulkan/material.cpp
View File

@@ -1,44 +1,78 @@
#include "vulkan_state.h"
CVkMaterial::CVkMaterial( IShader *pShader )
CVkMaterial::CVkMaterial( IBaseShader *pShader )
{
m_pVkShader = (CVkShader*)pShader;
if ( m_pVkShader->m_setLayouts.GetSize() == 0 )
return;
VkDevice hDevice = NULL;
VkDescriptorPoolSize pools[4] =
CVkShader *pS = dynamic_cast<CVkShader*>(pShader);
CVkComputeShader *pCS = dynamic_cast<CVkComputeShader*>(pShader);
if ( pS )
{
if (pS->m_setLayouts.GetSize() == 0 )
return;
hDevice = pS->m_hDevice;
}
if (pCS)
{
hDevice = pCS->m_hDevice;
}
VkDescriptorPoolSize pools[5] =
{
{
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
128,
1024,
},
{
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
128,
1024,
},
{
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1024,
},
{
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
128,
1024,
},
{
VK_DESCRIPTOR_TYPE_SAMPLER,
1,
1024,
}
};
VkDescriptorPoolCreateInfo stPool = {};
stPool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
stPool.poolSizeCount = 4;
stPool.poolSizeCount = 5;
stPool.pPoolSizes = pools;
stPool.maxSets = 16;
stPool.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT;
vkCreateDescriptorPool(m_pVkShader->m_hDevice, &stPool, NULL, &m_hPool);
vkCreateDescriptorPool(hDevice, &stPool, NULL, &m_hPool);
VkDescriptorSetAllocateInfo stInfo = {};
stInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
stInfo.descriptorPool = m_hPool;
stInfo.descriptorSetCount = m_pVkShader->m_setLayouts.GetSize();
stInfo.pSetLayouts = m_pVkShader->m_setLayouts.GetData();
m_hSets.Resize(m_pVkShader->m_setLayouts.GetSize());
vkAllocateDescriptorSets(m_pVkShader->m_hDevice, &stInfo, m_hSets.GetData());
if ( pS )
{
VkDescriptorSetAllocateInfo stInfo = {};
stInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
stInfo.descriptorPool = m_hPool;
stInfo.descriptorSetCount = pS->m_setLayouts.GetSize();
stInfo.pSetLayouts = pS->m_setLayouts.GetData();
m_hSets.Resize(pS->m_setLayouts.GetSize());
VkResult r = vkAllocateDescriptorSets(hDevice, &stInfo, m_hSets.GetData());
VULKAN_RESULT_PRINT(r, vkAllocateDescriptorSets);
}
if ( pCS )
{
VkDescriptorSetAllocateInfo stInfo = {};
stInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
stInfo.descriptorPool = m_hPool;
stInfo.descriptorSetCount = pCS->m_setLayouts.GetSize();
stInfo.pSetLayouts = pCS->m_setLayouts.GetData();
m_hSets.Resize(pCS->m_setLayouts.GetSize());
VkResult r = vkAllocateDescriptorSets(hDevice, &stInfo, m_hSets.GetData());
VULKAN_RESULT_PRINT(r, vkAllocateDescriptorSets);
}
m_pShader = pShader;
}
CVkMaterial::~CVkMaterial()
@@ -86,11 +120,49 @@ void CVkMaterial::PSSetSampler( uint32_t uRegister, ISampler *pImage )
SetShaderResource(uRegister, 0, pImage);
}
void CVkMaterial::CSSetConstantsBuffer( uint32_t uRegister, uint32_t uSet, IBuffer *pBuffer )
{
SetShaderResource(uRegister, uSet, pBuffer);
}
void CVkMaterial::CSSetTexture( uint32_t uRegister, uint32_t uSet, IImage *pImage )
{
SetShaderResource(uRegister, uSet, pImage);
}
void CVkMaterial::CSSetSampler( uint32_t uRegister, uint32_t uSet, ISampler *pSampler )
{
SetShaderResource(uRegister, uSet, pSampler);
}
void CVkMaterial::CSSetTextureArray( uint32_t uSet, ITextureArray *pArray )
{
SetShaderResource(0, uSet, pArray);
}
void CVkMaterial::SetShaderResource( uint32_t uRegister, uint32_t uSet, IRenderingObject *pObject)
{
if ( m_pVkShader->m_setLayouts.GetSize() == 0 )
return;
VkDevice hDevice;
CVkShader *pShader = dynamic_cast<CVkShader*>(m_pShader);
CVkComputeShader *pCS = dynamic_cast<CVkComputeShader*>(m_pShader);
if ( pShader )
{
if (pShader->m_setLayouts.GetSize() == 0 )
return;
hDevice = pShader->m_hDevice;
}
if (pCS)
{
if (pCS->m_setLayouts.GetSize() == 0 )
return;
hDevice = pCS->m_hDevice;
}
union {
IRenderingObject *pVkObject;
CVkBuffer *pBuffer;
@@ -112,7 +184,7 @@ void CVkMaterial::SetShaderResource( uint32_t uRegister, uint32_t uSet, IRenderi
write.pBufferInfo = &stInfo;
stInfo.buffer = pBuffer->m_buffer;
stInfo.range = pBuffer->m_nSize;
vkUpdateDescriptorSets(m_pVkShader->m_hDevice, 1, &write, 0, 0);
vkUpdateDescriptorSets(hDevice, 1, &write, 0, 0);
}
if (dynamic_cast<IImage*>(pObject))
{
@@ -122,12 +194,12 @@ void CVkMaterial::SetShaderResource( uint32_t uRegister, uint32_t uSet, IRenderi
write.dstSet = m_hSets[uSet];
write.dstBinding = uRegister;
write.dstArrayElement = 0;
write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
write.descriptorType = pImage->m_eDescriptorType;
write.descriptorCount = 1;
write.pImageInfo = &stInfo;
stInfo.imageView = pImage->m_imageView;
stInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
vkUpdateDescriptorSets(m_pVkShader->m_hDevice, 1, &write, 0, 0);
vkUpdateDescriptorSets(hDevice, 1, &write, 0, 0);
}
if (dynamic_cast<CVkSampler*>(pObject))
@@ -142,7 +214,7 @@ void CVkMaterial::SetShaderResource( uint32_t uRegister, uint32_t uSet, IRenderi
write.descriptorCount = 1;
write.pImageInfo = &stInfo;
stInfo.sampler = pSampler->m_sampler;
vkUpdateDescriptorSets(m_pVkShader->m_hDevice, 1, &write, 0, 0);
vkUpdateDescriptorSets(hDevice, 1, &write, 0, 0);
}
if (dynamic_cast<ITextureArray*>(pObject))
{
@@ -184,7 +256,7 @@ void CVkMaterial::SetShaderResource( uint32_t uRegister, uint32_t uSet, IRenderi
writes[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
writes[1].descriptorCount = 128;
writes[1].pImageInfo = stWrites;
vkUpdateDescriptorSets(m_pVkShader->m_hDevice, 2, writes, 0, 0);
vkUpdateDescriptorSets(hDevice, 2, writes, 0, 0);
}
}

166
materialsystem/vulkan/rendercommandlist.cpp
View File

@@ -89,50 +89,69 @@ void CVkRenderCommandList::SetViewport( uint32_t uX, uint32_t uY, uint32_t uWidt
void CVkRenderCommandList::SetMaterial( IMaterial *pMaterial )
{
SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
bool bWasCreated = false;
m_pCurrentMaterialBuffer = FindOrCreateMaterialCommandBuffer(pMaterial, &bWasCreated);
if (bWasCreated)
{
m_pCurrentMaterialBuffer->Reset();
CVkBeginCommand *pBeginCommand = CREATE_COMMAND(m_pCommandBufferManager, Begin);
pBeginCommand->images = m_pOutput;
pBeginCommand->nResolutionX = m_uWidth;
pBeginCommand->nResolutionY = m_uHeight;
for ( auto &i: pBeginCommand->images)
{
pBeginCommand->AddDependency(i.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE);
}
if ( m_bDepthEnabled )
{
pBeginCommand->AddDependency(m_depth.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE);
pBeginCommand->bDepthEnabled = m_bDepthEnabled;
pBeginCommand->stDepthImage = m_depth;
CVkMaterial *pVkMat = (CVkMaterial*)pMaterial;
CVkComputeShader *pCS = dynamic_cast<CVkComputeShader*>(pVkMat->m_pShader);
}
m_pCurrentMaterialBuffer->AddCommand(pBeginCommand);
if (pCS)
{
SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
CVkSetShaderCommand *pSetShader = CREATE_COMMAND(m_pCommandBufferManager, SetShader);
pSetShader->pShader = ((CVkMaterial*)pMaterial)->m_pVkShader;
m_pCurrentMaterialBuffer->AddCommand(pSetShader);
pSetShader->pShader = pCS;
m_pPostRaster->AddCommand(pSetShader);
CVkSetShaderDataCommand *pSetShaderData = CREATE_COMMAND(m_pCommandBufferManager, SetShaderData);
pSetShaderData->pShaderData = pMaterial;
m_pCurrentMaterialBuffer->AddCommand(pSetShaderData);
m_pPostRaster->AddCommand(pSetShaderData);
}
else
{
SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
bool bWasCreated = false;
m_pCurrentMaterialBuffer = FindOrCreateMaterialCommandBuffer(pMaterial, &bWasCreated);
if (bWasCreated)
{
m_pCurrentMaterialBuffer->Reset();
CVkBeginCommand *pBeginCommand = CREATE_COMMAND(m_pCommandBufferManager, Begin);
pBeginCommand->images = m_pOutput;
pBeginCommand->nResolutionX = m_uWidth;
pBeginCommand->nResolutionY = m_uHeight;
for ( auto &i: pBeginCommand->images)
{
pBeginCommand->AddDependency(i.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE);
}
if ( m_bDepthEnabled )
{
pBeginCommand->AddDependency(m_depth.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE);
pBeginCommand->bDepthEnabled = m_bDepthEnabled;
pBeginCommand->stDepthImage = m_depth;
CVkSetScissorsCommand *pScissorsCommand = CREATE_COMMAND(m_pCommandBufferManager, SetScissors);
pScissorsCommand->uWidth = m_uWidth;
pScissorsCommand->uHeight = m_uHeight;
m_pCurrentMaterialBuffer->AddCommand(pScissorsCommand);
}
m_pCurrentMaterialBuffer->AddCommand(pBeginCommand);
CVkSetShaderCommand *pSetShader = CREATE_COMMAND(m_pCommandBufferManager, SetShader);
pSetShader->pShader = ((CVkMaterial*)pMaterial)->m_pShader;
m_pCurrentMaterialBuffer->AddCommand(pSetShader);
CVkSetShaderDataCommand *pSetShaderData = CREATE_COMMAND(m_pCommandBufferManager, SetShaderData);
pSetShaderData->pShaderData = pMaterial;
m_pCurrentMaterialBuffer->AddCommand(pSetShaderData);
CVkSetScissorsCommand *pScissorsCommand = CREATE_COMMAND(m_pCommandBufferManager, SetScissors);
pScissorsCommand->uWidth = m_uWidth;
pScissorsCommand->uHeight = m_uHeight;
m_pCurrentMaterialBuffer->AddCommand(pScissorsCommand);
CVkSetViewportCommand *pViewportCommand = CREATE_COMMAND(m_pCommandBufferManager, SetViewport);
pViewportCommand->fX = 0;
pViewportCommand->fY = 0;
pViewportCommand->fWidth = m_uWidth;
pViewportCommand->fHeight = m_uHeight;
pViewportCommand->fDepthMin = 0;
pViewportCommand->fDepthMax = 1;
m_pCurrentMaterialBuffer->AddCommand(pViewportCommand);
}
CVkSetViewportCommand *pViewportCommand = CREATE_COMMAND(m_pCommandBufferManager, SetViewport);
pViewportCommand->fX = 0;
pViewportCommand->fY = 0;
pViewportCommand->fWidth = m_uWidth;
pViewportCommand->fHeight = m_uHeight;
pViewportCommand->fDepthMin = 0;
pViewportCommand->fDepthMax = 1;
m_pCurrentMaterialBuffer->AddCommand(pViewportCommand);
}
}
@@ -160,34 +179,8 @@ void CVkRenderCommandList::DrawPrimitives( uint32_t nVertexCount, uint32_t nFirs
pCmd->nFirstVertex = nFirstVertex;
pCmd->nInstanceCount = nInstanceCount;
pCmd->nFirstInstance = nFirstInstance;
for ( auto &b: m_barriers )
{
if (dynamic_cast<CVkBuffer*>(b.pObject))
{
if (b.m_bIsRead)
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_READ_WRITE);
else
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_READ);
else
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_WRITE);
FlushBarriers(pCmd);
}
if (dynamic_cast<CVkImage*>(b.pObject))
{
if (b.m_bIsRead)
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE);
else
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_READ);
else
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_WRITE);
}
}
m_barriers = {};
m_pCurrentMaterialBuffer->AddCommand(pCmd);
}
@@ -278,6 +271,18 @@ void CVkRenderCommandList::Barrier( IRenderingObject *pObject, bool bIsRead, boo
{
m_barriers.AppendTail({pObject, bIsRead, bIsWrite});
}
void CVkRenderCommandList::DispatchCompute( uint32_t uX, uint32_t uY, uint32_t uZ )
{
SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
CVkDispatchCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, Dispatch);
pCmd->uX = uX;
pCmd->uY = uY;
pCmd->uZ = uZ;
FlushBarriers(pCmd);
m_pPostRaster->AddCommand(pCmd);
}
void CVkRenderCommandList::Submit()
{
@@ -287,6 +292,38 @@ void CVkRenderCommandList::Submit()
}
}
void CVkRenderCommandList::FlushBarriers( CVkCommand *pCmd )
{
for ( auto &b: m_barriers )
{
if (dynamic_cast<CVkBuffer*>(b.pObject))
{
if (b.m_bIsRead)
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_READ_WRITE);
else
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_READ);
else
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_WRITE);
}
if (dynamic_cast<CVkImage*>(b.pObject))
{
if (b.m_bIsRead)
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE);
else
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_READ);
else
if (b.m_bIsWrite)
pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_WRITE);
}
}
m_barriers = {};
}
void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
{
if (eStage != RENDERING_STAGE_RASTER)
@@ -300,7 +337,7 @@ void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
}
m_materials = {};
};
if (eStage == RENDERING_STAGE_POST_RASTER)
if (eStage == RENDERING_STAGE_POST_RASTER )
{
if (m_eCurrentStage != RENDERING_STAGE_POST_RASTER)
{
@@ -314,6 +351,7 @@ void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
{
m_pPostRaster->Render();
m_pCommandBuffers.AppendTail(m_pPostRaster);
m_pPostRaster = NULL;
}
}
m_eCurrentStage = eStage;

17
materialsystem/vulkan/rendercontext.cpp
View File

@@ -202,6 +202,11 @@ void CVkImage::CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFor
stAlloc.usage = VMA_MEMORY_USAGE_AUTO;
if (eUsage & VK_IMAGE_USAGE_SAMPLED_BIT)
m_eDescriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
if (eUsage & VK_IMAGE_USAGE_STORAGE_BIT)
m_eDescriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
vmaCreateImage(s_vkAllocator, &stCreateInfo, &stAlloc, &m_image, &m_allocation, NULL);
}
@@ -475,7 +480,7 @@ public:
virtual IComputeShader *CreateComputeShader( const char *szName ) override;
virtual void DestroyShader( IBaseShader *pShader ) override;
virtual IMaterial *CreateMaterial( IShader *pShader ) override;
virtual IMaterial *CreateMaterial( IBaseShader *pShader ) override;
virtual void DestroyMaterial( IMaterial *pMaterial ) override;
virtual IRenderCommandList *CreateCommandList() override;
@@ -609,6 +614,7 @@ void CVkRenderContext::DestroyBuffer( IBuffer *pBuffer )
void CVkRenderContext::DestroyImage( IImage *pImage )
{
m_scheduledRemovalImages.AppendTail((CVkImage*)pImage);
}
@@ -617,7 +623,6 @@ IShader *CVkRenderContext::CreateShader( const char *szName )
CVkShader *pShader = new CVkShader();
VkGraphicsPipelineCreateInfo stPipelineCreateInfo = {};
ICompiledShaderManager *pCompiledShaderManager = (ICompiledShaderManager*)CreateInterface(COMPILED_SHADER_MANAGER_INTERFACE_VERSION, NULL);
pCompiledShaderManager->ReadFromFile(&pShader->m_shader, szName);
pShader->m_hDevice = s_vkDevice;
@@ -627,7 +632,6 @@ IShader *CVkRenderContext::CreateShader( const char *szName )
IRayTracingShader *CVkRenderContext::CreateRayShader( const char *szName )
{
CVkRayTracingShader *pShader = new CVkRayTracingShader();
VkGraphicsPipelineCreateInfo stPipelineCreateInfo = {};
ICompiledShaderManager *pCompiledShaderManager = (ICompiledShaderManager*)CreateInterface(COMPILED_SHADER_MANAGER_INTERFACE_VERSION, NULL);
pCompiledShaderManager->ReadFromFile(&pShader->m_shader, szName);
pShader->m_hDevice = s_vkDevice;
@@ -636,6 +640,11 @@ IRayTracingShader *CVkRenderContext::CreateRayShader( const char *szName )
IComputeShader *CVkRenderContext::CreateComputeShader( const char *szName )
{
CVkComputeShader *pShader = new CVkComputeShader;
ICompiledShaderManager *pCompiledShaderManager = (ICompiledShaderManager*)CreateInterface(COMPILED_SHADER_MANAGER_INTERFACE_VERSION, NULL);
pCompiledShaderManager->ReadFromFile(&pShader->m_shader, szName);
pShader->m_hDevice = s_vkDevice;
return pShader;
}
void CVkRenderContext::DestroyShader( IBaseShader *pShader )
@@ -643,7 +652,7 @@ void CVkRenderContext::DestroyShader( IBaseShader *pShader )
delete pShader;
}
IMaterial *CVkRenderContext::CreateMaterial( IShader *pShader )
IMaterial *CVkRenderContext::CreateMaterial( IBaseShader *pShader )
{
CVkMaterial *pMaterial = new CVkMaterial(pShader);
m_pMaterials.AppendTail(pMaterial);

14
materialsystem/vulkan/vulkan_state.h
View File

@@ -208,6 +208,7 @@ public:
VkImageLayout m_eImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
EDependencyMode m_eLastUsage = DEPENDENCY_MODE_JUST_CREATED;
VkDescriptorType m_eDescriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
};
class CVkBuffer: public IBuffer
@@ -310,8 +311,6 @@ class CVkComputeShader : public IComputeShader
{
public:
virtual void Build() override;
void BuildCompute();
void BuildTrace();
VkDevice m_hDevice;
CCompiledShader m_shader;
@@ -383,7 +382,7 @@ public:
class CVkMaterial: public IMaterial
{
public:
CVkMaterial( IShader *pShader );
CVkMaterial( IBaseShader *pShader );
virtual ~CVkMaterial() override;
void Frame();
@@ -398,7 +397,12 @@ public:
virtual void PSSetTexture( uint32_t uRegister, IImage *pImage ) override;
virtual void PSSetSampler( uint32_t uRegister, ISampler *pImage ) override;
CVkShader *m_pVkShader;
virtual void CSSetConstantsBuffer( uint32_t uRegister, uint32_t uSet, IBuffer *pBuffer ) override;
virtual void CSSetTexture( uint32_t uRegister, uint32_t uSet, IImage *pImage ) override;
virtual void CSSetSampler( uint32_t uRegister, uint32_t uSet, ISampler *pSampler ) override;
virtual void CSSetTextureArray( uint32_t uSet, ITextureArray *pArray ) override;
IBaseShader *m_pShader;
CUtlVector<VkDescriptorSet> m_hSets;
private:
VkDescriptorPool m_hPool;
@@ -490,6 +494,7 @@ public:
virtual void EndRecording() override;
virtual void Barrier( IRenderingObject *pObject, bool bIsRead, bool bIsWrite ) override;
virtual void DispatchCompute( uint32_t uX, uint32_t uY, uint32_t uZ ) override;
virtual void CopyImageToImage( IImage *pSrc, IImage *pDst ) override;
virtual void BlitImageToImage( IImage *pSrc, ImageSector_t src, IImage *pDst, ImageSector_t dst ) override;
@@ -497,6 +502,7 @@ public:
virtual void ClearDepth( IImage *pImage, float fVal ) override;
void Submit();
void FlushBarriers( CVkCommand *pCmd );
IVkCommandBufferManager *m_pCommandBufferManager;
private: