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

added barriers, started working on libraries

Browse Source
This commit is contained in:
kotofyt
2025-12-15 20:31:16 +02:00
parent 5d4c587bf2
commit dd1a51b752
20 changed files with 608 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
build.cpp Normal file → Executable file
View File

4
engine/filesystem_pak.cpp
View File

@@ -82,7 +82,7 @@ public:
return;
delete pHandle;
}
virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) override { return NULL; };
};
CPAKFileSystem g_pakFileSystem;
IFileSystem *filesystem_pak = &g_pakFileSystem;
EXPOSE_FILESYSTEM(CPAKFileSystem, "pakfs");

BIN
fpc/fpc_temp Executable file
View File

Binary file not shown.

18
funnyassets/__build.cpp
View File

@@ -8,24 +8,24 @@
void build_shader( const char *szName )
{
filesystem2->MakeDirectory(CUtlString("build/funnygame/metal/gfx"));
filesystem2->MakeDirectory(CUtlString("build/funnygame/vulkan/gfx"));
filesystem2->MakeDirectory(CUtlString("build/funnygame/metal/shaders"));
filesystem2->MakeDirectory(CUtlString("build/funnygame/vulkan/shaders"));
CUtlVector<CUtlString> slang_args = {
CUtlString("funnyassets/gfx_shaders/%s.slang", szName),
CUtlString("funnyassets/shaders/%s.slang", szName),
"-g",
"-target",
"spirv",
"-D",
"__SPIRV__=1",
"-o",
CUtlString("build/funnygame/vulkan/gfx/%s.shader", szName),
CUtlString("build/funnygame/vulkan/shaders/%s.spv", szName),
};
runner->Run("slangc", slang_args);
slang_args[3] = "metal";
slang_args[5] = "__METAL__=1";
slang_args[7] = CUtlString("build/funnygame/metal/gfx/%s.shader", szName);
slang_args[7] = CUtlString("build/funnygame/metal/shaders/%s.spv", szName);
runner->Run("slangc", slang_args);
runner->Wait();
};
@@ -37,16 +37,19 @@ DECLARE_BUILD_STAGE(assets)
filesystem2->CopyDirectory("build", "tools");
filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/maps");
filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/gfx");
filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/shaders");
filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/fonts");
filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/textures");
filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/materials");
/*
build_shader("mesh_frag");
build_shader("mesh_vert");
build_shader("fgui_rect_frag");
build_shader("fgui_rect_vert");
build_shader("fgui_text_frag");
build_shader("fgui_text_vert");
*/
build_shader("flat");
CUtlVector<CUtlString> python_args = {
"build/tools/makepak64.py",
CUtlString("build/funnygame/assets"),
@@ -62,12 +65,15 @@ DECLARE_BUILD_STAGE(assets)
};
runner->Run("python3", python_args);
} else {
filesystem2->CopyDirectory(CUtlString("%s/funnygame", szOutputDir.GetString()),"build/funnygame/vulkan/shaders");
/*
python_args = {
"build/tools/makepak64.py",
CUtlString("build/funnygame/vulkan"),
bStaticBuild ? CUtlString("%s/bin/%s.pak", szOutputDir.GetString(), "vulkan") : CUtlString("%s/funnygame/%s.pak", szOutputDir.GetString(), "vulkan"),
};
runner->Run("python3", python_args);
*/
}
runner->Wait();

23
funnyassets/shaders/flat.slang Normal file
View File

@@ -0,0 +1,23 @@
struct VS_INPUT
{
float3 m_vPosition;
}
struct PS_INPUT
{
float4 m_vPosition;
}
[shader("vertex")]
PS_INPUT vsMain( VS_INPUT i )
{
PS_INPUT o;
o.m_vPosition = { i.m_vPosition, 1 };
return o;
}
[shader("pixel")]
float4 psMain( PS_INPUT i )
{
return float4(1);
}

4
materialsystem/__build.cpp
View File

@@ -9,7 +9,11 @@ CUtlVector<CUtlString> MaterialSystem_CompiledFiles = {
"materialsystem/vulkan/rendercontext.cpp",
"materialsystem/vulkan/material.cpp",
"materialsystem/vulkan/commandbuffer.cpp",
"materialsystem/vulkan/utils.cpp",
"materialsystem/vulkan/shader.cpp",
"materialsystem/vulkan/commands/draw.cpp",
"materialsystem/vulkan/commands/base.cpp",
"materialsystem/vulkan/libraries/raster.cpp",
"external/volk/volk.c",
};
CUtlString material_lib;

