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

Started work on build system

Browse Source
This commit is contained in:
kotofyt
2025-05-31 00:42:41 +03:00
parent 953cca2aa4
commit ade32c24a6
33 changed files with 369 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
engine/__build.c
View File

@@ -16,7 +16,6 @@ void engine_build(struct build_data b)
/* rendering */
"engine/vk_video.cpp",
"engine/vk_brush.cpp",
"engine/vk_mesh.cpp",
szVideoFile,

37
engine/baseentity.cpp
View File

@@ -1,14 +1,49 @@
#include "baseentity.h"
#include "cglm/mat4.h"
#include "tier0/platform.h"
#include "tier1/utlstring.h"
CUtlSelfReferencingVector<CBaseEntity*> g_entities;
CUtlVector<CEntityRegistry*> g_RegisteredEntities;
CBaseEntity::CBaseEntity()
{
glm_mat4_identity(m_matrix);
glm_mat3_identity(m_matrix);
glm_vec3_zero(m_position);
glm_vec3_zero(m_scale);
};
void CBaseEntity::ReadParameter( const char *szName, const char *szValue )
{
CUtlString name = szName;
if (name == "origin")
V_sscanf(szValue, "%f %f %f", &m_position[0], &m_position[1], &m_position[2]);
}
void CBaseEntity::SetPosition( vec3 position )
{
V_memcpy(m_position, position, sizeof(vec3));
}
void CBaseEntity::SetRotationEuler( vec3 euler )
{
}
void CBaseEntity::SetRotationQuat( vec4 quaternion )
{
}
void CBaseEntity::SetRotationMatrix( mat3 matrix )
{
V_memcpy(m_matrix, matrix, sizeof(mat3));
}
void CBaseEntity::SetScale( vec3 scale )
{
V_memcpy(m_scale, scale, sizeof(vec3));
}
CEntityRegistry::CEntityRegistry(const char *szName, const char *szClass, EntityRegistryFn pfn) :
m_szName(szName), m_szClass(szClass), m_pfn(pfn), m_pClientfn(0)

32
engine/brush.cpp
View File

@@ -1,4 +1,6 @@
#include "brush.h"
#include "baseentity.h"
#include "cglm/mat4.h"
#include "physics.h"
#include "rendering.h"
#include "tier0/platform.h"
@@ -12,11 +14,13 @@ void CBrushEntity::Precache()
void CBrushEntity::Spawn()
{
/* physics don't support unindexed meshes, so generate indicies */
CUtlBuffer<uint32_t> indicies(m_mesh.GetSize()*3);
for (uint32_t i = 0;i<indicies.GetSize();i++)
{
indicies[i]=i;
}
/* copy over the triangles to a separate buffer, which will be used by physics */
CUtlBuffer<Point<float>> triangles(m_mesh.GetSize()*3);
uint32_t i = 0;
for (auto tri: m_mesh)
@@ -24,17 +28,10 @@ void CBrushEntity::Spawn()
V_memcpy(&triangles[i],tri.location,36);
i+=3;
}
/* use them */
px_collider_params params = {};
params.friction = 0.6;
m_collider = px_trimesh((Point<float>*)triangles.GetMemory(), triangles.GetSize(), (uint32_t(*)[3])indicies.GetMemory(), indicies.GetSize()/3 ,params);
//m_collider = px_box(4, 10, 1, params);
px_matrix mat = {};
mat.m[0] = 1;
mat.m[5] = 1;
mat.m[10] = 1;
mat.m[15] = 1;
px_rigidbody_params param = {};
param.gravity_scale = 1;
px_fixedbody(px, m_collider);
};
@@ -44,6 +41,12 @@ void CBrushEntity::Destroy()
}
void CBrushEntity::Think( float fDelta )
{
};
void CBrushEntity::ReadParameter( const char *szName, const char *szValue )
{
CBaseEntity::ReadParameter(szName, szValue);
};
@@ -89,7 +92,7 @@ void C_BrushEntity::Spawn()
}
vertexBuffer->Unmap();
mesh = IBrushRenderer::CreateMesh();
mesh = IMeshRenderer::CreateMesh();
mesh->SetVertexBuffer(vertexBuffer);
};
@@ -102,7 +105,16 @@ void C_BrushEntity::Think( float fDelta )
{
material.m.albedo = ITextureManager::GetTexture(pAlbedo);
IRenderer::SetMaterial(&material);
mat4 matrix;
glm_mat4_zero(matrix);
for (int i = 0; i < 9; i++) {
matrix[i/3][i%3] = pEntity->m_matrix[i/3][i%3];
}
matrix[3][3] = 1;
matrix[3][0] = pEntity->m_position[0];
matrix[3][1] = pEntity->m_position[1];
matrix[3][2] = pEntity->m_position[2];
mesh->SetMatrix(matrix);
mesh->Draw();
};

