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

introduces ios support? still needs metal

Browse Source
This commit is contained in:
kotofyt
2025-06-29 01:21:55 +03:00
parent af4f0c3cad
commit cdeaac7c0c
79 changed files with 2176 additions and 1349 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
engine/__build.c
View File

@@ -1,75 +0,0 @@
#include "god/build.h"
#include "god/c.h"
#include "god/ld.h"
#include "god/utils.h"
char *engine_lib;
char *engine_implib;
void engine_build(struct build_data b)
{
char *szVideoFile = "engine/vk_videosdl.cpp";
char* files[] = {
"engine/console.cpp",
"engine/filesystem.cpp",
"engine/server.cpp",
"engine/engine.cpp",
/* rendering */
"engine/vk_video.cpp",
"engine/vk_mesh.cpp",
szVideoFile,
/* entities */
"engine/baseentity.cpp",
"engine/level.cpp",
"engine/brush.cpp",
/* server */
"engine/sv_worldspawn.cpp",
"engine/sv_light.cpp",
/* client */
"engine/cl_worldspawn.cpp",
"engine/cl_light.cpp",
NULL,
};
struct project p = {
.b = &b,
.files = files,
.name = "engine",
};
struct project o = C_compile(p, (struct C_settings){
.generation_flags = C_GENERATION_FLAGS_PIC,
.compile_flags = C_COMPILE_FLAGS_WALL,
.include_dirs = include_dirs,
});
add_item(&o.files, tier1_lib);
add_item(&o.files, rapierLib);
char *szVulkan = (char*)1;
char *szws2 = (char*)1;
if (b.kernel==BUILD_KERNEL_WINDOWS)
{
szVulkan="vulkan-1";
szws2="ws2_32";
}
if (b.kernel==BUILD_KERNEL_LINUX)
{
szVulkan="vulkan";
}
char* libs[] = {
"c",
"SDL3",
szVulkan,
NULL,
};
engine_lib = ld_link_project(o, (struct link_settings){
.type = LINK_TYPE_DYNAMIC,
.libs = libs,
});
mv("build/"GAME_NAME"/game/bin",engine_lib);
}

31
engine/__build.cpp
View File

@@ -29,8 +29,6 @@ CUtlVector<CUtlString> engine_CompiledFiles = {
/* rendering */
"engine/vk_videosdl.cpp",
"engine/vk_video.cpp",
"engine/vk_mesh.cpp",
"engine/vk_postprocessing.cpp",
/* io */
"engine/input.cpp",
@@ -40,11 +38,14 @@ CUtlVector<CUtlString> engine_CompiledFiles = {
CUtlVector<CUtlString> engine_Libraries = {
"c",
"SDL3",
"vulkan",
};
int engine_build()
{
if (Target_t::DefaultTarget().kernel == TARGET_KERNEL_DARWIN)
engine_Libraries.AppendTail("MoltenVK");
if (Target_t::DefaultTarget().kernel == TARGET_KERNEL_LINUX)
engine_Libraries.AppendTail("vulkan");
CCProject compileProject = {};
CLDProject ldProject = {};
@@ -53,19 +54,27 @@ int engine_build()
compileProject.includeDirectories = all_IncludeDirectories;
compileProject.bFPIC = true;
ldProject = compileProject.Compile();
ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
ldProject.libraries = engine_Libraries;
ldProject.objects.AppendTail((CObject){tier1_lib});
ldProject.objects.AppendTail((CObject){rapier_lib});
if (bStaticBuild)
ldProject.linkType = ELINK_STATIC_LIBRARY;
else
{
ldProject.objects.AppendTail((CObject){tier1_lib});
ldProject.objects.AppendTail((CObject){rapier_lib});
ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
}
CUtlString outputProject = ldProject.Link();
if (!bStaticBuild)
{
IFileSystem2::MakeDirectory(CUtlString("%s/bin",szOutputDir.GetString()));
IFileSystem2::CopyFile(CUtlString("%s/bin", szOutputDir.GetString()), outputProject);
} else {
engine_lib = outputProject;
}
const char *szGameName = ICommandLine::ParamValue("-game");
if (szGameName == NULL)
szGameName = "funnygame";
IFileSystem2::MakeDirectory(CUtlString("build/%s/game/bin",szGameName));
IFileSystem2::CopyFile(CUtlString("build/%s/game/bin",szGameName), outputProject);
return 0;

56
engine/brush.cpp
View File

@@ -30,7 +30,7 @@ void CBrushEntity::Spawn()
}
/* use them */
px_collider_params params = {};
params.friction = 0.6;
params.friction = 0.0;
m_collider = px_trimesh((Point<float>*)triangles.GetMemory(), triangles.GetSize(), (uint32_t(*)[3])indicies.GetMemory(), indicies.GetSize()/3 ,params);
px_fixedbody(px, m_collider);
};
@@ -65,10 +65,11 @@ void C_BrushEntity::Spawn()
float uv[2];
};
pAlbedo = ITextureManager::LoadTexture("textures/bricks.png");
CBrushEntity* pBrushEntity = (CBrushEntity*)pEntity;
uint32_t numVertices = 15*pBrushEntity->m_mesh.GetSize();
vertexBuffer = IRenderer::CreateVertexBuffer(numVertices*4);
Vertex_t *pTriangles = (Vertex_t*)vertexBuffer->Map();
uint32_t i = 0;
for (auto &triangle: pBrushEntity->m_mesh)
@@ -91,10 +92,6 @@ void C_BrushEntity::Spawn()
i+=3;
}
vertexBuffer->Unmap();
mesh = IMeshRenderer::CreateMesh();
mesh->SetVertexBuffer(vertexBuffer);
};
void C_BrushEntity::Destroy()
@@ -103,7 +100,6 @@ void C_BrushEntity::Destroy()
}
void C_BrushEntity::Think( float fDelta )
{
material.m.albedo = ITextureManager::GetTexture(pAlbedo);
mat4 matrix;
glm_mat4_zero(matrix);
for (int i = 0; i < 9; i++) {
@@ -113,8 +109,48 @@ void C_BrushEntity::Think( float fDelta )
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->SetMaterial(&material);
mesh->Draw();
};
IGraphicsPipeline *g_BrushPipeline;
class CBrushRendering: public IRenderingPipelineStep
{
public:
virtual void Init() override;
virtual void Frame( float fDelta ) override;
virtual void Deinit() override;
private:
};
DECLARE_MESH_RENDERING_STAGE(CBrushRendering, brush_rasterizer);
CUtlVector<IVertexBuffer*> g_BrushVertices;
void CBrushRendering::Init()
{
V_printf("cool\n");
IRenderer::CreateGraphicsPipeline(
{
{"shaders/brush_vert.spv", SHADER_TYPE_VERTEX},
{"shaders/brush_frag.spv", SHADER_TYPE_FRAGMENT},
},
{}, 64,
{EImageFormat::IMAGE_FORMAT_R8G8B8A8}
);
};
void CBrushRendering::Frame( float fDelta )
{
V_printf("cooll\n");
IRenderer::ResetState();
IRenderer::SetDepthMode(DEPTH_MODE_LESS_EQUAL);
IRenderer::BindPipeline(g_BrushPipeline);
for (auto &vertices: g_BrushVertices)
{
IRenderer::Draw(vertices, 0);
}
};
void CBrushRendering::Deinit()
{
};

53
engine/console.cpp
View File

@@ -1,4 +1,5 @@
#include "console.h"
#include "filesystem.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
@@ -64,33 +65,43 @@ void IConsole::Execute2( CUtlVector<CUtlString> &args )
(cmd->GetCallback())(args.GetSize(), strbuffer);
}
void IConsole::Execute( void )
{
CUtlVector<CUtlVector<CUtlString>> commands = ParseCommandLine(g_commandBuffer);
g_commandBuffer = 0;
for (auto &command: commands)
{
IConsole::Execute2(command);
}
}
//-----------------------------------------------------------------------------
// Parses command buffer.
//-----------------------------------------------------------------------------
void IConsole::Execute( void )
{
CUtlVector<CUtlVector<CUtlString>> IConsole::ParseCommandLine( CUtlString psz )
{
CUtlVector<CUtlString> arguments;
CUtlVector<CUtlVector<CUtlString>> commands;
CUtlString szArgument;
bool bIsQuote = false;
for (auto &c: (CUtlVector<char>&)g_commandBuffer)
for ( auto &c: (CUtlVector<char>&)psz )
{
if (c == '\"')
if ( c == '\"' )
{
bIsQuote = !bIsQuote;
continue;
}
if (c == ';' || c == '\n' || c == '\0')
if ( c == ';' || c == '\n' )
{
if (bIsQuote)
{
if (c != '\0')
szArgument.AppendTail(c);
continue;
}
if (szArgument != 0)
arguments.AppendTail(szArgument);
IConsole::Execute2(arguments);
if ( arguments.GetSize() > 0 )
commands.AppendTail(arguments);
szArgument = 0;
arguments = {};
continue;
@@ -110,7 +121,11 @@ void IConsole::Execute( void )
}
szArgument.AppendTail(c);
};
g_commandBuffer = 0;
if (szArgument != 0)
arguments.AppendTail(szArgument);
if ( arguments.GetSize() > 0 )
commands.AppendTail(arguments);
return commands;
}
void IConsole::AddCommand( const char *psz )
@@ -232,3 +247,23 @@ ConCommandFn ConCommand::GetCallback( void )
{
return m_callback;
}
void IConsole_Exec( int argc, char **argv)
{
if (argc != 2)
return;
FileHandle_t f = IFileSystem::Open(argv[1], IFILE_READ);
if (!f)
return;
CUtlBuffer<char> b(IFileSystem::Size(f)+1);
IFileSystem::Read(f, b, b.GetSize());
b[IFileSystem::Size(f)] = 0;
IConsole::AddCommand(b);
IConsole::AddCommand(";");
IConsole::Execute();
}
ConCommand IConsole_ExecCmd("exec", IConsole_Exec);

8
engine/engine.cpp
View File

@@ -54,7 +54,7 @@ void IEngine_Signal(int sig)
break;
};
IEngine::Shutdown();
_exit(0);
Plat_Exit(0);
};
//-----------------------------------------------------------------------------
@@ -88,8 +88,14 @@ void IEngine::Init()
IVideo::Init();
IInput::Init();
IInput::SetMouseMode(MOUSE_MODE_GAME);
}
IServer::LoadGame("funnygame");
IConsole::AddCommand("exec default.cfg;");
IConsole::Execute();
};
//-----------------------------------------------------------------------------