187
materialsystem/vulkan/commandbuffer.cpp
View File

@@ -7,6 +7,20 @@
CUtlVector<VkCommandBuffer> g_vkCommandBuffers;
IVkCommandBufferManager *g_pCommandBufferManager;
struct VulkanCommandLastUsage_t
{
uint32_t m_nLastUsedCommand;
EDependencyMode m_eLastUsage;
VulkanCommandDepenency_t m_dependency;
};
struct VulkanSwapchainCommandLastUsage_t
{
uint32_t m_nLastUsedCommand;
EDependencyMode m_eLastUsage;
VulkanCommandSwapchainDepenency_t m_dependency;
};
class CVkCommandBuffer: public IVkCommandBuffer
{
public:
@@ -16,12 +30,15 @@ public:
virtual void Render() override;
private:
void SortDependencies();
void TryBarrier();
void TryBarrier( int iCurrent, int iCurrentBuffer );
VulkanCommandDepenency_t *FindLastObjectDependency( IRenderingObject *pObject );
CUtlSelfReferencingVector<CVkCommand*> m_commands;
CUtlVector<CVkCommand*> m_commands;
CUtlVector<VkCommandBuffer> m_hBuffers = NULL;
CUtlVector<VulkanCommandDepenency_t> m_usedDependencies;
CUtlVector<VulkanCommandLastUsage_t> m_usedDependencies;
CUtlVector<CUtlVector<VulkanCommandLastUsage_t>> m_dependencies;
CUtlVector<VulkanSwapchainCommandLastUsage_t> m_usedSwapchainDependencies;
CUtlVector<CUtlVector<VulkanSwapchainCommandLastUsage_t>> m_swapchainDependencies;
};
void CVkCommandBuffer::Reset()
@@ -65,17 +82,22 @@ void CVkCommandBuffer::Render()
uint32_t nNumDependencies;
int i = 0;
int y = 0;
SortDependencies();
for (auto hBuffer: m_hBuffers)
{
y = 0;
VkCommandBufferBeginInfo stCommandBufferBeginInfo = {};
stCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
vkBeginCommandBuffer(hBuffer, &stCommandBufferBeginInfo);
for (auto &pCommand: m_commands)
{
TryBarrier();
TryBarrier(y,i);
pCommand->Execute(hBuffer, i);
y++;
};
vkEndCommandBuffer(hBuffer);
@@ -89,33 +111,161 @@ struct VulkanCommandBarrier_t
EDependencyMode m_eNewDependency;
IRenderingObject *m_pObject;
};
void CVkCommandBuffer::SortDependencies()
{
m_dependencies = {};
m_swapchainDependencies = {};
m_dependencies.Resize(m_commands.GetSize());
m_swapchainDependencies.Resize(m_commands.GetSize());
m_usedDependencies = {};
m_usedSwapchainDependencies = {};
int i = 0;
for ( auto dependency: m_dependencies)
{
dependency = NULL;
}
void CVkCommandBuffer::TryBarrier()
{
CUtlVector<VulkanCommandBarrier_t> barriers;
for (auto &pCommand: m_commands)
{
for ( auto dependency: pCommand->m_depedencies)
for ( auto dependency: pCommand->m_dependencies)
{
VulkanCommandDepenency_t *pLastDependency = FindLastObjectDependency(dependency.m_pObject);
VulkanCommandLastUsage_t *pLastUsage = NULL;
for ( auto &dep: m_usedDependencies )
{
if (dep.m_dependency.m_pObject == dependency.m_pObject)
pLastUsage = &dep;
}
VulkanCommandLastUsage_t stLastUsage = {};
stLastUsage.m_nLastUsedCommand = i;
stLastUsage.m_dependency = dependency;
stLastUsage.m_eLastUsage = DEPENDENCY_MODE_FROM_PREVIOUS;
if (pLastUsage)
stLastUsage.m_eLastUsage = pLastUsage->m_dependency.m_eDependencyMode;
if (pLastUsage)
m_dependencies[pLastUsage->m_nLastUsedCommand+1].AppendTail(stLastUsage);
else
m_dependencies[0].AppendTail(stLastUsage);
m_usedDependencies.AppendTail(stLastUsage);
}
for ( auto dependency: pCommand->m_swapchainDependencies)
{
VulkanSwapchainCommandLastUsage_t *pLastUsage = NULL;
for ( auto &dep: m_usedSwapchainDependencies )
{
if (dep.m_dependency.m_ppObjects == dependency.m_ppObjects)
pLastUsage = &dep;
}
VulkanSwapchainCommandLastUsage_t stLastUsage = {};
stLastUsage.m_nLastUsedCommand = i;
stLastUsage.m_dependency = dependency;
stLastUsage.m_eLastUsage = DEPENDENCY_MODE_FROM_PREVIOUS;
if (pLastUsage)
stLastUsage.m_eLastUsage = pLastUsage->m_dependency.m_eDependencyMode;
if (pLastUsage)
m_swapchainDependencies[pLastUsage->m_nLastUsedCommand+1].AppendTail(stLastUsage);
else
m_swapchainDependencies[0].AppendTail(stLastUsage);
m_usedSwapchainDependencies.AppendTail(stLastUsage);
}
i++;
}
}
void CVkCommandBuffer::TryBarrier( int iCurrent, int iCurrentBuffer )
{
int x = 0;
CUtlVector<VulkanCommandLastUsage_t> dependency = m_dependencies[iCurrent];
CUtlVector<VulkanSwapchainCommandLastUsage_t> swapchainDependency = m_swapchainDependencies[iCurrent];
CUtlVector<VulkanCommandBarrier_t> barriers;
VkDependencyInfo stDependencyInfo = {};
stDependencyInfo.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
CUtlVector<VkMemoryBarrier2> memoryBarriers = {};
CUtlVector<VkImageMemoryBarrier2> imageBarriers = {};
CUtlVector<VkBufferMemoryBarrier2> bufferBarriers = {};
for (auto barrier: dependency)
{
VulkanCommandBarrier_t stBarrier = {};
stBarrier.m_eOldDependency = barrier.m_eLastUsage;
stBarrier.m_eNewDependency = barrier.m_dependency.m_eDependencyMode;
stBarrier.m_pObject = barrier.m_dependency.m_pObject;
barriers.AppendTail(stBarrier);
x++;
};
x = 0;
for (auto barrier: swapchainDependency)
{
VulkanCommandBarrier_t stBarrier = {};
stBarrier.m_eOldDependency = barrier.m_eLastUsage;
stBarrier.m_eNewDependency = barrier.m_dependency.m_eDependencyMode;
stBarrier.m_pObject = barrier.m_dependency.m_ppObjects[iCurrentBuffer];
barriers.AppendTail(stBarrier);
x++;
};
for ( auto barrier: barriers )
{
union {
IRenderingObject *pObject;
CVkImage *pImage;
CVkBuffer *pBuffer;
};
VulkanCommandDepenency_t *CVkCommandBuffer::FindLastObjectDependency( IRenderingObject *pObject )
pObject = barrier.m_pObject;
if (dynamic_cast<CVkImage*>(pObject))
{
VulkanCommandDepenency_t *pDependency = NULL;
for ( auto &dependency: m_usedDependencies )
VkImageMemoryBarrier2 imageMemoryBarrier = {};
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
imageMemoryBarrier.image = pImage->m_image;
imageMemoryBarrier.subresourceRange = pImage->m_range;
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.newLayout = VulkanGetImageLayout(barrier.m_eNewDependency);
imageMemoryBarrier.dstStageMask = VulkanGetStageFlags(barrier.m_eNewDependency);
imageMemoryBarrier.dstAccessMask = VulkanGetAccessFlags(barrier.m_eNewDependency);
if (barrier.m_eOldDependency == DEPENDENCY_MODE_FROM_PREVIOUS)
{
if ( dependency.m_pObject == pObject )
pDependency = &dependency;
imageMemoryBarrier.oldLayout = VulkanGetImageLayout(pImage->m_eLastUsage);
imageMemoryBarrier.srcStageMask = VulkanGetStageFlags(pImage->m_eLastUsage);
imageMemoryBarrier.srcAccessMask = VulkanGetAccessFlags(pImage->m_eLastUsage);
} else {
imageMemoryBarrier.oldLayout = VulkanGetImageLayout(barrier.m_eOldDependency);
imageMemoryBarrier.srcStageMask = VulkanGetStageFlags(barrier.m_eOldDependency);
imageMemoryBarrier.srcAccessMask = VulkanGetAccessFlags(barrier.m_eOldDependency);
}
return pDependency;
imageBarriers.AppendTail(imageMemoryBarrier);
pImage->m_eLastUsage = barrier.m_eNewDependency;
}
if (dynamic_cast<CVkBuffer*>(pObject))
{
}
}
if (imageBarriers.GetSize() == 0 && bufferBarriers.GetSize() == 0 )
return;
stDependencyInfo.imageMemoryBarrierCount = imageBarriers.GetSize();
stDependencyInfo.bufferMemoryBarrierCount = bufferBarriers.GetSize();
stDependencyInfo.pImageMemoryBarriers = imageBarriers.GetData();
stDependencyInfo.pBufferMemoryBarriers = bufferBarriers.GetData();
vkCmdPipelineBarrier2(m_hBuffers[iCurrentBuffer], &stDependencyInfo);
};
class CVkCommandBufferManager: public IVkCommandBufferManager
{
@@ -175,5 +325,10 @@ CVkCommandRegistry::CVkCommandRegistry( const char *szName, fnCreateVulkanComman
void CVkCommand::AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode )
{
m_depedencies.AppendTail({ pObject, eDependencyMode });
m_dependencies.AppendTail({ pObject, eDependencyMode });
}
void CVkCommand::AddSwapchainDependency( IRenderingObject **ppObject, EDependencyMode eDependencyMode )
{
m_swapchainDependencies.AppendTail({ ppObject, eDependencyMode });
}

26
materialsystem/vulkan/commands.h
View File

@@ -1,6 +1,7 @@
#ifndef VULKAN_COMMANDS_H
#define VULKAN_COMMANDS_H
#include "tier1/utlvector.h"
#include "vulkan_state.h"
BEGIN_VULKAN_COMMAND(ClearColor)
@@ -12,4 +13,29 @@ BEGIN_VULKAN_COMMAND(ClearColor)
IImage **ppSwapchainImages = NULL;
END_VULKAN_COMMAND(ClearColor)
struct VulkanRenderOutput_t {
EResolveMode m_eResolveMode;
VkFrameObject_t m_stImage;
VkFrameObject_t m_stResolveImage;
ELoadMode m_eLoadMode;
EStoreMode m_eStoreMode;
};
BEGIN_VULKAN_COMMAND(Begin)
CUtlVector<VulkanRenderOutput_t> images;
VulkanRenderOutput_t stDepthImage;
uint32_t nResolutionX;
uint32_t nResolutionY;
END_VULKAN_COMMAND(Begin)
BEGIN_VULKAN_COMMAND(End)
END_VULKAN_COMMAND(End)
BEGIN_VULKAN_COMMAND(Empty)
END_VULKAN_COMMAND(Empty)
#endif

7
materialsystem/vulkan/commands/base.cpp Normal file
View File

@@ -0,0 +1,7 @@
#include "../vulkan_state.h"
#include "../commands.h"
#include "tier0/platform.h"
DECLARE_VULKAN_COMMAND(Empty)
{
}

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

@@ -1,6 +1,9 @@
#include "../vulkan_state.h"
#include "../commands.h"
#include "materialsystem/imaterialsystem.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"
#include "vulkan/vulkan_core.h"
DECLARE_VULKAN_COMMAND(ClearColor)
@@ -8,7 +11,6 @@ DECLARE_VULKAN_COMMAND(ClearColor)
CVkImage *pImg;
pImage = NULL;
if (pImage)
pImg = (CVkImage*)pImage;
if (ppSwapchainImages)
@@ -17,7 +19,6 @@ DECLARE_VULKAN_COMMAND(ClearColor)
if (pImg == NULL)
Plat_FatalErrorFunc("pImage and *ppSwapchainImages are NULL\n");
AddDependency(pImg, DEPENDENCY_MODE_IMAGE_DESTINATION);
VkClearColorValue color = {.float32 = {r,g,b,a}};
VkImageSubresourceRange range = {
@@ -27,3 +28,31 @@ DECLARE_VULKAN_COMMAND(ClearColor)
};
vkCmdClearColorImage(hCommandBuffer, pImg->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &range);
}
DECLARE_VULKAN_COMMAND(Begin)
{
VkRenderingInfo stRenderingInfo = {};
CUtlVector<VkRenderingAttachmentInfo> attachments;
for (auto i: images)
{
VkRenderingAttachmentInfo a;
a.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
a.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
a.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
a.imageView = ((CVkImage*)VulkanGetObject(i.m_stImage, iCurrentFrame))->m_imageView;
attachments.AppendTail(a);
}
stRenderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
stRenderingInfo.layerCount = 1;
stRenderingInfo.colorAttachmentCount = attachments.GetSize();
stRenderingInfo.pColorAttachments = attachments.GetData();
vkCmdBeginRendering(hCommandBuffer, &stRenderingInfo);
}
DECLARE_VULKAN_COMMAND(End)
{
vkCmdEndRendering(hCommandBuffer);
}

57
materialsystem/vulkan/libraries/raster.cpp Normal file
View File

@@ -0,0 +1,57 @@
#include "../vulkan_state.h"
#include "../raster_libraries.h"
#include "tier1/utlbuffer.h"
#include "tier2/ifilesystem.h"
#include "vulkan/vulkan_core.h"
BEGIN_BUILD_PIPELINE_LIBRARY(Functions)
CUtlBuffer<unsigned char> vertexShaderData;
VkShaderModuleCreateInfo stVertexModule = {};
VkPipelineShaderStageCreateInfo stVertexStage = {};
if (szVertexShader)
{
IFileHandle *pFile = filesystem->Open(szVertexShader, FILEMODE_READ);
vertexShaderData = filesystem->Read(pFile);
pFile->Close();
stVertexModule.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
stVertexModule.codeSize = vertexShaderData.GetSize();
stVertexModule.pCode = (uint32_t*)vertexShaderData.GetMemory();
stVertexStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stVertexStage.pName = szVertexShaderMain;
stVertexStage.pNext = &stVertexModule;
}
CUtlBuffer<unsigned char> pixelShaderData;
VkShaderModuleCreateInfo stPixelModule = {};
VkPipelineShaderStageCreateInfo stPixelStage = {};
if (szPixelShader)
{
IFileHandle *pFile = filesystem->Open(szPixelShader, FILEMODE_READ);
pixelShaderData = filesystem->Read(pFile);
pFile->Close();
stPixelModule.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
stPixelModule.codeSize = pixelShaderData.GetSize();
stPixelModule.pCode = (uint32_t*)pixelShaderData.GetMemory();
stPixelStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stPixelStage.pName = szPixelShaderMain;
stPixelStage.pNext = &stPixelModule;
}
END_BUILD_PIPELINE_LIBRARY()
void CVkFunctionsPipelineLibrary::SetVertex( const char *szFile, const char *szMain )
{
szVertexShader = szFile;
szVertexShaderMain = szMain;
}
void CVkFunctionsPipelineLibrary::SetPixel( const char *szFile, const char *szMain )
{
szPixelShader = szFile;
szPixelShaderMain = szMain;
}

36
materialsystem/vulkan/raster_libraries.h Normal file
View File

@@ -0,0 +1,36 @@
#include "vulkan_state.h"
BEGIN_DEFINE_PIPELINE_LIBRARY(Functions)
private:
const char *szVertexShader;
const char *szVertexShaderMain;
const char *szPixelShader;
const char *szPixelShaderMain;
public:
void SetVertex( const char *szFile, const char *szMain );
void SetPixel( const char *szFile, const char *szMain );
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(VertexInput)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(InputAssembly)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(Tesselation)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(ViewportState)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(RasterizationState)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(MultisampleState)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(DepthStencilState)
END_DEFINE_PIPELINE_LIBRARY()
BEGIN_DEFINE_PIPELINE_LIBRARY(ColorBlend)
END_DEFINE_PIPELINE_LIBRARY()

61
materialsystem/vulkan/rendercontext.cpp
View File

@@ -10,6 +10,7 @@
#include "vulkan/vulkan_core.h"
#include "vulkan_state.h"
#include "igamewindow.h"
#include "raster_libraries.h"
#define REQUIRED_EXTENSION(ext) ext##_EXTENSION_NAME,
@@ -126,6 +127,7 @@ void CVkImage::CreateImageView()
stImageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
stImageViewCreateInfo.subresourceRange.layerCount = 1;
stImageViewCreateInfo.subresourceRange.levelCount = 1;
m_range = stImageViewCreateInfo.subresourceRange;
vkCreateImageView(g_vkDevice, &stImageViewCreateInfo, NULL, &m_imageView);
}
void CVkImage::SetDebugName( const char *szName )
@@ -155,25 +157,6 @@ EMultisampleType CVkImage::GetMultisampleType()
}
class CVkBuffer: public IBuffer
{
public:
CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlignment );
~CVkBuffer();
virtual void SetDebugName( const char *szName ) override;
virtual void Lock() override;
virtual void Unlock() override;
virtual void *Map() override;
virtual void Unmap() override;
virtual uint32_t GetSize() override;
VmaAllocation allocation;
VkBuffer buffer;
VkDeviceAddress address;
uint32_t nSize;
};
CVkBuffer::CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlignment )
{
}
@@ -360,8 +343,7 @@ void CVkRenderContext::DrawPrimitivesIndexed( uint32_t nIndexCount, uint32_t nFi
}
IVkCommandBuffer *pCommandBuffer;
IVkCommandBuffer *s_pPresentCommandBuffer;
IImage *pCurrentImage;
static IVkCommandBuffer *s_pPresentCommandBuffer;
void CVkRenderContext::Init()
{
VkResult r;
@@ -448,11 +430,16 @@ void CVkRenderContext::Init()
stDeviceQueueCreateInfo.pQueuePriorities = &fPriority;
stDeviceQueueCreateInfo.queueFamilyIndex = g_iDrawFamily;
VkPhysicalDeviceVulkan13Features vk13Features = {};
vk13Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
vk13Features.synchronization2 = VK_TRUE;
stDeviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
stDeviceCreateInfo.queueCreateInfoCount = 1;
stDeviceCreateInfo.pQueueCreateInfos = &stDeviceQueueCreateInfo;
stDeviceCreateInfo.enabledExtensionCount = enabledDeviceExtensions.GetSize();
stDeviceCreateInfo.ppEnabledExtensionNames = enabledDeviceExtensions.GetData();
stDeviceCreateInfo.pNext = &vk13Features;
r = vkCreateDevice(g_vkPhysicalDevice, &stDeviceCreateInfo, NULL, &g_vkDevice);
VULKAN_RESULT_PRINT(r, vkEnumeratePhysicalDevices);
for (auto &extension: enabledDeviceExtensions)
@@ -477,21 +464,44 @@ void CVkRenderContext::Init()
g_pCommandBufferManager->Init();
pCommandBuffer = g_pCommandBufferManager->CreateCommandBuffer();
s_pPresentCommandBuffer = g_pCommandBufferManager->CreateCommandBuffer();
CVkClearColorCommand *pCommand = (CVkClearColorCommand*)g_pCommandBufferManager->CreateCommand("ClearColor");
pCommand->pImage = NULL;
pCommand->ppSwapchainImages = g_vkSwapchainImages.GetData();
pCommand->r = 1;
pCommand->b = 1;
pCommand->g = 0;
pCommand->AddSwapchainDependency( (IRenderingObject**)g_vkSwapchainImages.GetData(), DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION );
CVkFunctionsPipelineLibrary functions = {};
functions.SetVertex("funnygame/shaders/flat.spv", "vsMain");
functions.SetPixel("funnygame/shaders/flat.spv", "psMain");
functions.Build();
CVkEmptyCommand *pPresentCommand = (CVkEmptyCommand*)g_pCommandBufferManager->CreateCommand("Empty");
pPresentCommand->AddSwapchainDependency( (IRenderingObject**)g_vkSwapchainImages.GetData(), DEPENDENCY_MODE_IMAGE_PRESENT );
CVkBeginCommand *pBeginCommand = (CVkBeginCommand*)g_pCommandBufferManager->CreateCommand("Empty");
pBeginCommand->AddSwapchainDependency((IRenderingObject**)g_vkSwapchainImages.GetData(), DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE);
CVkBeginCommand *pEndCommand = (CVkBeginCommand*)g_pCommandBufferManager->CreateCommand("Empty");
pCommandBuffer->Reset();
pCommandBuffer->AddCommand(pCommand);
pCommandBuffer->Render();
s_pPresentCommandBuffer->Reset();
s_pPresentCommandBuffer->AddCommand(pPresentCommand);
s_pPresentCommandBuffer->Render();
}
void CVkRenderContext::Frame( float fDeltaTime )
{
vkDeviceWaitIdle(g_vkDevice);
pCommandBuffer->Render();
s_pPresentCommandBuffer->Render();
static uint32_t s_nImageIndex = 0;
uint32_t nImageIndex = 0;
@@ -500,6 +510,11 @@ void CVkRenderContext::Frame( float fDeltaTime )
vkResetFences(g_vkDevice, 1, &g_vkFences[s_nImageIndex]);
g_vkCommandBuffers = {};
pCommandBuffer->Submit(nImageIndex);
s_pPresentCommandBuffer->Submit(nImageIndex);
VkPipelineStageFlags uPipelineStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo stSubmitInfo = {};
stSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -507,10 +522,6 @@ void CVkRenderContext::Frame( float fDeltaTime )
stSubmitInfo.pWaitSemaphores = &g_vkGraphicsSemaphores[s_nImageIndex];
stSubmitInfo.pWaitDstStageMask = &uPipelineStageFlags;
pCurrentImage = g_vkSwapchainImages[nImageIndex];
g_vkCommandBuffers = {};
pCommandBuffer->Submit(nImageIndex);
stSubmitInfo.commandBufferCount = g_vkCommandBuffers.GetSize();
stSubmitInfo.pCommandBuffers = g_vkCommandBuffers.GetData();

3
materialsystem/vulkan/shader.cpp
View File

@@ -0,0 +1,3 @@
#include "vulkan_state.h"

50
materialsystem/vulkan/utils.cpp Normal file
View File

@@ -0,0 +1,50 @@
#include "vulkan_state.h"
IRenderingObject *VulkanGetObject( VkFrameObject_t stObject, int iIndex )
{
switch (stObject.m_eObjectType)
{
case FRAME_OBJECT_TYPE_SINGLE:
return stObject.m_pSingle;
case FRAME_OBJECT_TYPE_SWAPPED:
return stObject.m_ppSwapped[iIndex];
default:
return NULL;
}
}
VkAccessFlags2 VulkanGetAccessFlags( EDependencyMode eMode )
{
switch (eMode)
{
case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR;
case DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION: return VK_ACCESS_2_TRANSFER_WRITE_BIT;
case DEPENDENCY_MODE_IMAGE_PRESENT: return VK_ACCESS_2_NONE;
default:
return 0;
}
}
VkPipelineStageFlags2 VulkanGetStageFlags( EDependencyMode eMode )
{
switch (eMode)
{
case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
case DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION: return VK_PIPELINE_STAGE_2_TRANSFER_BIT;
case DEPENDENCY_MODE_IMAGE_PRESENT: return VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
default:
return VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
}
}
VkImageLayout VulkanGetImageLayout( EDependencyMode eMode )
{
switch (eMode)
{
case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
case DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
case DEPENDENCY_MODE_IMAGE_PRESENT: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
default:
return VK_IMAGE_LAYOUT_UNDEFINED;
}
}

96
materialsystem/vulkan/vulkan_state.h
View File

@@ -58,13 +58,20 @@ enum EDependencyMode
DEPENDENCY_MODE_DRAWCALL_VERTEX_BUFFER,
DEPENDENCY_MODE_DRAWCALL_INDEX_BUFFER,
DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE,
DEPENDENCY_MODE_DRAWCALL_INPUT_IMAGE,
DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE,
DEPENDENCY_MODE_IMAGE_SOURCE,
DEPENDENCY_MODE_IMAGE_DESTINATION,
DEPENDENCY_MODE_COLOR_CLEAR_SOURCE,
DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION,
DEPENDENCY_MODE_ALL_COMMANDS,
DEPENDENCY_MODE_IMAGE_PRESENT,
DEPENDENCY_MODE_FROM_PREVIOUS,
DEPENDENCY_MODE_COUNT,
};
@@ -73,6 +80,10 @@ struct VulkanCommandDepenency_t {
IRenderingObject *m_pObject;
EDependencyMode m_eDependencyMode;
};
struct VulkanCommandSwapchainDepenency_t {
IRenderingObject **m_ppObjects;
EDependencyMode m_eDependencyMode;
};
struct VulkanCommandParameter_t
{
@@ -90,10 +101,12 @@ public:
virtual void Execute( VkCommandBuffer hCommandBuffer, int iCurrentFrame ) = 0;
//virtual const char *GetName();
CUtlVector<VulkanCommandDepenency_t> m_depedencies;
CUtlVector<VulkanCommandDepenency_t> m_dependencies = {};
CUtlVector<VulkanCommandSwapchainDepenency_t> m_swapchainDependencies = {};
EVulkanCommandType m_eType;
protected:
void AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode );
void AddSwapchainDependency( IRenderingObject **ppObjects, EDependencyMode eDependencyMode );
};
abstract_class IVkCommandBuffer
@@ -173,9 +186,88 @@ public:
VkImage m_image;
VkImageView m_imageView;
VmaAllocation m_allocation;
VkImageSubresourceRange m_range;
VkImageLayout m_eImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
EDependencyMode m_eLastUsage;
};
class CVkBuffer: public IBuffer
{
public:
CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlignment );
~CVkBuffer();
virtual void SetDebugName( const char *szName ) override;
virtual void Lock() override;
virtual void Unlock() override;
virtual void *Map() override;
virtual void Unmap() override;
virtual uint32_t GetSize() override;
VmaAllocation allocation;
VkBuffer buffer;
VkDeviceAddress address;
uint32_t nSize;
};
class CVkPipelineLibrary
{
public:
virtual void Build() = 0;
VkPipeline m_hPipeline = NULL;
};
#define BEGIN_DEFINE_PIPELINE_LIBRARY(name) \
class CVk##name##PipelineLibrary: public CVkPipelineLibrary \
{ \
public: \
virtual void Build() override; \
#define END_DEFINE_PIPELINE_LIBRARY() \
};
#define BEGIN_BUILD_PIPELINE_LIBRARY(name) \
void CVk##name##PipelineLibrary::Build() \
{ \
VkGraphicsPipelineCreateInfo pipeline = {}; \
pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; \
#define END_BUILD_PIPELINE_LIBRARY() \
vkCreateGraphicsPipelines(g_vkDevice, NULL, 1, &pipeline, NULL, &m_hPipeline); \
}
class CVkShader : IShader
{
public:
void AddShaderLibrary( CVkPipelineLibrary *pLibrary );
void Build();
VkPipeline m_hPipeline = NULL;
VkPipelineLayout m_hPipelineLayout;
CUtlVector<CVkPipelineLibrary*> m_libraries;
};
enum EVkFrameObjectType_t
{
FRAME_OBJECT_TYPE_SINGLE,
FRAME_OBJECT_TYPE_SWAPPED,
};
struct VkFrameObject_t
{
EVkFrameObjectType_t m_eObjectType;
union {
IRenderingObject *m_pSingle;
IRenderingObject **m_ppSwapped;
};
};
IRenderingObject *VulkanGetObject( VkFrameObject_t stObject, int iIndex );
VkAccessFlags2 VulkanGetAccessFlags( EDependencyMode eMode );
VkPipelineStageFlags2 VulkanGetStageFlags( EDependencyMode eMode );
VkImageLayout VulkanGetImageLayout( EDependencyMode eMode );
#endif