55
engine/cl_light.cpp
View File

@@ -8,8 +8,6 @@ public:
virtual void Spawn( void ) override;
virtual void Destroy( void ) override;
virtual void Think( float fDelta ) override;
IVertexBuffer *vertexBuffer;
IMesh *mesh;
};
void C_Light::Precache()
@@ -19,56 +17,7 @@ void C_Light::Precache()
void C_Light::Spawn()
{
float cubeVertices[] = {
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
};
vertexBuffer = IRenderer::CreateVertexBuffer(sizeof(cubeVertices));
void *pTriangles = vertexBuffer->Map();
V_memcpy(pTriangles, cubeVertices, sizeof(cubeVertices));
vertexBuffer->Unmap();
mesh = IMeshRenderer::CreateMesh();
mesh->SetVertexBuffer(vertexBuffer);
};
void C_Light::Destroy()
@@ -77,9 +26,7 @@ void C_Light::Destroy()
}
void C_Light::Think( float fDelta )
{
IRenderer::SetMaterial(0);
mesh->SetMatrix(pEntity->m_matrix);
mesh->Draw();
};
LINK_CLIENT_ENTITY(C_Light, CLight)

1
engine/level.cpp
View File

@@ -59,6 +59,7 @@ void ILevel::LoadLevel( const char *szLevelName )
CUtlBuffer<char> szParamValue(V_strlen(pData)+1);
V_strcpy(szParamValue, pData);
pData+=szParamValue.GetSize();
pEntity->ReadParameter(szParamName, szParamValue);
};
CBrushEntity *pBrush = dynamic_cast<CBrushEntity*>(pEntity);

29
engine/sv_light.cpp
View File

@@ -8,11 +8,9 @@ class CLight: public CBaseEntity
public:
virtual void Precache ( void ) override;
virtual void Spawn( void ) override;
virtual void ReadParameter( const char *szName, const char *szValue ) override;
virtual void Destroy( void ) override;
virtual void Think( float fDelta ) override;
private:
Collider* col;
RigidBodyHandle *m_body;
};
void CLight::Precache()
@@ -22,31 +20,22 @@ void CLight::Precache()
void CLight::Spawn()
{
px_collider_params params = {};
params.friction = 0.7;
col = px_box(0.5,0.5,0.5, params);
px_matrix mat = {};
mat.m[0] = 1;
mat.m[5] = 1;
mat.m[10] = 1;
mat.m[15] = 1;
mat.m[11]=10;
mat.m[7]=-4;
mat.m[3]=12;
px_rigidbody_params param = {};
param.gravity_scale = 1;
m_body=px_rigidbody(px, col, mat, param);
};
void CLight::ReadParameter( const char *szName, const char *szValue )
{
CBaseEntity::ReadParameter(szName, szValue);
}
void CLight::Destroy()
{
}
void CLight::Think( float fDelta )
{
px_matrix pos = px_getmatrix(px, m_body);
V_memcpy(m_matrix, pos.m, 64);
V_printf("%p %f %f %f\n",col, pos.m[12], pos.m[13], pos.m[14]);
};
DECLARE_ENTITY(light, CLight)

12
engine/sv_worldspawn.cpp
View File

@@ -6,8 +6,9 @@ class CWorldSpawn: public CBrushEntity
public:
virtual void Precache ( void ) override;
virtual void Spawn( void ) override;
virtual void ReadParameter( const char *szName, const char *szValue ) override;
virtual void Destroy( void ) override;
virtual void Think( float fDelta ) override;
virtual void Think( float fDelta ) override;
};
void CWorldSpawn::Precache()
@@ -17,17 +18,22 @@ void CWorldSpawn::Precache()
void CWorldSpawn::Spawn()
{
V_printf("Cool\n");
CBrushEntity::Spawn();
};
void CWorldSpawn::ReadParameter( const char *szName, const char *szValue )
{
CBrushEntity::ReadParameter(szName, szValue);
}
void CWorldSpawn::Destroy()
{
CBrushEntity::Destroy();
}
void CWorldSpawn::Think( float fDelta )
{
CBrushEntity::Think(fDelta);
};
}
DECLARE_ENTITY(worldspawn, CWorldSpawn)