47
engine/filesystem.cpp
View File

@@ -44,6 +44,10 @@ public:
static void AddFile( const char *psz );
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IFileSystem::InitFilesystem()
{
fs_basedir = ICommandLine::ParamValue("-basedir");
@@ -59,6 +63,10 @@ void IFileSystem::InitFilesystem()
AddGameDirectory(fs_gamedir);
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CFileSystem::AddFile( const char *psz )
{
CUtlString extension = Plat_GetExtension(psz);
@@ -68,6 +76,9 @@ void CFileSystem::AddFile( const char *psz )
};
}
//-----------------------------------------------------------------------------
// Adds directory which can contain pack files
//-----------------------------------------------------------------------------
void IFileSystem::AddGameDirectory( const char *psz )
{
FileDirectory_t dir = {};
@@ -81,6 +92,10 @@ void IFileSystem::AddGameDirectory( const char *psz )
};
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool IFileSystem::LoadPackFile( const char *szFilename )
{
Pack_t pack = {};
@@ -109,10 +124,6 @@ bool IFileSystem::LoadPackFile( const char *szFilename )
pack.handle = f;
pack.files = CUtlVector<PackDirectory_t>(nNumFiles);
V_memcpy(pack.files.GetData(),pDirs, header.size);
for (auto &i: pack.files)
{
V_printf(" LOADED %s\n",i.name);
}
V_free(pDirs);
nNumFiles = header.size/sizeof(PackDirectory_t);
@@ -124,10 +135,19 @@ bool IFileSystem::LoadPackFile( const char *szFilename )
return true;
}
//-----------------------------------------------------------------------------
// Creates path
//-----------------------------------------------------------------------------
void IFileSystem::CreatePath( const char *szPath )
{
}
//-----------------------------------------------------------------------------
// Opens file
// If it is located in a pack then it can only be read
//-----------------------------------------------------------------------------
FileHandle_t IFileSystem::Open( const char *szFilename, EFileOptions options )
{
if (options == IFILE_READ)
@@ -172,6 +192,9 @@ FileHandle_t IFileSystem::Open( const char *szFilename, EFileOptions options )
return 0;
}
//-----------------------------------------------------------------------------
// Closes file
//-----------------------------------------------------------------------------
void IFileSystem::Close( FileHandle_t file )
{
/* close only fs files */
@@ -182,10 +205,18 @@ void IFileSystem::Close( FileHandle_t file )
delete file;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
size_t IFileSystem::Size( FileHandle_t file )
{
return file->nSize;
}
//-----------------------------------------------------------------------------
// Reads nSize bytes of file
//-----------------------------------------------------------------------------
size_t IFileSystem::Read( FileHandle_t file, void *pOutput, size_t nSize)
{
if (file->file)
@@ -200,10 +231,18 @@ size_t IFileSystem::Read( FileHandle_t file, void *pOutput, size_t nSize)
return readsize;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
size_t IFileSystem::ReadLine( FileHandle_t file, void *pOutput, size_t nSize)
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
size_t IFileSystem::Write( FileHandle_t file, void *pInput, size_t nSize)
{

22
engine/gamemode.cpp
View File

@@ -4,6 +4,9 @@
CGameMode *pCurrentMode = NULL;
//-----------------------------------------------------------------------------
// Round begin handler
//-----------------------------------------------------------------------------
void CGameMode::RoundBegin( void )
{
size_t i = 0;
@@ -24,22 +27,33 @@ void CGameMode::RoundBegin( void )
}
}
//-----------------------------------------------------------------------------
// Round end handler
//-----------------------------------------------------------------------------
void CGameMode::RoundEnd( void )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IGameModeManager::Init( void )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IGameModeManager::Frame( void )
{
}
//-----------------------------------------------------------------------------
// Sets gamemode
//-----------------------------------------------------------------------------
void IGameModeManager::StartGameMode(CGameMode *pGameMode)
{
if (pCurrentMode)
@@ -49,11 +63,17 @@ void IGameModeManager::StartGameMode(CGameMode *pGameMode)
pCurrentMode->RoundBegin();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CGameMode *IGameModeManager::GetCurrentMode( void )
{
return pCurrentMode;
}
//-----------------------------------------------------------------------------
// Restarts the gamemode
//-----------------------------------------------------------------------------
void IGameModeManager::RestartCurrentMode( void )
{
if (!pCurrentMode)

130
engine/input.cpp
View File

@@ -1,52 +1,166 @@
#include "input.h"
#include "console.h"
#include "tier0/lib.h"
#include "tier1/commandline.h"
#include "math3d.h"
char g_PressedKeys[256];
float g_fXAxisEvent[256];
float g_fYAxisEvent[256];
char g_PressedKeys[KEY_NUM_KEYS];
float g_fAxisValues[AXIS_NUM_AXIS];
CUtlString g_bindings[256];
struct KeyName_t {
const char *szName;
EInputKey key;
};
KeyName_t keys[] = {
{"TAB",KEY_TAB},
{"ENTER",KEY_ENTER},
{"ESCAPE",KEY_ESCAPE},
{"SPACE",KEY_SPACE},
{"A",KEY_A},
{"B",KEY_B},
{"C",KEY_C},
{"D",KEY_D},
{"E",KEY_E},
{"F",KEY_F},
{"G",KEY_G},
{"H",KEY_H},
{"I",KEY_I},
{"J",KEY_J},
{"K",KEY_K},
{"L",KEY_L},
{"M",KEY_M},
{"N",KEY_N},
{"O",KEY_O},
{"P",KEY_P},
{"Q",KEY_Q},
{"R",KEY_R},
{"S",KEY_S},
{"T",KEY_T},
{"U",KEY_U},
{"V",KEY_V},
{"W",KEY_W},
{"X",KEY_X},
{"Y",KEY_Y},
{"Z",KEY_Z},
};
//-----------------------------------------------------------------------------
// Converts string (eg. tab, mouse0, w, 0) to keycode
//-----------------------------------------------------------------------------
EInputKey IInput_StringToKey( char *psz )
{
for (uint32_t i = 0; i<sizeof(keys)/sizeof(KeyName_t); i++)
{
if (!V_stricmp(keys[i].szName, psz))
return keys[i].key;
};
return KEY_NONE;
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput::Init( void )
{
}
//-----------------------------------------------------------------------------
// Generates command call when pressed the key. eg +forward; -left;
// Just to be sure we put ; in the end of the command.
// When user releases the key command event is not generated. But if the first
// command contains + as first character ( in case of example +forward ), then
// it fires -forward
//-----------------------------------------------------------------------------
void IInput::KeyEvent( EInputKey key, EKeyEventType event )
{
V_printf("key\n");
if (event == KEY_EVENT_TYPE_DOWN) {
IConsole::AddCommand(g_bindings[key]);
IConsole::AddCommand(";");
}
if (event == KEY_EVENT_TYPE_UP)
{
auto binding = IConsole::ParseCommandLine(g_bindings[key]);
if (binding.GetSize()==0)
return;
if (binding[0].GetSize() == 0)
return;
if (binding[0][0].GetString()[0] == '+')
{
CUtlString command = binding[0][0];
command.GetString()[0] = '-';
IConsole::AddCommand(command);
IConsole::AddCommand(";");
}
}
}
void IInput::AxisEvent( unsigned char cAxis, float fX, float fY )
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput::AxisEvent( EInputAxis axis, float fValue )
{
if (axis == AXIS_MOUSE_X || axis == AXIS_MOUSE_Y)
{
g_fAxisValues[axis] += fValue*3.09;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput::Frame( void )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput::Deinit( void )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput_Bind( int argc, char **argv )
{
if (argc == 1)
return;
if (argc == 2)
return;
EInputKey key = IInput_StringToKey(argv[1]);
if (key == KEY_NONE)
return;
for ( int i = 2; i<argc; i++ )
{
g_bindings[key] = 0;
g_bindings[key].AppendTail(argv[i]);
}
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput_Unbind( int argc, char **argv )
{
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void IInput_UnbindAll( int argc, char **argv )
{
};
ConCommand BindCmd("bind", IInput_Bind, 0);
ConCommand UnbindCmd("unbind", IInput_Bind, 0);
ConCommand unbindAllcmd("unbindall", IInput_Bind, 0);
ConCommand UnbindCmd("unbind", IInput_Unbind, 0);
ConCommand UnbindAllcmd("unbindall", IInput_UnbindAll, 0);

3
engine/level.cpp
View File

@@ -18,6 +18,9 @@ struct EntityHeader_t
uint32_t nProperties;
};
//-----------------------------------------------------------------------------
// Loads level from file, deserializes it and creates entities.
//-----------------------------------------------------------------------------
void ILevel::LoadLevel( const char *szLevelName )
{
FileHandle_t handle = IFileSystem::Open(CUtlString("%s.fmap",szLevelName), IFILE_READ);

0
engine/mesh.cpp Normal file
View File

32
engine/physics.cpp
View File

@@ -1,5 +1,30 @@
#include "physics.h"
#include "physics_gen.h"
#include "math3d.h"
PxCastResult_t IPxWorld::BoxCast( vec3 size, vec3 origin, vec3 destination, vec3 rotation )
{
vec3 velocity;
PxCastResult_t result = {};
px_cast_result r = {};
for ( int i = 0; i < 3; i++ )
velocity[i] = destination[i] - origin[i];
r = px_box_cast(px, size[0], size[1], size[2], PX_GLM_VEC3(origin), PX_GLM_VEC3(rotation), PX_GLM_VEC3(velocity), 1);
result.bHit = r.hit;
result.fTime = r.time;
for ( int i = 0; i < 3; i++ )
{
result.position[i] = origin[i] + velocity[i] * result.fTime;
result.normal[i] = r.normal1.m[i];
result.normal2[i] = r.normal2.m[i];
}
return result;
}
void CPxCollider::Spawn( float fFriction )
{
@@ -44,6 +69,11 @@ void CPxRigidKinematicPosition::Spawn( CPxCollider *pCollider, px_matrix matrix,
{
m_pRigidBody = px_kinematic_position_body(px, pCollider->m_pCollider, matrix, params);
};
void CPxRigidKinematicPosition::SetPosition( px_vec3 position )
{
px_setposition(px, m_pRigidBody, position);
};
px_vec3 CPxRigidKinematicPosition::GetPosition( void )
{
return px_getposition(px, m_pRigidBody);

18
engine/server.cpp
View File

@@ -12,6 +12,10 @@ void *g_serverdll;
ConVar g_tickrate("tickrate","64",FCVAR_PROTECTED);
float g_fAccumulator = 0;
//-----------------------------------------------------------------------------
// Loads game and client libraries if linking dynamically, otherwise it runs
// IGame_Load compiled statically.
//-----------------------------------------------------------------------------
void IServer::LoadGame( const char *psz )
{
#ifdef __WIN32__
@@ -21,6 +25,10 @@ void IServer::LoadGame( const char *psz )
g_serverdll = Plat_LoadLibrary(CUtlString("%s/bin/libserver.so", psz));
Plat_LoadLibrary(CUtlString("%s/bin/libclient.so", psz));
#endif
#ifdef __APPLE__
g_serverdll = Plat_LoadLibrary(CUtlString("%s/bin/libserver.dysim", psz));
Plat_LoadLibrary(CUtlString("%s/bin/libclient.dysim", psz));
#endif
void (*GameLoadfn)() = (void(*)())Plat_GetProc(g_serverdll, "IGame_Load");
if (!GameLoadfn)
@@ -28,6 +36,9 @@ void IServer::LoadGame( const char *psz )
GameLoadfn();
};
//-----------------------------------------------------------------------------
// Updates server and client state.
//-----------------------------------------------------------------------------
void IServer::Think( float fDelta )
{
g_fAccumulator += fDelta;
@@ -37,8 +48,8 @@ void IServer::Think( float fDelta )
while(g_fAccumulator>=fTickrate)
{
IInput::Frame();
IConsole::AddCommand("+forward;");
IConsole::Execute();
g_fAccumulator-=fTickrate;
for (auto &entity: g_entities)
{
@@ -52,3 +63,8 @@ void IServer::Think( float fDelta )
entity->pClientEntity->Think(fDelta);
}
};
void IGame_Exit( int argc, char **argv ) {
Plat_Exit(0);
}
ConCommand ExitCmd("exit", IGame_Exit, 0);

6
engine/vk_external_functions.cpp
View File

@@ -8,3 +8,9 @@ VK_DEVICE_FUNCTION(vkCmdSetColorBlendEnableEXT);
VK_DEVICE_FUNCTION(vkCmdSetColorBlendEquationEXT);
VK_DEVICE_FUNCTION(vkCmdSetColorWriteMaskEXT);
VK_DEVICE_FUNCTION(vkCmdSetLogicOpEXT);
VK_DEVICE_FUNCTION(vkCmdTraceRaysKHR);
VK_DEVICE_FUNCTION(vkCreateAccelerationStructureKHR);
VK_DEVICE_FUNCTION(vkDestroyAccelerationStructureKHR);
VK_DEVICE_FUNCTION(vkGetAccelerationStructureBuildSizesKHR);
VK_DEVICE_FUNCTION(vkCmdBuildAccelerationStructuresKHR);
VK_DEVICE_FUNCTION(vkCreateRayTracingPipelinesKHR);

22
engine/vk_helper.h
View File

@@ -14,8 +14,7 @@
#include "vk_external_functions.cpp"
#undef VK_DEVICE_FUNCTION
class CVertexBuffer: public IVertexBuffer
class CVkBuffer: public IBuffer
{
public:
void *Map() override;
@@ -24,17 +23,14 @@ public:
void *m_pAllocated = NULL;
};
class CIndexBuffer: public IIndexBuffer
class CVkImage: public IImage
{
public:
void *Map() override;
void Unmap() override;
vk_buffer_t m_buffer;
void *m_pAllocated;
vk_image2d_t m_image;
};
class CTexture: public ITexture
class CVkTexture: public ITexture
{
public:
vk_image2d_t image;
@@ -65,8 +61,6 @@ extern uint32_t g_nWindowWidth;
extern uint32_t g_nWindowHeight;
extern VkSampler g_invalidTextureSampler;
extern IMaterial *g_pDefaultMaterial;
extern IMaterial *g_pCurrentMaterial;
extern CUtlVector<ITexture*> g_textures;
@@ -77,7 +71,7 @@ struct CameraProjection {
extern vk_buffer_t g_cameraProperties;
extern CameraProjection *g_cameraDataMap;
extern vk_image2d_t g_meshDepth;
extern vk_image2d_t g_meshDepthMSAA;
extern vk_image2d_t g_meshColor;
extern vk_image2d_t g_meshColorMSAA;
extern IImage *g_meshDepth;
extern IImage *g_meshDepthMSAA;
extern IImage *g_meshColor;
extern IImage *g_meshColorMSAA;

423
engine/vk_mesh.cpp
View File

@@ -1,423 +0,0 @@
#include "filesystem.h"
#include "rendering.h"
#include "tier1/utlvector.h"
#include "vk_helper.h"
#include "vulkan/vulkan_core.h"
#include "math3d.h"
vk_tripipeline_t g_meshPipeline = {};
VkDescriptorPool g_meshDescriptorPool;
VkDescriptorSet g_meshDescriptorSet;
VkSampler g_meshSampler;
abstract_class CMesh: public IMesh
{
public:
CMesh();
void SetPosition( vec3 position ) override;
void SetRotationEuler( vec3 angle ) override;
void SetRotationQuat( vec4 quaternion) override;
void SetMatrix( mat4 matrix ) override;
void SetScale( vec3 scale ) override;
void SetVertexBuffer( IVertexBuffer *pBuffer ) override;
void SetIndexBuffer( IIndexBuffer *pBuffer ) override;
void SetMaterial( IMaterial *pMaterial ) override;
void Draw() override;
Material_t m_material;
CVertexBuffer *m_pVertexBuffer = NULL;
CIndexBuffer *m_pIndexBuffer = NULL;
mat4 m_matrix;
};
CMesh::CMesh()
{
glm_mat4_identity(m_matrix);
};
void CMesh::SetPosition( vec3 position )
{
m_matrix[0][3] = position[0];
m_matrix[1][3] = position[1];
m_matrix[2][3] = position[2];
}
void CMesh::SetRotationEuler( vec3 angle )
{
}
void CMesh::SetRotationQuat( vec4 quaternion)
{
}
void CMesh::SetMatrix( mat4 matrix )
{
memcpy(m_matrix,matrix,64);
}
void CMesh::SetScale( vec3 scale )
{
}
void CMesh::SetVertexBuffer( IVertexBuffer *pBuffer )
{
m_pVertexBuffer = (CVertexBuffer*)pBuffer;
}
void CMesh::SetIndexBuffer( IIndexBuffer *pBuffer )
{
m_pIndexBuffer = (CIndexBuffer*)pBuffer;
}
void CMesh::SetMaterial( IMaterial *pMaterial )
{
if (pMaterial == 0)
return;
m_material = pMaterial->m;
}
CUtlVector<CMesh> g_drawnMeshes;
void CMesh::Draw()
{
g_drawnMeshes.AppendTail(*this);
}
void IMeshRenderer::Init()
{
CUtlVector<vk_shader_t> shaders(2);
for (auto &shader: shaders)
{
shader.m_shaderModule = NULL;
}
shaders[0].Create("gfx/mesh_vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaders[1].Create("gfx/mesh_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;
CUtlVector<VkFormat> formats(1);
formats[0] = VK_FORMAT_R16G16B16A16_SFLOAT;
g_meshPipeline.Create(shaders, bindings, 76, formats);
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_meshDescriptorPool);
VkDescriptorSetAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = g_meshDescriptorPool;
allocInfo.descriptorSetCount = 1;
allocInfo.pSetLayouts = &g_meshPipeline.m_descriptorSetLayout;
vkAllocateDescriptorSets(g_vkDevice, &allocInfo, &g_meshDescriptorSet);
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_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);
for (auto &write: writes)
{
write = {};
write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
write.dstSet = g_meshDescriptorSet;
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_GENERAL;
image.imageView = texture->image.m_imageView;
image.sampler = g_meshSampler;
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 barriers[4] = {
{
.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_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 | 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_meshColorMSAA.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.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_meshDepthMSAA.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.resolveMode = VK_RESOLVE_MODE_MIN_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 = {
.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_4_BIT);
VkSampleMask sampleMask = 0xFFFFFFFF;
_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};
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_meshPipeline.m_pipeline);
vkCmdBindDescriptorSets(g_vkCommandBuffer,VK_PIPELINE_BIND_POINT_GRAPHICS, g_meshPipeline.m_layout, 0, 1, &g_meshDescriptorSet, 0, NULL);
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);
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)
{
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/20,1,0,0);
}
}
vkCmdEndRendering(g_vkCommandBuffer);
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_GENERAL,
.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>();
}
IMesh *IMeshRenderer::CreateMesh()
{
CMesh *mesh = new CMesh;
return mesh;
}
void IMeshRenderer::Destroy( IMesh *pModel )
{
}

144
engine/vk_postprocessing.cpp
View File

@@ -1,144 +0,0 @@
#include "rendering.h"
#include "vk_helper.h"
#include "vk_video.h"
#include "vulkan/vulkan_core.h"
vk_shader_t post_agxShader = {};
vk_comppipeline_t post_agxPipeline = {};
VkDescriptorPool post_descriptorPool;
VkDescriptorSet post_descriptorSet;
void IPostProcessRenderer::Init()
{
post_agxShader.Create("gfx/agx_comp.spv", VK_SHADER_STAGE_COMPUTE_BIT);
CUtlVector<VkDescriptorSetLayoutBinding> bindings = {
{
.binding = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
},
{
.binding = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
}
};
post_agxPipeline.Create(post_agxShader, bindings, 0);
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, &post_descriptorPool);
VkDescriptorSetAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = post_descriptorPool;
allocInfo.descriptorSetCount = 1;
allocInfo.pSetLayouts = &post_agxPipeline.m_descriptorSetLayout;
vkAllocateDescriptorSets(g_vkDevice, &allocInfo, &post_descriptorSet);
}
void IPostProcessRenderer::Frame(float fDelta)
{
CUtlVector<VkImageMemoryBarrier> barriers = {
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
.oldLayout = VK_IMAGE_LAYOUT_GENERAL,
.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.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_SHADER_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.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_COMPUTE_SHADER_BIT,
0, 0, NULL, 0, NULL, barriers.GetSize(), barriers.GetData());
CUtlVector<VkWriteDescriptorSet> writes(2);
for (auto &write: writes)
{
write = {};
write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
write.dstSet = post_descriptorSet;
write.dstArrayElement = 0;
}
VkDescriptorImageInfo dii1 = {
.imageView = g_meshColor.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.sampler = NULL,
};
VkDescriptorImageInfo dii2 = {
.imageView = g_swapchainImageView,
.imageLayout = VK_IMAGE_LAYOUT_GENERAL,
.sampler = NULL,
};
writes[0].dstBinding = 0;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
writes[0].descriptorCount = 1;
writes[0].pImageInfo = &dii1;
writes[1].dstBinding = 1;
writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
writes[1].descriptorCount = 1;
writes[1].pImageInfo = &dii2;
vkUpdateDescriptorSets(g_vkDevice, writes.GetSize(), writes.GetData(), 0, NULL);
vkCmdBindPipeline(g_vkCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, post_agxPipeline.m_pipeline);
vkCmdBindDescriptorSets(g_vkCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, post_agxPipeline.m_layout, 0, 1, &post_descriptorSet, 0, 0);
vkCmdDispatch(g_vkCommandBuffer, (g_nWindowWidth+31)/32, (g_nWindowHeight+31)/32, 1);
barriers = {
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = 0,
.dstAccessMask = 0,
.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
.image = g_meshColor.m_image,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
.dstAccessMask = 0,
.oldLayout = VK_IMAGE_LAYOUT_GENERAL,
.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.image = g_swapchainImage,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
}
};
vkCmdPipelineBarrier(g_vkCommandBuffer,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, 0, NULL, 0, NULL, barriers.GetSize(), barriers.GetData());
}

430
engine/vk_video.cpp
View File

@@ -9,6 +9,19 @@
#include "vulkan/vulkan_core.h"
#define STB_IMAGE_IMPLEMENTATION
#if defined(__APPLE__) && defined(__MACH__)
#include "TargetConditionals.h"
#if TARGET_OS_IPHONE
// iOS
#define STBI_NO_THREAD_LOCALS
#else
// macOS
#endif
#else
// Other platforms
#define STBI_THREAD_LOCAL thread_local
#endif
#include "stb_image.h"
#define VULKAN_RENDERING_IMPLEMENTATION
@@ -21,13 +34,58 @@ CameraProjection *g_cameraDataMap;
mat4 g_cameraView;
IMaterial *g_pDefaultMaterial;
IMaterial *g_pCurrentMaterial;
IImage *g_meshDepth;
IImage *g_meshDepthMSAA;
IImage *g_meshColor;
IImage *g_meshColorMSAA;
class CVkGraphicsPipeline: public IGraphicsPipeline
{
public:
vk_tripipeline_t m_pipeline;
};
vk_image2d_t g_meshDepth;
vk_image2d_t g_meshDepthMSAA;
vk_image2d_t g_meshColor;
vk_image2d_t g_meshColorMSAA;
class CVkComputePipeline: public IComputePipeline
{
public:
vk_comppipeline_t m_pipeline;
};
class CVkRayTracingPipeline: public IRayTracingPipeline
{
public:
};
VkFormat IRenderer_FormatToVk( EImageFormat format )
{
switch (format)
{
case IMAGE_FORMAT_R8G8B8A8: return VK_FORMAT_R8G8B8A8_UNORM;
case IMAGE_FORMAT_R16G16B16A16: return VK_FORMAT_R16G16B16A16_UNORM;
case IMAGE_FORMAT_DEPTH: return VK_FORMAT_D32_SFLOAT;
default: return VK_FORMAT_R8G8B8A8_UNORM;
}
};
VkAttachmentLoadOp IRenderer_LoadOpVk( EAttachmentLoadMode mode )
{
switch (mode)
{
case ATTACHMENT_LOAD_MODE_DONT_CARE: return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
case ATTACHMENT_LOAD_MODE_CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR;
case ATTACHMENT_LOAD_MODE_LOAD: return VK_ATTACHMENT_LOAD_OP_LOAD;
default: return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
}
}
VkAttachmentStoreOp IRenderer_StoreOpVk( EAttachmentStoreMode mode )
{
switch (mode)
{
case ATTACHMENT_STORE_MODE_DONT_CARE: return VK_ATTACHMENT_STORE_OP_DONT_CARE;
case ATTACHMENT_STORE_MODE_STORE: return VK_ATTACHMENT_STORE_OP_STORE;
default: return VK_ATTACHMENT_STORE_OP_DONT_CARE;
}
}
void IVulkan::Init()
{
@@ -65,15 +123,25 @@ 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, 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_IMAGE_USAGE_STORAGE_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);
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);
g_meshColor = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, 1280, 720, 1);
g_meshColorMSAA = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, 1280, 720, 4);
glm_mat4_identity(g_cameraView);
IMeshRenderer::Init();
IPostProcessRenderer::Init();
};
void IVulkan::CreatePipelines()
{
for (auto &step: g_StepPrepass)
step.pPipeline->Init();
for (auto &step: g_StepMeshRendering)
step.pPipeline->Init();
for (auto &step: g_StepShading)
step.pPipeline->Init();
for (auto &step: g_StepPostProcessing)
step.pPipeline->Init();
for (auto &step: g_StepUI)
step.pPipeline->Init();
}
void IVulkan::Frame()
{
@@ -87,19 +155,42 @@ void IVulkan::Frame()
if (g_bConfigNotify)
{
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_4_BIT);
g_meshColor.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_SAMPLE_COUNT_1_BIT);
g_meshColorMSAA.Create(g_nWindowWidth, g_nWindowHeight, VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, VK_SAMPLE_COUNT_4_BIT);
IRenderer::DestroyImage(g_meshDepth);
IRenderer::DestroyImage(g_meshDepthMSAA);
IRenderer::DestroyImage(g_meshColor);
IRenderer::DestroyImage(g_meshColorMSAA);
g_meshDepth = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 1);
g_meshDepthMSAA = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 4);
g_meshColor = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 1);
g_meshColorMSAA = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 4);
}
IMeshRenderer::Frame(0);
IPostProcessRenderer::Frame(0);
for (auto &step: g_StepPrepass)
step.pPipeline->Frame(0);
IRenderer::Begin(g_nWindowWidth, g_nWindowHeight,
{
{
g_meshColor,
g_meshColorMSAA,
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_STORE_MODE_STORE,
}
},
{
g_meshDepth,
g_meshDepthMSAA,
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_STORE_MODE_STORE,
});
for (auto &step: g_StepMeshRendering)
step.pPipeline->Frame(0);
IRenderer::End();
for (auto &step: g_StepShading)
step.pPipeline->Frame(0);
for (auto &step: g_StepPostProcessing)
step.pPipeline->Frame(0);
for (auto &step: g_StepUI)
step.pPipeline->Frame(0);
};
void vk_shader_t::Create( const char *szPath, VkShaderStageFlagBits shaderStage )
@@ -384,27 +475,13 @@ void vk_image2d_t::Destroy()
void CopyTo(struct vk_image2d_t *image);
void CopyTo(struct vk_buffer_t *buffer);
void *CVertexBuffer::Map()
void *CVkBuffer::Map()
{
if (!m_pAllocated)
m_pAllocated = m_buffer.Map(0, m_buffer.m_nSize);
return m_pAllocated;
};
void CVertexBuffer::Unmap()
{
if (!m_pAllocated)
return;
m_buffer.Unmap();
m_pAllocated = 0;
};
void *CIndexBuffer::Map()
{
if (!m_pAllocated)
m_pAllocated = m_buffer.Map(0, m_buffer.m_nSize);
return m_pAllocated;
};
void CIndexBuffer::Unmap()
void CVkBuffer::Unmap()
{
if (!m_pAllocated)
return;
@@ -415,21 +492,9 @@ void CIndexBuffer::Unmap()
CUtlVector<ITexture*> g_textures;
CUtlVector<ITexture*> g_newtextures;
uint32_t ITextureManager::GetTexture(ITexture *pTexture)
{
uint32_t i = 0;
for (ITexture *texture: g_textures)
{
if (texture == pTexture)
return i;
i++;
};
return 0;
}
ITexture *ITextureManager::LoadTexture( void *pData, uint32_t X, uint32_t Y, uint32_t numChannels )
{
CTexture *pTexture = new CTexture;
CVkTexture *pTexture = new CVkTexture;
*pTexture = {};
VkDeviceSize imageSize = X*Y*4;
vk_buffer_t gpu_buffer = {};
@@ -562,28 +627,265 @@ ITexture *ITextureManager::LoadTexture( const char *szName )
return pTexture;
};
IMaterial *IRenderer::LoadMaterial( const char *szMaterial )
{
FileHandle_t file = IFileSystem::Open(szMaterial, IFILE_READ);
IMaterial *pMaterial = new IMaterial;
if (!file)
{
return g_pDefaultMaterial;
}
IFileSystem::Close(file);
IStorageBuffer *IRenderer::CreateStorageBuffer( uint32_t uSize )
{
CVkBuffer *pBuffer = new CVkBuffer();
pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
return pBuffer;
}
IUniformBuffer *IRenderer::CreateUniformBuffer( uint32_t uSize )
{
CVkBuffer *pBuffer = new CVkBuffer();
pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
return pBuffer;
}
IVertexBuffer *IRenderer::CreateVertexBuffer( uint32_t uSize )
{
CVertexBuffer *pBuffer = new CVertexBuffer();
CVkBuffer *pBuffer = new CVkBuffer();
pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
return pBuffer;
}
IIndexBuffer *IRenderer::CreateIndexBuffer( uint32_t uSize )
{
CIndexBuffer *pBuffer = new CIndexBuffer();
CVkBuffer *pBuffer = new CVkBuffer();
pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
return pBuffer;
}
IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples )
{
VkFormat vkformat;
VkImageUsageFlags vkusage;
CVkImage *pImage = new CVkImage();
VkSampleCountFlagBits samples;
switch (format)
{
case IMAGE_FORMAT_R8G8B8A8: vkformat = VK_FORMAT_R8G8B8A8_UNORM; break;
case IMAGE_FORMAT_R16G16B16A16: vkformat = VK_FORMAT_R16G16B16A16_UNORM; break;
case IMAGE_FORMAT_DEPTH: vkformat = VK_FORMAT_D32_SFLOAT; break;
default: return 0;
};
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;
switch (nSamples)
{
case 1: samples = VK_SAMPLE_COUNT_1_BIT; break;
case 4: samples = VK_SAMPLE_COUNT_4_BIT; break;
default: samples = VK_SAMPLE_COUNT_1_BIT; break;
}
pImage->m_image.Create(nWidth, nHeight, vkformat, vkusage, samples);
return pImage;
};
void IRenderer::DestroyBuffer( IBuffer *pBuffer )
{
CVkBuffer *pVkBuffer = (CVkBuffer*)pBuffer;
if (pVkBuffer)
pVkBuffer->m_buffer.Destroy();
}
void IRenderer::DestroyImage( IImage *pImage )
{
CVkImage *pVkImage = (CVkImage*)pImage;
if (pVkImage)
pVkImage->m_image.Destroy();
}
void IRenderer::SetConstants( uint32_t nSize, uint32_t nOffset, void *pData )
{
}
void IRenderer::Barrier( EBarrierStage stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
{
}
void IRenderer::BindData( uint32_t binding, IBuffer *pBuffer, IImage* pImage)
{
}
void IRenderer::BindPipeline( IPipeline *pPipeline )
{
if (!pPipeline)
return;
if (pPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)pPipeline;
vkCmdBindPipeline(g_vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pVkPipeline->m_pipeline.m_pipeline);
}
}
void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth )
{
CUtlVector<VkRenderingAttachmentInfo> colorAttachments = {};
VkRenderingAttachmentInfo depthAttachment = {};
for (auto &attachment: attachments)
{
VkRenderingAttachmentInfo vkattachment = {};
vkattachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
CVkImage *pImage = (CVkImage*)attachment.pTemporary;
CVkImage *pTemporary = (CVkImage*)attachment.pTemporary;
if (attachment.pTemporary)
{
vkattachment.imageView = pTemporary->m_image.m_imageView;
vkattachment.resolveImageView = pImage->m_image.m_imageView;
vkattachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
vkattachment.resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
} else
{
vkattachment.imageView = pImage->m_image.m_imageView;
vkattachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
vkattachment.loadOp = IRenderer_LoadOpVk(attachment.loadMode);
vkattachment.storeOp = IRenderer_StoreOpVk(attachment.storeMode);
colorAttachments.AppendTail(vkattachment);
}
depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
CVkImage *pDepthImage = (CVkImage*)depth.pTemporary;
CVkImage *pDepthTemporary = (CVkImage*)depth.pTemporary;
if (depth.pTemporary)
{
depthAttachment.imageView = pDepthTemporary->m_image.m_imageView;
depthAttachment.resolveImageView = pDepthImage->m_image.m_imageView;
depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
depthAttachment.resolveImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
} else
{
depthAttachment.imageView = pDepthImage->m_image.m_imageView;
depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
}
depthAttachment.loadOp = IRenderer_LoadOpVk(depth.loadMode);
depthAttachment.storeOp = IRenderer_StoreOpVk(depth.storeMode);
VkRenderingInfo renderInfo = {
.sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
.renderArea = {{0, 0}, {nWidth, nHeight}},
.layerCount = 1,
.colorAttachmentCount = (uint32_t)colorAttachments.GetSize(),
.pColorAttachments = colorAttachments.GetData(),
.pDepthAttachment = &depthAttachment,
};
vkCmdBeginRendering(g_vkCommandBuffer, &renderInfo);
}
void IRenderer::ResetState()
{
}
void IRenderer::SetDepthMode( EDepthMode mode )
{
}
void IRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
{
}
void IRenderer::End()
{
vkCmdEndRendering(g_vkCommandBuffer);
}
IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
CUtlVector<Shader_t> shaders,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize,
CUtlVector<EImageFormat> outputFormats
)
{
CVkGraphicsPipeline *pipeline = new CVkGraphicsPipeline;
pipeline->type = PIPELINE_TYPE_RASTERIZATION;
CUtlVector<vk_shader_t> vkshaders(shaders.GetSize());
CUtlVector<VkDescriptorSetLayoutBinding> vkbindings(inputs.GetSize());
CUtlVector<VkFormat> vkformats(outputFormats.GetSize());
for ( uint32_t i = 0; i < vkshaders.GetSize(); i++ )
{
VkShaderStageFlagBits flags;
if (shaders[i].type == SHADER_TYPE_VERTEX) flags = VK_SHADER_STAGE_VERTEX_BIT;
if (shaders[i].type == SHADER_TYPE_FRAGMENT) flags = VK_SHADER_STAGE_FRAGMENT_BIT;
vkshaders[i].Create(shaders[i].szPath, flags);
}
for ( uint32_t i = 0; i < vkbindings.GetSize(); i++ )
{
vkbindings[i].binding = inputs[i].binding;
vkbindings[i].descriptorCount = 1;
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;
if (inputs[i].type == SHADER_INPUT_TYPE_TLAS) vkbindings[i].descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
if (inputs[i].type == SHADER_INPUT_TYPE_TEXTURES)
{
vkbindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
vkbindings[i].descriptorCount = 1024;
}
}
for ( uint32_t i = 0; i < vkformats.GetSize(); i++ )
{
vkformats[i] = IRenderer_FormatToVk(outputFormats[i]);
}
pipeline->m_pipeline.Create(vkshaders, vkbindings, nConstantsSize, vkformats);
return 0;
};
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()
{
}
CRenderingStep::CRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
{
}
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});
}

