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

added command line, added basic character

Browse Source
This commit is contained in:
kotofyt
2025-06-12 00:17:59 +03:00
parent 64c0f41884
commit af4f0c3cad
65 changed files with 262985 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
engine/__build.cpp
View File

@@ -10,26 +10,31 @@ CUtlVector<CUtlString> engine_CompiledFiles = {
"engine/server.cpp",
"engine/engine.cpp",
"engine/physics.cpp",
"engine/gamemode.cpp",
/* rendering */
"engine/vk_video.cpp",
"engine/vk_mesh.cpp",
"engine/vk_postprocessing.cpp",
/* entities */
"engine/baseentity.cpp",
"engine/level.cpp",
"engine/brush.cpp",
/* server */
/* server entities */
"engine/sv_worldspawn.cpp",
"engine/sv_light.cpp",
"engine/sv_playerstart.cpp",
/* client */
/* client entities */
"engine/cl_worldspawn.cpp",
"engine/cl_light.cpp",
"engine/cl_light.cpp",
/* rendering */
"engine/vk_videosdl.cpp",
"engine/vk_video.cpp",
"engine/vk_mesh.cpp",
"engine/vk_postprocessing.cpp",
/* io */
"engine/input.cpp",
"engine/net.cpp"
};
CUtlVector<CUtlString> engine_Libraries = {

1
engine/baseentity.cpp
View File

@@ -1,5 +1,4 @@
#include "baseentity.h"
#include "cglm/mat4.h"
#include "tier0/platform.h"
#include "tier1/utlstring.h"

0
engine/vk_shading.cpp → engine/baseplayer.cpp
View File

2
engine/brush.cpp
View File

@@ -1,11 +1,11 @@
#include "brush.h"
#include "baseentity.h"
#include "cglm/mat4.h"
#include "physics.h"
#include "rendering.h"
#include "tier0/platform.h"
#include "tier1/utlbuffer.h"
#include "tier1/utlvector.h"
#include "math3d.h"
void CBrushEntity::Precache()
{

124
engine/console.cpp
View File

@@ -1,9 +1,13 @@
#include "console.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
CUtlVector<ConVar*> g_convars;
CUtlVector<ConCommand*> g_commands;
void IConsole::RegisterVar( ConVar *cvar )
{
g_convars.AppendTail(cvar);
}
void IConsole::UnRegisterVar( ConVar *cvar )
{
@@ -11,35 +15,112 @@ void IConsole::UnRegisterVar( ConVar *cvar )
}
ConVar *IConsole::FindVar( const char *pName )
{
for (auto &var: g_convars)
{
if (!V_strcmp(var->GetName(), pName))
return var;
}
return NULL;
}
void IConsole::RegisterCommand( ConVar *cvar )
void IConsole::RegisterCommand( ConCommand *cvar )
{
g_commands.AppendTail(cvar);
}
void IConsole::UnRegisterCommand( ConVar *cvar )
void IConsole::UnRegisterCommand( ConCommand *cvar )
{
}
ConCommand *IConsole::FindCommand( const char *pName )
{
for (auto &var: g_commands)
{
if (!V_strcmp(var->GetName(), pName))
return var;
}
return NULL;
}
CUtlString g_commandBuffer;
//-----------------------------------------------------------------------------
// Executes arguments from IConsole::Execute
//-----------------------------------------------------------------------------
void IConsole::Execute2( CUtlVector<CUtlString> &args )
{
if (args.GetSize()<1)
return;
ConCommand *cmd = IConsole::FindCommand(args[0]);
if (!cmd)
{
V_printf("%s not found\n", args[0].GetString());
return;
}
CUtlBuffer<char*> strbuffer(args.GetSize());
for ( size_t i = 0; i < args.GetSize(); i++)
{
strbuffer[i] = args[i].GetString();
};
(cmd->GetCallback())(args.GetSize(), strbuffer);
}
//-----------------------------------------------------------------------------
// Parses command buffer.
//-----------------------------------------------------------------------------
void IConsole::Execute( void )
{
CUtlVector<CUtlString> arguments;
CUtlString szArgument;
bool bIsQuote = false;
for (auto &c: (CUtlVector<char>&)g_commandBuffer)
{
if (c == '\"')
{
bIsQuote = !bIsQuote;
continue;
}
if (c == ';' || c == '\n' || c == '\0')
{
if (bIsQuote)
{
if (c != '\0')
szArgument.AppendTail(c);
continue;
}
if (szArgument != 0)
arguments.AppendTail(szArgument);
IConsole::Execute2(arguments);
szArgument = 0;
arguments = {};
continue;
}
if ( c == '\t' || c == ' ' )
{
if (bIsQuote)
{
szArgument.AppendTail(c);
continue;
}
if (szArgument != 0)
arguments.AppendTail(szArgument);
szArgument = 0;
continue;
}
szArgument.AppendTail(c);
};
g_commandBuffer = 0;
}
void IConsole::AddCommand( const char *psz )
{
g_commandBuffer.AppendTail(psz);
}
void IConsole::InsertCommand( const char *psz )
{
g_commandBuffer.AppendHead(psz);
};
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags )
@@ -55,7 +136,7 @@ ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
const char *pHelpString, ConCommandFn callback )
{
m_szName = CUtlString(pName);
m_szName = pName;
m_flags = flags;
m_szValue = pDefaultValue;
m_fValue = V_atof(pDefaultValue);
@@ -69,7 +150,7 @@ bool ConVar::IsFlagSet( int flag )
}
const char *ConVar::GetHelpText( void )
{
return m_szHelpString;
}
bool ConVar::IsRegistered( void )
{
@@ -77,7 +158,7 @@ bool ConVar::IsRegistered( void )
}
const char *ConVar::GetName( void )
{
return m_szName;
}
void ConVar::AddFlags( int flags )
{
@@ -129,4 +210,25 @@ void ConVar::SetValue( int iValue )
m_fValue = iValue;
m_nValue = iValue;
m_szValue = CUtlString("%i\n",iValue);
}
}
ConCommand::ConCommand(const char *pName, ConCommandFn callback,
const char *pHelpString, int flags)
{
m_szName = pName;
m_callback = callback;
m_flags = flags;
IConsole::RegisterCommand(this);
};
const char *ConCommand::GetHelpText( void )
{
return m_szHelpString;
}
const char *ConCommand::GetName( void )
{
return m_szName;
}
ConCommandFn ConCommand::GetCallback( void )
{
return m_callback;
}