316
engine/vk_brush.cpp
View File

@@ -1,316 +0,0 @@
#include "filesystem.h"
#include "rendering.h"
#include "tier1/utlvector.h"
#include "vk_helper.h"
#include "vulkan/vulkan_core.h"
vk_tripipeline_t g_brushPipeline = {};
VkDescriptorPool g_brushDescriptorPool;
VkDescriptorSet g_brushDescriptorSet;
VkSampler g_brushSampler;
abstract_class CBrush: public IBrush
{
public:
void SetVertexBuffer( IVertexBuffer *pBuffer ) override;
void SetIndexBuffer( IIndexBuffer *pBuffer ) override;
void Draw() override;
Material_t m_material;
CVertexBuffer *m_pVertexBuffer = NULL;
CIndexBuffer *m_pIndexBuffer = NULL;
};
CUtlVector<CBrush> g_drawnBrushes;
void CBrush::SetVertexBuffer( IVertexBuffer *pBuffer )
{
m_pVertexBuffer = (CVertexBuffer*)pBuffer;
}
void CBrush::SetIndexBuffer( IIndexBuffer *pBuffer )
{
m_pIndexBuffer = (CIndexBuffer*)pBuffer;
}
void CBrush::Draw()
{
if (!g_pCurrentMaterial)
m_material = {};
else
m_material = g_pCurrentMaterial->m;
g_drawnBrushes.AppendTail(*this);
}
void IBrushRenderer::Init()
{
CUtlVector<vk_shader_t> shaders(2);
for (auto &shader: shaders)
{
shader.m_shaderModule = NULL;
}
shaders[0].Create("gfx/brush_vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaders[1].Create("gfx/brush_frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
CUtlVector<VkDescriptorSetLayoutBinding> bindings(2);
bindings[0] = {};
bindings[0].binding = 0;
bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
bindings[0].descriptorCount = 1;
bindings[1] = {};
bindings[1].binding = 1;
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[1].descriptorCount = 1024;
g_brushPipeline.Create(shaders, bindings, 4);
shaders[1].Destroy();
shaders[0].Destroy();
CUtlVector<VkDescriptorPoolSize> pools;
for (auto &binding: bindings)
{
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, &g_brushDescriptorPool);
VkDescriptorSetAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = g_brushDescriptorPool;
allocInfo.descriptorSetCount = 1;
allocInfo.pSetLayouts = &g_brushPipeline.m_descriptorSetLayout;
vkAllocateDescriptorSets(g_vkDevice, &allocInfo, &g_brushDescriptorSet);
VkPhysicalDeviceProperties properties{};
vkGetPhysicalDeviceProperties(g_vkPhysicalDevice, &properties);
VkSamplerCreateInfo samplerInfo{};
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.anisotropyEnable = VK_FALSE;
samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
samplerInfo.unnormalizedCoordinates = VK_FALSE;
samplerInfo.compareEnable = VK_FALSE;
samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
samplerInfo.mipLodBias = 0.0f;
samplerInfo.minLod = 0.0f;
samplerInfo.maxLod = 0.0f;
vkCreateSampler(g_vkDevice, &samplerInfo, nullptr, &g_brushSampler);
}
void IBrushRenderer::Frame( float fDelta )
{
CUtlVector<VkWriteDescriptorSet> writes(2);
for (auto &write: writes)
{
write = {};
write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
write.dstSet = g_brushDescriptorSet;
write.dstArrayElement = 0;
}
VkDescriptorBufferInfo bufferInfo = {};
bufferInfo.buffer = g_cameraProperties.m_buffer;
bufferInfo.offset = 0;
bufferInfo.range = g_cameraProperties.m_nSize;
writes[0].dstBinding = 0;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
writes[0].descriptorCount = 1;
writes[0].pBufferInfo = &bufferInfo;
CUtlVector<VkDescriptorImageInfo> textures;
textures.Reserve(g_textures.GetSize());
for (ITexture *t: g_textures)
{
CTexture *texture = (CTexture*)t;
VkDescriptorImageInfo image = {};
image.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
image.imageView = texture->image.m_imageView;
image.sampler = g_brushSampler;
textures.AppendTail(image);
};
textures[0].sampler = g_invalidTextureSampler;
writes[1].dstBinding = 1;
writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
writes[1].descriptorCount = textures.GetSize();
writes[1].pImageInfo = textures.GetData();
vkUpdateDescriptorSets(g_vkDevice, writes.GetSize(), writes.GetData(), 0, NULL);
VkImageMemoryBarrier barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.image = g_swapchainImage,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
};
vkCmdPipelineBarrier(g_vkCommandBuffer,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
0, 0, NULL, 0, NULL, 1, &barrier);
VkRenderingAttachmentInfo colorAttachment = {
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
.imageView = g_swapchainImageView,
.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.clearValue = {.color = {0.0f, 0.0f, 0.0f, 1.0f}}
};
VkRenderingAttachmentInfo depthAttachment = {
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
.imageView = g_meshdepth.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.clearValue = {.depthStencil = {.depth = 1}},
};
VkRenderingInfo renderInfo = {
.sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
.renderArea = {{0, 0}, {g_nWindowWidth, g_nWindowHeight}},
.layerCount = 1,
.colorAttachmentCount = 1,
.pColorAttachments = &colorAttachment,
.pDepthAttachment = &depthAttachment,
};
vkCmdBeginRendering(g_vkCommandBuffer, &renderInfo);
vkCmdSetRasterizerDiscardEnable(g_vkCommandBuffer, VK_FALSE);
vkCmdSetDepthBiasEnable(g_vkCommandBuffer, VK_FALSE);
_vkCmdSetPolygonModeEXT(g_vkCommandBuffer, VK_POLYGON_MODE_FILL);
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);
_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);
VkVertexInputBindingDescription2EXT binding = {
.sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT,
.binding = 0,
.stride = 20,
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
.divisor = 1,
};
VkVertexInputAttributeDescription2EXT attributes[2] = {
{
VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
NULL,
0, 0,
VK_FORMAT_R32G32B32_SFLOAT,
0
},
{
VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
NULL,
1, 0,
VK_FORMAT_R32G32_SFLOAT,
12
}
};
_vkCmdSetVertexInputEXT(g_vkCommandBuffer, 1, &binding, 2, attributes);
VkBool32 blendEnable = VK_FALSE;
VkColorBlendEquationEXT blendEquation = {
VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_OP_ADD,
VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD
};
VkColorComponentFlags writeMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
_vkCmdSetColorBlendEnableEXT(g_vkCommandBuffer, 0, 1, &blendEnable);
_vkCmdSetColorBlendEquationEXT(g_vkCommandBuffer, 0, 1, &blendEquation);
_vkCmdSetColorWriteMaskEXT(g_vkCommandBuffer, 0, 1, &writeMask);
vkCmdBindPipeline(g_vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, g_brushPipeline.m_pipeline);
vkCmdBindDescriptorSets(g_vkCommandBuffer,VK_PIPELINE_BIND_POINT_GRAPHICS, g_brushPipeline.m_layout, 0, 1, &g_brushDescriptorSet, 0, NULL);
for (auto &mesh: g_drawnBrushes)
{
VkDeviceSize offset = 0;
uint32_t textureID = mesh.m_material.albedo;
vkCmdPushConstants(g_vkCommandBuffer, g_brushPipeline.m_layout, VK_SHADER_STAGE_ALL, 0, 4, &textureID);
vkCmdBindVertexBuffers(g_vkCommandBuffer, 0, 1, &mesh.m_pVertexBuffer->m_buffer.m_buffer, &offset);
if (mesh.m_pIndexBuffer)
{
vkCmdBindIndexBuffer(
g_vkCommandBuffer,
mesh.m_pIndexBuffer->m_buffer.m_buffer,
0,
VK_INDEX_TYPE_UINT32
);
vkCmdDrawIndexed(g_vkCommandBuffer, mesh.m_pIndexBuffer->m_buffer.m_nSize/4, 1, 0, 0, 0);
}
else
{
vkCmdDraw(g_vkCommandBuffer, mesh.m_pVertexBuffer->m_buffer.m_nSize/12,1,0,0);
}
}
vkCmdEndRendering(g_vkCommandBuffer);
barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.dstAccessMask = 0,
.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.image = g_swapchainImage,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
};
vkCmdPipelineBarrier(g_vkCommandBuffer,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, 0, NULL, 0, NULL, 1, &barrier);
g_drawnBrushes = CUtlVector<CBrush>();
}
IBrush *IBrushRenderer::CreateMesh()
{
CBrush *mesh = new CBrush;
return mesh;
}
void IBrushRenderer::Destroy( IBrush *pModel )
{
}