105
engine/vk_video.h Normal file
View File

@@ -0,0 +1,105 @@
#ifndef VK_VIDEO_H
#define VK_VIDEO_H
#include "rendering.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"
#include "vulkan/vulkan.h"
#include "vulkan/vulkan_core.h"
#ifndef VULKAN_RENDERING_IMPL
#error "Not a vulkan rendering implementation. Do not use this file!"
#endif
#include "vk_mem_alloc.h"
struct vk_framedata_t {
VkSemaphore draw;
VkSemaphore present;
VkFence fence;
};
struct vk_shader_t
{
void Create( const char *szPath, VkShaderStageFlagBits shaderStage );
void Create( CUtlBuffer<uint8_t> &spirv, VkShaderStageFlagBits shaderStage );
void Destroy( void );
VkShaderModule m_shaderModule = NULL;
VkPipelineShaderStageCreateInfo m_stageCreateInfo;
};
struct vk_tripipeline_t
{
void Create(
CUtlVector<vk_shader_t> &shaders,
CUtlVector<VkDescriptorSetLayoutBinding> &bindings,
uint32_t pushConstantsSize,
CUtlVector<VkFormat> formats
/* the rest of the stuff is set by the dynamic state */
/* literally */
);
void Destroy();
CUtlVector<vk_shader_t> m_shaders;
VkDescriptorSetLayout m_descriptorSetLayout;
VkPipelineLayout m_layout;
VkPipeline m_pipeline;
};
struct vk_comppipeline_t
{
void Create(
vk_shader_t &shader,
CUtlVector<VkDescriptorSetLayoutBinding> &bindings,
uint32_t pushConstantsSize
);
void Destroy();
VkDescriptorSetLayout m_descriptorSetLayout;
VkPipelineLayout m_layout;
VkPipeline m_pipeline;
};
struct vk_buffer_t
{
void Create(size_t size, VkBufferUsageFlags usage);
void Destroy();
void *Map(size_t offset, size_t size);
void Unmap();
void CopyTo(struct vk_image2d_t *image);
void CopyTo(struct vk_buffer_t *buffer);
size_t m_nSize;
VkBuffer m_buffer;
VmaAllocation m_memory;
VkDeviceAddress m_address;
};
struct vk_image2d_t
{
void Create(size_t x, size_t y, VkFormat format, VkImageUsageFlags usage, VkSampleCountFlagBits samples);
void Destroy();
void CopyTo(struct vk_image2d_t *image);
void CopyTo(struct vk_buffer_t *buffer);
uint32_t m_X;
uint32_t m_Y;
VkFormat m_format;
VkImage m_image;
VkImageView m_imageView;
VmaAllocation m_memory;
};
interface IVulkan
{
public:
static void Init();
static void CreatePipelines();
static void Frame();
static void Deinit();
};
#endif