68
engine/engine.cpp
View File

@@ -1,3 +1,4 @@
#include "input.h"
#include "tier1/commandline.h"
#include "tier1/utlstring.h"
#include "tier0/lib.h"
@@ -14,6 +15,11 @@ double fPrev = 0;
double fCurrent = 0;
funnyphysics *px;
IIClient g_localClient;
CUtlVector<IIClient*> g_clients;
//-----------------------------------------------------------------------------
// Purpose: Engine entry point
//-----------------------------------------------------------------------------
@@ -30,6 +36,9 @@ extern "C" void FunnyMain( int argc, char **argv ) {
/* deinit is handled explicitly */
};
//-----------------------------------------------------------------------------
// Purpose: Recieves signals from the system
//-----------------------------------------------------------------------------
void IEngine_Signal(int sig)
{
printf("Trapped signal %i\n",sig);
@@ -48,7 +57,9 @@ void IEngine_Signal(int sig)
_exit(0);
};
//-----------------------------------------------------------------------------
// Purpose: Initializes engine
//-----------------------------------------------------------------------------
void IEngine::Init()
{
/* trap signals */
@@ -66,36 +77,52 @@ void IEngine::Init()
#endif
IFileSystem::InitFilesystem();
IVideo::Init();
px = px_init();
if (!ICommandLine::CheckParam("-dedicated"))
{
g_localClient = {
};
IIEngine::ConnectClient(&g_localClient);
IVideo::Init();
IInput::Init();
}
IServer::LoadGame("funnygame");
};
//-----------------------------------------------------------------------------
// Purpose: Updates every frame
//-----------------------------------------------------------------------------
void IEngine::Frame(float fDelta)
{
IServer::Think(fDelta);
IVideo::Frame(fDelta);
};
//-----------------------------------------------------------------------------
// Purpose: Deinitializes engine
//-----------------------------------------------------------------------------
void IEngine::Shutdown()
{
};
//-----------------------------------------------------------------------------
// Purpose: Spawns entity in the world
//-----------------------------------------------------------------------------
CBaseEntity *IIEngine::SpawnEntity( const char *szName )
{
V_printf("%s\n", szName);
for (auto &entity: g_RegisteredEntities)
{
if (!V_strcmp(entity->m_szName, szName))
{
CBaseEntity *pEnt = entity->m_pfn();
pEnt->Spawn();
g_entities.AppendTail(pEnt);
if (entity->m_pClientfn)
{
pEnt->pClientEntity = entity->m_pClientfn();
pEnt->pClientEntity->Spawn();
pEnt->pClientEntity->pEntity = pEnt;
}
return pEnt;
@@ -104,7 +131,38 @@ CBaseEntity *IIEngine::SpawnEntity( const char *szName )
return 0;
};
//-----------------------------------------------------------------------------
// Purpose: Spawns entity without any parameters
//-----------------------------------------------------------------------------
void IIEngine::InitEntity( CBaseEntity *pEntity )
{
if (!pEntity)
return;
pEntity->Spawn();
if (pEntity->pClientEntity)
pEntity->pClientEntity->Spawn();
};
//-----------------------------------------------------------------------------
// Purpose: Destroys entity
//-----------------------------------------------------------------------------
void IIEngine::DestroyEntity( CBaseEntity *pEntity )
{
};
//-----------------------------------------------------------------------------
// Purpose: Connects client to the server
//-----------------------------------------------------------------------------
void IIEngine::ConnectClient( IIClient *pClient)
{
g_clients.AppendTail(pClient);
}
//-----------------------------------------------------------------------------
// Purpose: Disconnects client from the server
//-----------------------------------------------------------------------------
void IIEngine::DisconnectClient( IIClient *pClient)
{
}

64
engine/gamemode.cpp Normal file
View File

@@ -0,0 +1,64 @@
#include "gamemode.h"
#include "playerstart.h"
#include "tier1/utlvector.h"
CGameMode *pCurrentMode = NULL;
void CGameMode::RoundBegin( void )
{
size_t i = 0;
for (auto &start: g_PlayerStarts)
{
start->RoundEnd();
}
for (auto &player: g_clients)
{
CPlayerStart *pSelectedStart = NULL;
for (auto &start: g_PlayerStarts)
{
if (start->m_bIsRunning == false)
pSelectedStart = start;
};
pSelectedStart->RoundStart(player);
i++;
}
}
void CGameMode::RoundEnd( void )
{
}
void IGameModeManager::Init( void )
{
}
void IGameModeManager::Frame( void )
{
}
void IGameModeManager::StartGameMode(CGameMode *pGameMode)
{
if (pCurrentMode)
pCurrentMode->RoundEnd();
pCurrentMode = pGameMode;
if (pCurrentMode)
pCurrentMode->RoundBegin();
}
CGameMode *IGameModeManager::GetCurrentMode( void )
{
return pCurrentMode;
}
void IGameModeManager::RestartCurrentMode( void )
{
if (!pCurrentMode)
return;
pCurrentMode->RoundEnd();
pCurrentMode->RoundBegin();
}

52
engine/input.cpp Normal file
View File

@@ -0,0 +1,52 @@
#include "input.h"
#include "console.h"
#include "tier0/lib.h"
char g_PressedKeys[256];
float g_fXAxisEvent[256];
float g_fYAxisEvent[256];
CUtlString g_bindings[256];
void IInput::Init( void )
{
}
void IInput::KeyEvent( EInputKey key, EKeyEventType event )
{
V_printf("key\n");
}
void IInput::AxisEvent( unsigned char cAxis, float fX, float fY )
{
}
void IInput::Frame( void )
{
}
void IInput::Deinit( void )
{
}
void IInput_Bind( int argc, char **argv )
{
};
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);

3
engine/level.cpp
View File

@@ -51,6 +51,9 @@ void ILevel::LoadLevel( const char *szLevelName )
break;
}
}
if (!pEntity)
continue;
for ( uint32_t j = 0; j<pEntityHeader->nProperties; j++ )
{
CUtlBuffer<char> szParamName(V_strlen(pData)+1);

0
engine/net.cpp Normal file
View File

35
engine/physics.cpp
View File

@@ -1,5 +1,4 @@
#include "physics.h"
#include "cglm/mat4.h"
#include "physics_gen.h"
void CPxCollider::Spawn( float fFriction )
@@ -41,14 +40,48 @@ void CPxTriangleMesh::Destroy()
};
void CPxRigidKinematicPosition::Spawn( CPxCollider *pCollider, px_matrix matrix, px_rigidbody_params params )
{
m_pRigidBody = px_kinematic_position_body(px, pCollider->m_pCollider, matrix, params);
};
px_vec3 CPxRigidKinematicPosition::GetPosition( void )
{
return px_getposition(px, m_pRigidBody);
};
px_matrix CPxRigidKinematicPosition::GetMatrix ( void )
{
return px_getmatrix(px, m_pRigidBody);
};
void CPxRigidKinematicPosition::Destroy()
{
};
void CPxRigidBody::Spawn( CPxCollider *pCollider, px_matrix matrix, px_rigidbody_params params )
{
m_pRigidBody = px_rigidbody(px, pCollider->m_pCollider, matrix, params);
};
void CPxRigidBody::SetPosition( px_vec3 position )
{
px_setposition(px, m_pRigidBody, position);
}
void CPxRigidBody::SetVelocity( px_vec3 velocity )
{
px_setvelocity(px, m_pRigidBody, velocity);
}
px_vec3 CPxRigidBody::GetPosition( void )
{
return px_getposition(px, m_pRigidBody);
};
px_vec3 CPxRigidBody::GetVelocity( void )
{
return px_getvelocity(px, m_pRigidBody);
};
px_matrix CPxRigidBody::GetMatrix ( void )
{
return px_getmatrix(px, m_pRigidBody);

8
engine/server.cpp
View File

@@ -1,8 +1,12 @@
#include "server.h"
#include "input.h"
#include "tier1/commandline.h"
#include "tier1/utlstring.h"
#include "baseentity.h"
#include "console.h"
#include "physics.h"
#include "input.h"
#include "net.h"
void *g_serverdll;
ConVar g_tickrate("tickrate","64",FCVAR_PROTECTED);
@@ -28,9 +32,13 @@ void IServer::Think( float fDelta )
{
g_fAccumulator += fDelta;
float fTickrate = 1.0/g_tickrate.GetFloat();
/* tickrate */
while(g_fAccumulator>=fTickrate)
{
IInput::Frame();
IConsole::AddCommand("+forward;");
IConsole::Execute();
g_fAccumulator-=fTickrate;
for (auto &entity: g_entities)
{

2
engine/sv_light.cpp
View File

@@ -1,7 +1,5 @@
#include "baseentity.h"
#include "cglm/mat4.h"
#include "physics.h"
#include "cglm/cglm.h"
class CLight: public CBaseEntity
{

54
engine/sv_playerstart.cpp Normal file
View File

@@ -0,0 +1,54 @@
#include "baseentity.h"
#include "baseplayer.h"
#include "engine.h"
#include "tier1/utlvector.h"
CUtlVector<CPlayerStart*> g_PlayerStarts;
void CPlayerStart::Precache()
{
}
void CPlayerStart::Spawn()
{
g_PlayerStarts.AppendTail(this);
};
void CPlayerStart::ReadParameter( const char *szName, const char *szValue )
{
CBaseEntity::ReadParameter(szName, szValue);
}
void CPlayerStart::Destroy()
{
}
void CPlayerStart::Think( float fDelta )
{
}
void CPlayerStart::RoundEnd( void )
{
m_bIsRunning = false;
}
void CPlayerStart::RoundStart(IIClient *pClient)
{
IIEngine::DestroyEntity(pOwningPlayer);
if (!pClient)
return;
m_bIsRunning = true;
pOwningPlayer = (CBasePlayer*)IIEngine::SpawnEntity("player");
if (pOwningPlayer)
{
pOwningPlayer->pOwningSpawn = this;
pOwningPlayer->SetPosition(m_position);
}
else
V_printf("Failed to spawn player\n");
IIEngine::InitEntity(pOwningPlayer);
pClient->pBasePlayer = pOwningPlayer;
};
DECLARE_ENTITY(info_player_start, CPlayerStart);

2
engine/vk_helper.h
View File

@@ -14,8 +14,6 @@
#include "vk_external_functions.cpp"
#undef VK_DEVICE_FUNCTION
#include "cglm/affine.h"
#include "cglm/cglm.h"
class CVertexBuffer: public IVertexBuffer
{

10
engine/vk_mesh.cpp
View File

@@ -1,9 +1,9 @@
#include "cglm/mat4.h"
#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 = {};
@@ -112,7 +112,7 @@ void IMeshRenderer::Init()
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[1].descriptorCount = 1024;
CUtlVector<VkFormat> formats(1);
formats[0] = g_meshColor.m_format;
formats[0] = VK_FORMAT_R16G16B16A16_SFLOAT;
g_meshPipeline.Create(shaders, bindings, 76, formats);
shaders[1].Destroy();
shaders[0].Destroy();
@@ -285,7 +285,7 @@ void IMeshRenderer::Frame( float fDelta )
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
.imageView = g_meshDepthMSAA.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT,
.resolveMode = VK_RESOLVE_MODE_MIN_BIT,
.resolveImageView = g_meshDepth.m_imageView,
.resolveImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
@@ -346,7 +346,7 @@ void IMeshRenderer::Frame( float fDelta )
VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
NULL,
1, 0,
VK_FORMAT_R32G32_SFLOAT,
VK_FORMAT_R32G32_SFLOAT,
12
}
};
@@ -385,7 +385,7 @@ void IMeshRenderer::Frame( float fDelta )
}
else
{
vkCmdDraw(g_vkCommandBuffer, mesh.m_pVertexBuffer->m_buffer.m_nSize/12,1,0,0);
vkCmdDraw(g_vkCommandBuffer, mesh.m_pVertexBuffer->m_buffer.m_nSize/20,1,0,0);
}
}
vkCmdEndRendering(g_vkCommandBuffer);

14
engine/vk_postprocessing.cpp
View File

@@ -61,7 +61,7 @@ void IPostProcessRenderer::Frame(float fDelta)
.srcAccessMask = 0,
.dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
.oldLayout = VK_IMAGE_LAYOUT_GENERAL,
.newLayout = 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}
},
@@ -92,7 +92,7 @@ void IPostProcessRenderer::Frame(float fDelta)
VkDescriptorImageInfo dii1 = {
.imageView = g_meshColor.m_imageView,
.imageLayout = VK_IMAGE_LAYOUT_GENERAL,
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.sampler = NULL,
};
VkDescriptorImageInfo dii2 = {
@@ -116,7 +116,15 @@ void IPostProcessRenderer::Frame(float fDelta)
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,

10
engine/vk_video.cpp
View File

@@ -1,4 +1,4 @@
#include "cglm/mat4.h"
#include "math3d.h"
#include "filesystem.h"
#include "rendering.h"
#include "tier0/lib.h"
@@ -69,6 +69,7 @@ void IVulkan::Init()
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);
glm_mat4_identity(g_cameraView);
IMeshRenderer::Init();
IPostProcessRenderer::Init();
@@ -93,8 +94,8 @@ void IVulkan::Frame()
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_R8G8B8A8_UNORM, 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_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_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);
}
IMeshRenderer::Frame(0);
@@ -172,8 +173,6 @@ void vk_tripipeline_t::Create(
/* pInputAssemblyState */
VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,
VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
/* pTessellationState */
VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT,
/* pViewportState */
VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
@@ -200,7 +199,6 @@ void vk_tripipeline_t::Create(
VK_DYNAMIC_STATE_DEPTH_BOUNDS,
/* pColorBlendState */
VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
VK_DYNAMIC_STATE_LOGIC_OP_EXT,
VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,

68
engine/vk_videosdl.cpp
View File

@@ -3,10 +3,12 @@
#include "tier1/utlvector.h"
#include "console.h"
#include "tier1/commandline.h"
#include "input.h"
#include "vulkan/vulkan.h"
#include "SDL3/SDL.h"
#include "vulkan/vulkan_core.h"
#include <SDL3/SDL_keycode.h>
#define SDL_MAIN_HANDLED
#include "SDL3/SDL_main.h"
#include "SDL3/SDL_vulkan.h"
@@ -17,7 +19,9 @@
#define VMA_VULKAN_VERSION 1004000
#define VMA_IMPLEMENTATION
#include "tier0/minmax_off.h"
#include "vk_mem_alloc.h"
#include "tier0/minmax.h"
SDL_Window *g_window;
@@ -181,6 +185,51 @@ void IVideo_SwapchainDestroy()
}
};
EInputKey ISDL_KeyName(SDL_Keycode key)
{
switch(key)
{
case SDLK_1: return KEY_1;
case SDLK_2: return KEY_2;
case SDLK_3: return KEY_3;
case SDLK_4: return KEY_4;
case SDLK_5: return KEY_5;
case SDLK_6: return KEY_6;
case SDLK_7: return KEY_7;
case SDLK_8: return KEY_8;
case SDLK_9: return KEY_9;
case SDLK_0: return KEY_0;
case SDLK_A: return KEY_A;
case SDLK_B: return KEY_B;
case SDLK_C: return KEY_C;
case SDLK_D: return KEY_D;
case SDLK_E: return KEY_E;
case SDLK_F: return KEY_F;
case SDLK_G: return KEY_G;
case SDLK_H: return KEY_H;
case SDLK_I: return KEY_I;
case SDLK_J: return KEY_J;
case SDLK_K: return KEY_K;
case SDLK_L: return KEY_L;
case SDLK_M: return KEY_M;
case SDLK_N: return KEY_N;
case SDLK_O: return KEY_O;
case SDLK_P: return KEY_P;
case SDLK_Q: return KEY_Q;
case SDLK_R: return KEY_R;
case SDLK_S: return KEY_S;
case SDLK_T: return KEY_T;
case SDLK_U: return KEY_U;
case SDLK_V: return KEY_V;
case SDLK_W: return KEY_W;
case SDLK_X: return KEY_X;
case SDLK_Y: return KEY_Y;
case SDLK_Z: return KEY_Z;
}
return KEY_NONE;
};
void IVideo::Init()
{
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
@@ -276,16 +325,9 @@ void IVideo::Init()
.extendedDynamicState3ColorWriteMask = VK_TRUE,
};
VkPhysicalDeviceExtendedDynamicState2FeaturesEXT pdeds2fe = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
.pNext = &pdeds3fe,
.extendedDynamicState2LogicOp = VK_TRUE,
.extendedDynamicState2PatchControlPoints = VK_TRUE,
};
VkPhysicalDeviceVulkan13Features pdv13f = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
.pNext = &pdeds2fe,
.pNext = &pdeds3fe,
.synchronization2 = VK_TRUE,
.dynamicRendering = VK_TRUE,
};
@@ -346,12 +388,22 @@ void IVideo_HandleEvents()
SDL_Event event;
while (SDL_PollEvent(&event))
{
SDL_KeyboardEvent *key = &event.key;
switch (event.type)
{
case SDL_EVENT_WINDOW_RESIZED:
g_nWindowWidth = event.window.data1;
g_nWindowHeight = event.window.data2;
g_bConfigNotify = 2;
break;
case SDL_EVENT_KEY_DOWN:
if (!key->repeat)
IInput::KeyEvent(ISDL_KeyName(key->key),KEY_EVENT_TYPE_UP);
break;
case SDL_EVENT_KEY_UP:
key = &event.key;
SDL_Log("Key Up: %s", SDL_GetKeyName(key->key));
break;
}
};
};