1
engine/vk_external_functions.cpp
View File

@@ -7,3 +7,4 @@ VK_DEVICE_FUNCTION(vkCmdSetViewportWithCount);
VK_DEVICE_FUNCTION(vkCmdSetColorBlendEnableEXT);
VK_DEVICE_FUNCTION(vkCmdSetColorBlendEquationEXT);
VK_DEVICE_FUNCTION(vkCmdSetColorWriteMaskEXT);
VK_DEVICE_FUNCTION(vkCmdSetLogicOpEXT);

7
engine/vk_helper.h
View File

@@ -60,6 +60,7 @@ extern VkCommandPool g_vkCommandPool;
extern VkCommandBuffer g_vkCommandBuffer;
extern VkImageView g_swapchainImageView;
extern VkImage g_swapchainImage;
extern VkFormat g_swapchainFormat;
extern bool g_bConfigNotify;
extern uint32_t g_nWindowWidth;
@@ -78,5 +79,7 @@ struct CameraProjection {
extern vk_buffer_t g_cameraProperties;
extern CameraProjection *g_cameraDataMap;
extern vk_image2d_t g_meshdepth;
extern vk_image2d_t g_meshcolor;
extern vk_image2d_t g_meshDepth;
extern vk_image2d_t g_meshDepthMSAA;
extern vk_image2d_t g_meshColor;
extern vk_image2d_t g_meshColorMSAA;

117
engine/vk_mesh.cpp
View File

@@ -107,7 +107,9 @@ void IMeshRenderer::Init()
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[1].descriptorCount = 1024;
g_meshPipeline.Create(shaders, bindings, 76);
CUtlVector<VkFormat> formats(1);
formats[0] = g_meshColor.m_format;
g_meshPipeline.Create(shaders, bindings, 76, formats);
shaders[1].Destroy();
shaders[0].Destroy();
@@ -157,6 +159,31 @@ void IMeshRenderer::Init()
vkCreateSampler(g_vkDevice, &samplerInfo, nullptr, &g_meshSampler);
}
void IMeshRenderer_PrepassNoMSAA()
{
};
void IMeshRenderer_Prepass()
{
};
void IMeshRenderer_EdgeDetection()
{
};
void IMeshRenderer_Light()
{
};
void IMeshRenderer_Combine()
{
};
void IMeshRenderer::Frame( float fDelta )
{
CUtlVector<VkWriteDescriptorSet> writes(2);
@@ -183,7 +210,7 @@ void IMeshRenderer::Frame( float fDelta )
{
CTexture *texture = (CTexture*)t;
VkDescriptorImageInfo image = {};
image.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
image.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
image.imageView = texture->image.m_imageView;
image.sampler = g_meshSampler;
textures.AppendTail(image);
@@ -196,33 +223,70 @@ void IMeshRenderer::Frame( float fDelta )
vkUpdateDescriptorSets(g_vkDevice, writes.GetSize(), writes.GetData(), 0, NULL);
VkImageMemoryBarrier barrier = {
VkImageMemoryBarrier barriers[4] = {
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_GENERAL,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.image = g_swapchainImage,
.image = g_meshColor.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.image = g_meshColorMSAA.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.image = g_meshDepth.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1}
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.image = g_meshDepthMSAA.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1}
},
};
vkCmdPipelineBarrier(g_vkCommandBuffer,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
0, 0, NULL, 0, NULL, 1, &barrier);
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
0, 0, NULL, 0, NULL, 4, barriers);
VkRenderingAttachmentInfo colorAttachment = {
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
.imageView = g_swapchainImageView,
.imageView = g_meshColorMSAA.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
.resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT,
.resolveImageView = g_meshColor.m_imageView,
.resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.clearValue = {.color = {0.0f, 0.0f, 0.0f, 1.0f}},
};
VkRenderingAttachmentInfo depthAttachment = {
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
.imageView = g_meshdepth.m_imageView,
.imageView = g_meshDepthMSAA.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
.resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT,
.resolveImageView = g_meshDepth.m_imageView,
.resolveImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.clearValue = {.depthStencil = {.depth = 1}},
};
VkRenderingInfo renderInfo = {
@@ -246,9 +310,9 @@ void IMeshRenderer::Frame( float fDelta )
vkCmdSetDepthCompareOp(g_vkCommandBuffer, VK_COMPARE_OP_LESS);
vkCmdSetStencilTestEnable(g_vkCommandBuffer, VK_FALSE);
_vkCmdSetRasterizationSamplesEXT(g_vkCommandBuffer, VK_SAMPLE_COUNT_1_BIT);
_vkCmdSetRasterizationSamplesEXT(g_vkCommandBuffer, VK_SAMPLE_COUNT_4_BIT);
VkSampleMask sampleMask = 0xFFFFFFFF;
_vkCmdSetSampleMaskEXT(g_vkCommandBuffer, VK_SAMPLE_COUNT_1_BIT, &sampleMask);
_vkCmdSetSampleMaskEXT(g_vkCommandBuffer, VK_SAMPLE_COUNT_4_BIT, &sampleMask);
_vkCmdSetAlphaToCoverageEnableEXT(g_vkCommandBuffer, VK_FALSE);
VkViewport viewport = {0, 0, (float)g_nWindowWidth, (float)g_nWindowHeight, 0.0f, 1.0f};
@@ -301,8 +365,8 @@ void IMeshRenderer::Frame( float fDelta )
for (auto &mesh: g_drawnMeshes)
{
VkDeviceSize offset = 0;
uint32_t textureID = mesh.m_material.albedo;
vkCmdPushConstants(g_vkCommandBuffer, g_meshPipeline.m_layout, VK_SHADER_STAGE_ALL, 0, 64, mesh.m_matrix);
uint32_t textureID = 0;
vkCmdPushConstants(g_vkCommandBuffer, g_meshPipeline.m_layout, VK_SHADER_STAGE_ALL, 0, 64, &mesh.m_matrix);
vkCmdPushConstants(g_vkCommandBuffer, g_meshPipeline.m_layout, VK_SHADER_STAGE_ALL, 64, 4, &textureID);
vkCmdBindVertexBuffers(g_vkCommandBuffer, 0, 1, &mesh.m_pVertexBuffer->m_buffer.m_buffer, &offset);
if (mesh.m_pIndexBuffer)
@@ -322,13 +386,13 @@ void IMeshRenderer::Frame( float fDelta )
}
vkCmdEndRendering(g_vkCommandBuffer);
barrier = {
VkImageMemoryBarrier barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.dstAccessMask = 0,
.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.image = g_swapchainImage,
.image = g_meshColor.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
};
@@ -336,6 +400,23 @@ void IMeshRenderer::Frame( float fDelta )
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, 0, NULL, 0, NULL, 1, &barrier);
barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.dstAccessMask = 0,
.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.image = g_meshColor.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
};
vkCmdPipelineBarrier(g_vkCommandBuffer,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, 0, NULL, 0, NULL, 1, &barrier);
g_drawnMeshes = CUtlVector<CMesh>();
}
@@ -347,7 +428,7 @@ IMesh *IMeshRenderer::CreateMesh()
return mesh;
}
void IMeshRenderer::Destroy( IBrush *pModel )
void IMeshRenderer::Destroy( IMesh *pModel )
{
}