28
engine/vk_videosdl.cpp
View File

@@ -189,6 +189,8 @@ EInputKey ISDL_KeyName(SDL_Keycode key)
{
switch(key)
{
case SDLK_ESCAPE: return KEY_ESCAPE;
case SDLK_1: return KEY_1;
case SDLK_2: return KEY_2;
case SDLK_3: return KEY_3;
@@ -380,7 +382,19 @@ void IVideo::Init()
IVideo_SwapchainInit();
IVulkan::Init();
}
void IInput::SetMouseMode( EMouseMode mode )
{
switch (mode)
{
case MOUSE_MODE_GAME:
SDL_SetWindowRelativeMouseMode(g_window, true);
return;
default:
SDL_SetWindowRelativeMouseMode(g_window, false);
return;
}
}
void IVideo_HandleEvents()
@@ -389,6 +403,7 @@ void IVideo_HandleEvents()
while (SDL_PollEvent(&event))
{
SDL_KeyboardEvent *key = &event.key;
SDL_MouseMotionEvent *motion = &event.motion;
switch (event.type)
{
case SDL_EVENT_WINDOW_RESIZED:
@@ -398,16 +413,25 @@ void IVideo_HandleEvents()
break;
case SDL_EVENT_KEY_DOWN:
if (!key->repeat)
IInput::KeyEvent(ISDL_KeyName(key->key),KEY_EVENT_TYPE_UP);
IInput::KeyEvent(ISDL_KeyName(key->key),KEY_EVENT_TYPE_DOWN);
break;
case SDL_EVENT_KEY_UP:
key = &event.key;
SDL_Log("Key Up: %s", SDL_GetKeyName(key->key));
if (!key->repeat)
IInput::KeyEvent(ISDL_KeyName(key->key),KEY_EVENT_TYPE_UP);
break;
case SDL_EVENT_MOUSE_MOTION:
IInput::AxisEvent(AXIS_MOUSE_X, motion->yrel*0.022);
IInput::AxisEvent(AXIS_MOUSE_Y, -motion->xrel*0.022);
break;
}
};
};
void IVideo::CreatePipelines( )
{
IVulkan::CreatePipelines();
};
void IVideo::Frame( float fDelta )
{