31
public/materialsystem/imaterialsystem.h
View File

@@ -38,6 +38,37 @@ enum EMultisampleType
MULTISAMPLE_TYPE_8_SAMPLES,
};
enum EResolveMode
{
RESOLVE_MODE_NONE,
RESOLVE_MODE_ZERO,
RESOLVE_MODE_AVERAGE,
RESOLVE_MODE_MIN,
RESOLVE_MODE_MAX,
};
enum ELoadMode
{
LOAD_MODE_LOAD,
LOAD_MODE_CLEAR,
LOAD_MODE_DONT_CARE,
};
enum EStoreMode
{
STORE_MODE_STORE,
STORE_MODE_DONT_CARE,
};
enum ETopologyMode
{
TOPOLOGY_MODE_POINT_LIST,
TOPOLOGY_MODE_LINE_LIST,
TOPOLOGY_MODE_LINE_STRIP,
TOPOLOGY_MODE_TRIANGLE_LIST,
TOPOLOGY_MODE_TRIANGLE_STRIP,
};
abstract_class IRenderingObject
{
public:

4
public/tier2/ifilesystem.h
View File

@@ -3,6 +3,7 @@
#include "iappsystem.h"
#include "tier0/platform.h"
#include "tier1/utlbuffer.h"
enum EFileMode
{
@@ -55,6 +56,9 @@ public:
virtual void Close( IFileHandle *pFile ) = 0;
// Some cool stuff
virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) = 0;
IFileSystem *m_pNext;
void RegisterFileSystem();

11
tier2/filesystem.cpp
View File

@@ -1,6 +1,8 @@
#include "tier1/utlbuffer.h"
#include "tier2/ifilesystem.h"
#include "tier1/interface.h"
#include "tier0/lib.h"
#include <cstdio>
size_t IFileHandle::Write( const void *pData, size_t nDataSize )
{
@@ -83,6 +85,15 @@ public:
{
}
virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) override
{
CUtlBuffer<unsigned char> buffer;
buffer = CUtlBuffer<unsigned char>(Size(pFile));
Read(pFile, buffer.GetMemory(), buffer.GetSize());
return buffer;
}
};

2
tier2/filesystem_libc.cpp
View File

@@ -107,6 +107,8 @@ public:
V_fclose(pHandle->m_pFile);
delete pHandle;
}
virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) override { return NULL; };
};
EXPOSE_FILESYSTEM(CLIBCFileSystem, "sysfs");