36
engine/vk_video.cpp
View File

@@ -17,8 +17,10 @@ CameraProjection *g_cameraDataMap;
IMaterial *g_pDefaultMaterial;
IMaterial *g_pCurrentMaterial;
vk_image2d_t g_meshdepth;
vk_image2d_t g_meshcolor;
vk_image2d_t g_meshDepth;
vk_image2d_t g_meshDepthMSAA;
vk_image2d_t g_meshColor;
vk_image2d_t g_meshColorMSAA;
void IVulkan::Init()
{
@@ -56,10 +58,11 @@ void IVulkan::Init()
g_cameraProperties.Create(sizeof(CameraProjection), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
g_cameraDataMap = (CameraProjection*)g_cameraProperties.Map(0, 64);
g_meshdepth.Create(1280, 720, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
g_meshcolor.Create(1280, 720, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
g_meshDepth.Create(1280, 720, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_SAMPLE_COUNT_1_BIT);
g_meshDepthMSAA.Create(1280, 720, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, VK_SAMPLE_COUNT_4_BIT);
g_meshColor.Create(1280, 720, VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SAMPLE_COUNT_1_BIT);
g_meshColorMSAA.Create(1280, 720, VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, VK_SAMPLE_COUNT_4_BIT);
IBrushRenderer::Init();
IMeshRenderer::Init();
};
@@ -73,11 +76,17 @@ void IVulkan::Frame()
if (g_bConfigNotify)
{
g_meshdepth.Destroy();
g_meshdepth.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
g_meshDepth.Destroy();
g_meshDepthMSAA.Destroy();
g_meshColor.Destroy();
g_meshColorMSAA.Destroy();
g_meshDepth.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_SAMPLE_COUNT_1_BIT);
g_meshDepthMSAA.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, VK_SAMPLE_COUNT_1_BIT);
g_meshColor.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SAMPLE_COUNT_1_BIT);
g_meshColorMSAA.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, VK_SAMPLE_COUNT_4_BIT);
}
IBrushRenderer::Frame(0);
IMeshRenderer::Frame(0);
};
@@ -119,7 +128,8 @@ void vk_shader_t::Destroy( void )
void vk_tripipeline_t::Create(
CUtlVector<vk_shader_t> &shaders,
CUtlVector<VkDescriptorSetLayoutBinding> &bindings,
uint32_t pushConstantSize
uint32_t pushConstantSize,
CUtlVector<VkFormat> formats
)
{
VkPushConstantRange pushConstantRange = {};
@@ -202,8 +212,8 @@ void vk_tripipeline_t::Create(
VkPipelineRenderingCreateInfo prci = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
.pNext = NULL,
.colorAttachmentCount = 1,
.pColorAttachmentFormats = (VkFormat[]){ VK_FORMAT_B8G8R8A8_UNORM }, // <-- replace with your actual format
.colorAttachmentCount = (uint32_t)formats.GetSize(),
.pColorAttachmentFormats = formats.GetData(),
.depthAttachmentFormat = VK_FORMAT_D32_SFLOAT,
};
@@ -272,7 +282,7 @@ void vk_buffer_t::CopyTo(struct vk_buffer_t *buffer)
{
}
void vk_image2d_t::Create(size_t x, size_t y, VkFormat format, VkImageUsageFlags usage)
void vk_image2d_t::Create(size_t x, size_t y, VkFormat format, VkImageUsageFlags usage, VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT)
{
VkImageCreateInfo imageInfo={};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
@@ -286,7 +296,7 @@ void vk_image2d_t::Create(size_t x, size_t y, VkFormat format, VkImageUsageFlags
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.format=format;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.samples = samples;
VmaAllocationCreateInfo alloc = {};
alloc.usage=VMA_MEMORY_USAGE_AUTO;

11
engine/vk_videosdl.cpp
View File

@@ -6,6 +6,7 @@
#include "vulkan/vulkan.h"
#include "SDL3/SDL.h"
#include "vulkan/vulkan_core.h"
#define SDL_MAIN_HANDLED
#include "SDL3/SDL_main.h"
#include "SDL3/SDL_vulkan.h"
@@ -45,17 +46,18 @@ CUtlVector<VkImage> g_swapchainImages;
CUtlVector<VkImageView> g_swapchainImageViews;
VkImageView g_swapchainImageView;
VkImage g_swapchainImage;
VkFormat g_swapchainFormat;
uint32_t g_nNumSwapchainImages = 0;
#define VK_DEVICE_FUNCTION(name) PFN_##name _##name
#include "vk_external_functions.cpp"
#undef VK_DEVICE_FUNCTION
char g_bConfigNotify = 0;
uint32_t g_nWindowWidth = 1280;
uint32_t g_nWindowHeight = 720;
#define VK_DEVICE_FUNCTION(name) PFN_##name _##name
#include "vk_external_functions.cpp"
#undef VK_DEVICE_FUNCTION
void IVideo_SwapchainInit()
{
@@ -131,6 +133,7 @@ void IVideo_SwapchainInit()
vkCreateImageView(g_vkDevice, &createInfo, NULL, &g_swapchainImageViews[i]);
}
g_swapchainFormat = selectedFormat.format;
/* command buffers */
@@ -283,6 +286,7 @@ void IVideo::Init()
VkPhysicalDeviceVulkan13Features pdv13f = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
.pNext = &pdeds2fe,
.synchronization2 = VK_TRUE,
.dynamicRendering = VK_TRUE,
};
VkPhysicalDeviceVulkan12Features pdv12f = {
@@ -421,4 +425,5 @@ void IVideo::Frame( float fDelta )
g_bConfigNotify = 0;
s_frameID=(s_frameID+1)%g_nNumSwapchainImages;
};