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

brought back functionality from previous builds but now cross-platform

Browse Source
This commit is contained in:
kotofyt
2025-07-07 15:34:34 +03:00
parent 99eafb9443
commit 83bc9b7f16
61 changed files with 1210 additions and 581 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
engine/__build.cpp
View File

@@ -11,6 +11,11 @@ CUtlVector<CUtlString> engine_CompiledFiles = {
"engine/engine.cpp",
"engine/physics.cpp",
"engine/gamemode.cpp",
"engine/rendering.cpp",
/* io */
"engine/input.cpp",
"engine/net.cpp",
/* entities */
@@ -26,9 +31,6 @@ CUtlVector<CUtlString> engine_CompiledFiles = {
"engine/cl_worldspawn.cpp",
"engine/cl_light.cpp",
/* io */
"engine/input.cpp",
"engine/net.cpp"
};
CUtlVector<CUtlString> engine_Libraries = {
@@ -42,6 +44,7 @@ int engine_build()
{
engine_CompiledFiles.AppendTail("engine/ml_videosdl.cpp");
engine_CompiledFiles.AppendTail("engine/ml_video.cpp");
engine_CompiledFiles.AppendTail("engine/ml_video.mm");
} else {
engine_CompiledFiles.AppendTail("engine/vk_videosdl.cpp");
engine_CompiledFiles.AppendTail("engine/vk_video.cpp");

63
engine/brush.cpp
View File

@@ -1,5 +1,6 @@
#include "brush.h"
#include "baseentity.h"
#include "cglm/mat4.h"
#include "physics.h"
#include "rendering.h"
#include "tier0/platform.h"
@@ -7,6 +8,8 @@
#include "tier1/utlvector.h"
#include "math3d.h"
CUtlVector<IVertexBuffer*> g_BrushVertices;
void CBrushEntity::Precache()
{
@@ -66,9 +69,9 @@ void C_BrushEntity::Spawn()
};
CBrushEntity* pBrushEntity = (CBrushEntity*)pEntity;
uint32_t numVertices = 15*pBrushEntity->m_mesh.GetSize();
uint32_t numVertices = pBrushEntity->m_mesh.GetSize();
vertexBuffer = IRenderer::CreateVertexBuffer(numVertices*4);
vertexBuffer = IRenderer::CreateVertexBuffer(numVertices*60);
Vertex_t *pTriangles = (Vertex_t*)vertexBuffer->Map();
uint32_t i = 0;
@@ -100,15 +103,7 @@ void C_BrushEntity::Destroy()
}
void C_BrushEntity::Think( float fDelta )
{
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];
g_BrushVertices.AppendTail(vertexBuffer);
};
IGraphicsPipeline *g_BrushPipeline;
@@ -123,33 +118,47 @@ private:
};
DECLARE_MESH_RENDERING_STAGE(CBrushRendering, brush_rasterizer);
CUtlVector<IVertexBuffer*> g_BrushVertices;
ITexture *bricks;
void CBrushRendering::Init()
{
V_printf("cool\n");
IRenderer::CreateGraphicsPipeline(
{
{"shaders/brush_vert.spv", SHADER_TYPE_VERTEX},
{"shaders/brush_frag.spv", SHADER_TYPE_FRAGMENT},
},
{}, 64,
20,
{{0,0,EVertexFormat::VERTEX_FORMAT_X32Y32Z32}, {12,1,EVertexFormat::VERTEX_FORMAT_X32Y32}},
{EImageFormat::IMAGE_FORMAT_R8G8B8A8}
);
g_BrushPipeline = IRenderer::CreateGraphicsPipeline(
{
{"gfx/mesh_vert.shader", SHADER_TYPE_VERTEX},
{"gfx/mesh_frag.shader", SHADER_TYPE_FRAGMENT},
},
{
{SHADER_INPUT_TYPE_UNIFORM_BUFFER,0},
{SHADER_INPUT_TYPE_TEXTURES,1},
},
80,
20,
{{0,0,EVertexFormat::VERTEX_FORMAT_X32Y32Z32}, {12,1,EVertexFormat::VERTEX_FORMAT_X32Y32}},
{EImageFormat::IMAGE_FORMAT_R8G8B8A8},
true
);
bricks = ITextureManager::LoadTexture("textures/bricks.png");
};
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)
struct {
mat4 i;
uint32_t a = ITextureManager::GetTextureID(bricks);
uint32_t b = 0;
uint32_t c = 0;
} constants;
glm_mat4_identity(constants.i);
IRenderer::SetConstants(sizeof(constants), &constants);
IRenderer::BindData(0, IRenderer::GetCameraMatrix(), 0);
IRenderer::PushBindings();
for (auto &v: g_BrushVertices)
{
IRenderer::Draw(vertices, 0);
IRenderer::Draw(v, 0);
}
g_BrushVertices = {};
};
void CBrushRendering::Deinit()

11
engine/engine.cpp
View File

@@ -63,7 +63,7 @@ void IEngine_Signal(int sig)
void IEngine::Init()
{
/* trap signals */
#ifdef __linux
#ifdef __linux__
signal(SIGHUP, IEngine_Signal);
signal(SIGINT, IEngine_Signal);
signal(SIGQUIT, IEngine_Signal);
@@ -75,6 +75,13 @@ void IEngine::Init()
signal(SIGSEGV, IEngine_Signal);
signal(SIGTERM, IEngine_Signal);
#endif
#ifdef __WIN32__
signal(SIGINT, IEngine_Signal);
signal(SIGILL, IEngine_Signal);
signal(SIGFPE, IEngine_Signal);
signal(SIGSEGV, IEngine_Signal);
signal(SIGTERM, IEngine_Signal);
#endif
IFileSystem::InitFilesystem();
px = px_init();
@@ -93,6 +100,8 @@ void IEngine::Init()
IServer::LoadGame("funnygame");
IVideo::CreatePipelines();
IConsole::AddCommand("exec default.cfg;");
IConsole::Execute();

3
engine/gamemode.cpp
View File

@@ -22,7 +22,8 @@ void CGameMode::RoundBegin( void )
if (start->m_bIsRunning == false)
pSelectedStart = start;
};
pSelectedStart->RoundStart(player);
if (pSelectedStart)
pSelectedStart->RoundStart(player);
i++;
}
}

26
engine/input.cpp
View File

@@ -6,7 +6,9 @@
char g_PressedKeys[KEY_NUM_KEYS];
float g_fAxisValues[AXIS_NUM_AXIS];
float g_fAxisModifiers[AXIS_NUM_AXIS];
CUtlString g_bindings[256];
bool g_bController = false;
struct KeyName_t {
const char *szName;
@@ -17,7 +19,22 @@ KeyName_t keys[] = {
{"TAB",KEY_TAB},
{"ENTER",KEY_ENTER},
{"ESCAPE",KEY_ESCAPE},
{"ESC",KEY_ESCAPE},
{"SPACE",KEY_SPACE},
{"F1",KEY_F1},
{"F2",KEY_F2},
{"F3",KEY_F3},
{"F4",KEY_F4},
{"F5",KEY_F5},
{"F6",KEY_F6},
{"F7",KEY_F7},
{"F8",KEY_F8},
{"F9",KEY_F9},
{"F10",KEY_F10},
{"F11",KEY_F11},
{"F12",KEY_F12},
{"A",KEY_A},
{"B",KEY_B},
{"C",KEY_C},
@@ -105,8 +122,14 @@ void IInput::AxisEvent( EInputAxis axis, float fValue )
{
if (axis == AXIS_MOUSE_X || axis == AXIS_MOUSE_Y)
{
g_bController = false;
g_fAxisValues[axis] += fValue*3.09;
}
if (axis == AXIS_CONTROLLER_PITCH || axis == AXIS_CONTROLLER_YAW)
{
g_bController = true;
g_fAxisModifiers[axis] = fValue*3.09;
}
}
//-----------------------------------------------------------------------------
@@ -114,7 +137,8 @@ void IInput::AxisEvent( EInputAxis axis, float fValue )
//-----------------------------------------------------------------------------
void IInput::Frame( void )
{
g_fAxisValues[AXIS_MOUSE_X] += g_fAxisModifiers[AXIS_CONTROLLER_PITCH];
g_fAxisValues[AXIS_MOUSE_Y] += g_fAxisModifiers[AXIS_CONTROLLER_YAW];
}
//-----------------------------------------------------------------------------

179
engine/ml_video.cpp
View File

@@ -1,179 +0,0 @@
#include "Metal/Metal.hpp"
#include "math3d.h"
#include "filesystem.h"
#include "rendering.h"
#include "tier0/lib.h"
#include "tier1/utlvector.h"
#include "tier0/platform.h"
#include "rendering.h"
#include "ml_video.h"
mat4 g_cameraView;
class CMlBuffer: public IBuffer
{
public:
void *Map() override;
void Unmap() override;
MTL::Buffer *m_buffer;
};
void *CMlBuffer::Map()
{
return m_buffer->contents();
}
void CMlBuffer::Unmap()
{
}
IStorageBuffer *IRenderer::CreateStorageBuffer( uint32_t uSize )
{
CMlBuffer *pBuffer = new CMlBuffer;
pBuffer->m_buffer = g_mlDevice->newBuffer(uSize, MTL::ResourceStorageModeShared);
return pBuffer;
}
IUniformBuffer *IRenderer::CreateUniformBuffer( uint32_t uSize )
{
CMlBuffer *pBuffer = new CMlBuffer;
pBuffer->m_buffer = g_mlDevice->newBuffer(uSize, MTL::ResourceStorageModeShared);
return pBuffer;
}
IVertexBuffer *IRenderer::CreateVertexBuffer( uint32_t uSize )
{
CMlBuffer *pBuffer = new CMlBuffer;
pBuffer->m_buffer = g_mlDevice->newBuffer(uSize, MTL::ResourceStorageModeShared);
return pBuffer;
}
IIndexBuffer *IRenderer::CreateIndexBuffer( uint32_t uSize )
{
CMlBuffer *pBuffer = new CMlBuffer;
pBuffer->m_buffer = g_mlDevice->newBuffer(uSize, MTL::ResourceStorageModeShared);
return pBuffer;
}
IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples )
{
};
void IRenderer::DestroyBuffer( IBuffer *pBuffer )
{
}
void IRenderer::DestroyImage( IImage *pImage )
{
}
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 )
{
}
void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth )
{
}
void IRenderer::ResetState()
{
}
void IRenderer::SetDepthMode( EDepthMode mode )
{
}
void IRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
{
}
void IRenderer::End()
{
}
IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
CUtlVector<Shader_t> shaders,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize,
uint32_t nVertexSize,
CUtlVector<VertexAttribute_t> vertexFormat,
CUtlVector<EImageFormat> outputFormats
)
{
};
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});
}

19
engine/ml_video.h
View File

@@ -1,12 +1,31 @@
#ifndef ML_VIDEO_H
#define ML_VIDEO_H
#include "tier0/platform.h"
#include "Metal/Metal.hpp"
#include "QuartzCore/QuartzCore.hpp"
extern CA::MetalLayer *g_mlLayer;
extern MTL::Device *g_mlDevice;
extern MTL::CommandQueue *g_mlCommandQueue;
extern MTL::CommandBuffer *g_mlCommandBuffer;
extern NS::AutoreleasePool *g_mlPool;
extern char g_bConfigNotify;
extern uint32_t g_nWindowWidth;
extern uint32_t g_nWindowHeight;
extern CUtlVector<MTL::Texture*> g_destroyImageBuffer;
extern CUtlVector<MTL::Buffer*> g_destroyBuffersBuffer;
extern MTL::Texture *g_mlDrawableTexture;
interface IMetal
{
public:
static void Init();
static void CreatePipelines();
static void Frame();
static void Deinit();
};
#endif

13
engine/ml_video.mm Normal file
View File

@@ -0,0 +1,13 @@
#import <QuartzCore/CAMetalLayer.h>
#import <Metal/Metal.h>
namespace CA {
class MetalLayer;
}
void APPLE_ConfigureLayer(CA::MetalLayer* pMetalLayer)
{
if (!pMetalLayer) return;
CAMetalLayer* nsLayer = (__bridge CAMetalLayer*)pMetalLayer;
};

88
engine/ml_videosdl.cpp
View File

@@ -19,6 +19,7 @@
#include "SDL3/SDL_metal.h"
#include "SDL3/SDL_events.h"
#include "tier0/minmax.h"
#include "ml_video.h"
char g_bConfigNotify = 0;
uint32_t g_nWindowWidth = 1280;
@@ -29,7 +30,9 @@ SDL_MetalView g_mlView;
CA::MetalLayer *g_mlLayer;
MTL::Device *g_mlDevice;
MTL::CommandQueue *g_mlCommandQueue;
MTL::CommandBuffer *g_mlCommandBuffer;
NS::AutoreleasePool *g_mlPool;
MTL::Texture *g_mlDrawableTexture;
#if defined(__APPLE__) && defined(__MACH__)
#include "TargetConditionals.h"
@@ -114,7 +117,7 @@ void IVideo_HandleEvents()
SDL_MouseMotionEvent *motion = &event.motion;
switch (event.type)
{
case SDL_EVENT_WINDOW_RESIZED:
case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
g_nWindowWidth = event.window.data1;
g_nWindowHeight = event.window.data2;
g_bConfigNotify = 2;
@@ -132,17 +135,51 @@ void IVideo_HandleEvents()
IInput::AxisEvent(AXIS_MOUSE_X, motion->yrel*0.022);
IInput::AxisEvent(AXIS_MOUSE_Y, -motion->xrel*0.022);
break;
case SDL_EVENT_GAMEPAD_AXIS_MOTION:
{
SDL_GamepadAxis axis = (SDL_GamepadAxis)event.gaxis.axis;
float value = event.gaxis.value / 32768.0f;
if (abs(event.gaxis.value)<1000)
value = 0;
SDL_JoystickID id = event.gaxis.which;
if (axis == SDL_GAMEPAD_AXIS_RIGHTY)
{
IInput::AxisEvent(AXIS_CONTROLLER_PITCH, value);
}
if (axis == SDL_GAMEPAD_AXIS_RIGHTX)
{
IInput::AxisEvent(AXIS_CONTROLLER_YAW, -value);
}
}
break;
case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
break;
case SDL_EVENT_GAMEPAD_BUTTON_UP:
break;
}
};
};
void APPLE_ConfigureLayer(CA::MetalLayer* pMetalLayer);
void IVideo::Init()
{
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
g_window = SDL_CreateWindow("rtt", 1280, 720, SDL_WINDOW_METAL);
SDL_SetHint(SDL_HINT_RENDER_VSYNC, "0");
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_GAMEPAD);
g_window = SDL_CreateWindow("rtt", 1280, 720, SDL_WINDOW_METAL | SDL_WINDOW_HIGH_PIXEL_DENSITY);
int nNumGamepads = 0;
SDL_JoystickID *pGamepads = SDL_GetGamepads(&nNumGamepads);
for ( uint32_t i = 0; i < nNumGamepads; i++ )
{
SDL_OpenGamepad(pGamepads[i]);
}
g_mlView = SDL_Metal_CreateView(g_window);
g_mlLayer = (CA::MetalLayer*)SDL_Metal_GetLayer(g_mlView);
g_mlDevice = MTL::CreateSystemDefaultDevice();
g_mlLayer->setDevice(g_mlDevice);
@@ -151,34 +188,42 @@ void IVideo::Init()
g_mlCommandQueue = g_mlDevice->newCommandQueue();
g_mlLayer->setDrawableSize(CGSizeMake(1280, 720));
g_mlLayer->setFramebufferOnly(false);
IMetal::Init();
}
}
void IVideo::Frame( float fDelta )
{
IVideo_HandleEvents();
NS::AutoreleasePool *pool = NS::AutoreleasePool::alloc()->init();
int w, h;
SDL_GetWindowSizeInPixels(g_window, &w, &h);
g_mlLayer->setDrawableSize(CGSizeMake(w, h));
g_mlLayer->setDrawableSize(CGSizeMake(g_nWindowWidth, g_nWindowHeight));
CA::MetalDrawable *drawable = g_mlLayer->nextDrawable();
if (!drawable)
return;
g_mlDrawableTexture = drawable->texture();
MTL::CommandBuffer *commandBuffer = g_mlCommandQueue->commandBuffer();
MTL::RenderPassDescriptor *renderPass = MTL::RenderPassDescriptor::alloc()->init();
renderPass->colorAttachments()->object(0)->setTexture(drawable->texture());
renderPass->colorAttachments()->object(0)->setLoadAction(MTL::LoadActionClear);
renderPass->colorAttachments()->object(0)->setStoreAction(MTL::StoreActionStore);
renderPass->colorAttachments()->object(0)->setClearColor(MTL::ClearColor(0.0, 0, 1.0, 1.0));
MTL::RenderCommandEncoder *renderEncoder = commandBuffer->renderCommandEncoder(renderPass);
renderEncoder->endEncoding();
commandBuffer->presentDrawable(drawable);
commandBuffer->commit();
g_mlCommandBuffer = g_mlCommandQueue->commandBuffer();
IMetal::Frame();
g_mlCommandBuffer->presentDrawable(drawable);
g_mlCommandBuffer->commit();
g_mlCommandBuffer->waitUntilCompleted();
for (auto &image: g_destroyImageBuffer)
{
image->release();
}
for (auto &buffer: g_destroyBuffersBuffer)
{
buffer->release();
}
g_destroyImageBuffer = {};
g_destroyBuffersBuffer = {};
pool->release();
g_bConfigNotify = 0;
}
void IVideo::Deinit()
@@ -186,3 +231,8 @@ void IVideo::Deinit()
g_mlCommandQueue->release();
g_mlDevice->release();
};
void IVideo::CreatePipelines( )
{
IMetal::CreatePipelines();
}

43
engine/rendering.cpp Normal file
View File

@@ -0,0 +1,43 @@
#include "rendering.h"
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});
}

3
engine/server.cpp
View File

@@ -21,9 +21,6 @@ extern "C" void IGame_Load(void);
void IServer::LoadGame( const char *psz )
{
#ifndef STATIC_BUILD
#ifdef __WIN32__
g_serverdll = Plat_LoadLibrary(CUtlString("%s/bin/server.dll", psz));
#endif
#ifdef __linux__
g_serverdll = Plat_LoadLibrary(CUtlString("%s/bin/libserver.so", psz));
Plat_LoadLibrary(CUtlString("%s/bin/libclient.so", psz));

10
engine/vk_helper.h
View File

@@ -26,7 +26,8 @@ public:
class CVkImage: public IImage
{
public:
vk_image2d_t m_image;
vk_image2d_t m_image = {};
uint32_t m_usage;
};
@@ -64,12 +65,7 @@ extern VkSampler g_invalidTextureSampler;
extern CUtlVector<ITexture*> g_textures;
struct CameraProjection {
mat4 viewprojection;
};
extern vk_buffer_t g_cameraProperties;
extern CameraProjection *g_cameraDataMap;
extern IBuffer *g_cameraProperties;
extern IImage *g_meshDepth;
extern IImage *g_meshDepthMSAA;

481
engine/vk_video.cpp
View File

@@ -7,9 +7,9 @@
#include "rendering.h"
#include "vk_helper.h"
#include "vulkan/vulkan_core.h"
#include "tier0/mem.h"
#define STB_IMAGE_IMPLEMENTATION
#if defined(__APPLE__) && defined(__MACH__)
#include "TargetConditionals.h"
#if TARGET_OS_IPHONE
@@ -27,8 +27,13 @@
#include "vk_video.h"
VkSampler g_invalidTextureSampler;
static CVkImage s_SwapchainImage;
IBuffer *g_cameraProperties;
struct CameraProjection {
mat4 viewprojection;
};
vk_buffer_t g_cameraProperties;
CameraProjection *g_cameraDataMap;
mat4 g_cameraView;
@@ -41,6 +46,15 @@ class CVkGraphicsPipeline: public IGraphicsPipeline
{
public:
vk_tripipeline_t m_pipeline;
uint32_t nVertexSize;
CUtlVector<VkWriteDescriptorSet> m_writes;
VkDescriptorPool m_descriptorPool;
VkDescriptorSet m_descriptorSet;
CUtlVector<ShaderInput_t> m_inputs;
};
class CVkComputePipeline: public IComputePipeline
@@ -148,8 +162,8 @@ void IVulkan::Init()
samplerInfo.maxLod = 0.0f;
vkCreateSampler(g_vkDevice, &samplerInfo, nullptr, &g_invalidTextureSampler);
g_cameraProperties.Create(sizeof(CameraProjection), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
g_cameraDataMap = (CameraProjection*)g_cameraProperties.Map(0, 64);
g_cameraProperties = IRenderer::CreateUniformBuffer(sizeof(CameraProjection));
g_cameraDataMap = (CameraProjection*)g_cameraProperties->Map();
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);
@@ -181,6 +195,12 @@ void IVulkan::Frame()
glm_rotate(perspective, glm_rad(90), (vec4){0,0,1,0});
glm_mat4_mul(perspective,g_cameraDataMap->viewprojection,g_cameraDataMap->viewprojection);
s_SwapchainImage.m_image.m_image = g_swapchainImage;
s_SwapchainImage.m_image.m_imageView = g_swapchainImageView;
s_SwapchainImage.m_image.m_format = g_swapchainFormat;
s_SwapchainImage.m_usage = IMAGE_USAGE_COLOR_ATTACHMENT;
s_SwapchainImage.format = IMAGE_FORMAT_R8G8B8A8;
if (g_bConfigNotify)
{
IRenderer::DestroyImage(g_meshDepth);
@@ -195,24 +215,82 @@ void IVulkan::Frame()
for (auto &step: g_StepPrepass)
step.pPipeline->Frame(0);
IRenderer::Barrier(BARRIER_STAGE_TOP, BARRIER_STAGE_COLOR_OUTPUT, {}, {
{
.in = BARRIER_MEMORY_PERMISSIONS_NONE,
.out = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
.pImage = g_meshColor,
},
{
.in = BARRIER_MEMORY_PERMISSIONS_NONE,
.out = BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE,
.pImage = g_meshDepth,
},
}
);
IRenderer::Begin(g_nWindowWidth, g_nWindowHeight,
{
{
0,
g_meshColor,
g_meshColorMSAA,
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_LOAD_MODE_CLEAR,
ATTACHMENT_STORE_MODE_STORE,
}
},
{
0,
g_meshDepth,
g_meshDepthMSAA,
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_LOAD_MODE_CLEAR,
ATTACHMENT_STORE_MODE_STORE,
});
for (auto &step: g_StepMeshRendering)
{
step.pPipeline->Frame(0);
}
IRenderer::End();
IRenderer::Barrier(BARRIER_STAGE_COLOR_OUTPUT, BARRIER_STAGE_BOTTOM, {}, {
{
.in = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
.out = BARRIER_MEMORY_PERMISSIONS_COPY_READ,
.pImage = g_meshColor,
},
{
.in = BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE,
.out = BARRIER_MEMORY_PERMISSIONS_NONE,
.pImage = g_meshDepth,
},
{
.in = BARRIER_MEMORY_PERMISSIONS_NONE,
.out = BARRIER_MEMORY_PERMISSIONS_COPY_WRITE,
.pImage = IRenderer::GetOutputImage(),
}
}
);
VkImageCopy imageCopyRegion = {};
imageCopyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageCopyRegion.srcSubresource.mipLevel = 0;
imageCopyRegion.srcSubresource.baseArrayLayer = 0;
imageCopyRegion.srcSubresource.layerCount = 1;
imageCopyRegion.srcOffset = {0, 0, 0};
imageCopyRegion.dstSubresource = imageCopyRegion.srcSubresource;
imageCopyRegion.dstOffset = {0, 0, 0};
imageCopyRegion.extent.width = g_nWindowWidth;
imageCopyRegion.extent.height = g_nWindowHeight;
imageCopyRegion.extent.depth = 1;
vkCmdCopyImage(
g_vkCommandBuffer,
((CVkImage*)g_meshColor)->m_image.m_image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
g_swapchainImage,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imageCopyRegion
);
for (auto &step: g_StepShading)
step.pPipeline->Frame(0);
for (auto &step: g_StepPostProcessing)
@@ -289,11 +367,8 @@ void vk_tripipeline_t::Create(
vkCreatePipelineLayout(g_vkDevice, &pipelineLayoutCreateInfo, NULL, &m_layout);
VkDynamicState dynamicStates[] = {
/* pVertexInputState */
VK_DYNAMIC_STATE_VERTEX_INPUT_EXT,
/* pInputAssemblyState */
VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,
VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
/* pViewportState */
VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
@@ -318,12 +393,6 @@ void vk_tripipeline_t::Create(
VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE,
VK_DYNAMIC_STATE_STENCIL_OP,
VK_DYNAMIC_STATE_DEPTH_BOUNDS,
/* pColorBlendState */
VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
VK_DYNAMIC_STATE_BLEND_CONSTANTS,
};
VkVertexInputBindingDescription vibd = {
@@ -340,8 +409,8 @@ void vk_tripipeline_t::Create(
CUtlVector<VkVertexInputAttributeDescription> viad(vertexFormat.GetSize());
for ( uint32_t i = 0; i < viad.GetSize(); i++ )
{
viad[i].location = 0;
viad[i].binding = vertexFormat[i].binding;
viad[i].location = vertexFormat[i].binding;
viad[i].binding = 0;
viad[i].format = IRenderer_VertexToVk(vertexFormat[i].format);
viad[i].offset = vertexFormat[i].offset;
}
@@ -350,7 +419,8 @@ void vk_tripipeline_t::Create(
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.vertexBindingDescriptionCount = 1,
.pVertexBindingDescriptions = &vibd,
.vertexAttributeDescriptionCount = (uint32_t)vertexFormat.GetSize(),
.vertexAttributeDescriptionCount = (uint32_t)viad.GetSize(),
.pVertexAttributeDescriptions = viad.GetData()
};
VkPipelineInputAssemblyStateCreateInfo piasci = {
@@ -358,7 +428,16 @@ void vk_tripipeline_t::Create(
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_TRUE,
};
VkPipelineColorBlendAttachmentState pcbas = {
.blendEnable = VK_FALSE,
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
};
VkPipelineColorBlendStateCreateInfo pcbsci = {};
pcbsci.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
pcbsci.logicOpEnable = VK_FALSE;
pcbsci.attachmentCount = 1;
pcbsci.pAttachments = &pcbas;
VkPipelineRenderingCreateInfo prci = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
@@ -372,8 +451,9 @@ void vk_tripipeline_t::Create(
graphicsPipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
graphicsPipelineCreateInfo.pVertexInputState = &pvisci;
graphicsPipelineCreateInfo.pInputAssemblyState = &piasci;
graphicsPipelineCreateInfo.layout = m_layout;
graphicsPipelineCreateInfo.pColorBlendState = &pcbsci;
graphicsPipelineCreateInfo.pDynamicState = &pipelineDynamicStateCreateInfo;
graphicsPipelineCreateInfo.layout = m_layout;
graphicsPipelineCreateInfo.stageCount = shaders.GetSize();
CUtlVector<VkPipelineShaderStageCreateInfo> stages(graphicsPipelineCreateInfo.stageCount);
uint32_t i = 0;
@@ -544,6 +624,18 @@ void CVkBuffer::Unmap()
CUtlVector<ITexture*> g_textures;
CUtlVector<ITexture*> g_newtextures;
uint32_t ITextureManager::GetTextureID(ITexture *pTexture)
{
uint32_t i = 0;
for (auto &t: g_textures)
{
if (pTexture == t)
return i;
i++;
}
return 0;
}
ITexture *ITextureManager::LoadTexture( void *pData, uint32_t X, uint32_t Y, uint32_t numChannels )
{
CVkTexture *pTexture = new CVkTexture;
@@ -614,13 +706,13 @@ ITexture *ITextureManager::LoadTexture( void *pData, uint32_t X, uint32_t Y, uin
region.imageOffset = {0, 0, 0};
region.imageExtent = {(uint32_t)X, (uint32_t)Y, 1};
vkCmdCopyBufferToImage(
commandBuffer,
gpu_buffer.m_buffer,
pTexture->image.m_image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&region
);
commandBuffer,
gpu_buffer.m_buffer,
pTexture->image.m_image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&region
);
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
@@ -666,7 +758,6 @@ ITexture *ITextureManager::LoadTexture( const char *szName )
FileHandle_t file = IFileSystem::Open(szName, IFILE_READ);
if (!file)
Plat_FatalErrorFunc("Failed to load %s\n", szName);
V_printf("cool %s\n",szName);
CUtlBuffer<stbi_uc> buffer(IFileSystem::Size(file));
IFileSystem::Read(file, buffer.GetMemory(), buffer.GetSize());
@@ -713,7 +804,7 @@ IIndexBuffer *IRenderer::CreateIndexBuffer( uint32_t uSize )
IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples )
{
VkFormat vkformat;
VkImageUsageFlags vkusage;
VkImageUsageFlags vkusage = 0;
CVkImage *pImage = new CVkImage();
VkSampleCountFlagBits samples;
switch (format)
@@ -727,6 +818,8 @@ IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nW
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;
vkusage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
vkusage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
switch (nSamples)
{
@@ -734,6 +827,9 @@ IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nW
case 4: samples = VK_SAMPLE_COUNT_4_BIT; break;
default: samples = VK_SAMPLE_COUNT_1_BIT; break;
}
pImage->m_usage = usage;
pImage->m_image = {};
pImage->format = format;
pImage->m_image.Create(nWidth, nHeight, vkformat, vkusage, samples);
return pImage;
};
@@ -751,21 +847,157 @@ void IRenderer::DestroyImage( IImage *pImage )
pVkImage->m_image.Destroy();
}
IPipeline *g_pCurrentPipeline;
void IRenderer::SetConstants( uint32_t nSize, uint32_t nOffset, void *pData )
void IRenderer::SetConstants( uint32_t nSize, void *pData )
{
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
vkCmdPushConstants(g_vkCommandBuffer, pVkPipeline->m_pipeline.m_layout, VK_SHADER_STAGE_ALL, 0, nSize, pData);
}
}
void IRenderer::Barrier( EBarrierStage stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
void IRenderer::Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
{
VkPipelineStageFlags psfSrc = 0;
VkPipelineStageFlags psfDst = 0;
if (stageIn & BARRIER_STAGE_TOP) psfSrc |= VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
if (stageIn & BARRIER_STAGE_VERTEX_INPUT) psfSrc |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
if (stageIn & BARRIER_STAGE_VERTEX_SHADER) psfSrc |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
if (stageIn & BARRIER_STAGE_GEOMETRY_SHADER) psfSrc |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
if (stageIn & BARRIER_STAGE_FRAGMENT_SHADER) psfSrc |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
if (stageIn & BARRIER_STAGE_COLOR_OUTPUT) psfSrc |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
if (stageIn & BARRIER_STAGE_RAY_TRACING_SHADER) psfSrc |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
if (stageIn & BARRIER_STAGE_BOTTOM) psfSrc |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
if (stageOut & BARRIER_STAGE_TOP) psfDst |= VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
if (stageOut & BARRIER_STAGE_VERTEX_INPUT) psfDst |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
if (stageOut & BARRIER_STAGE_VERTEX_SHADER) psfDst |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
if (stageOut & BARRIER_STAGE_GEOMETRY_SHADER) psfDst |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
if (stageOut & BARRIER_STAGE_FRAGMENT_SHADER) psfDst |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
if (stageOut & BARRIER_STAGE_COLOR_OUTPUT) psfDst |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
if (stageOut & BARRIER_STAGE_RAY_TRACING_SHADER) psfDst |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
if (stageOut & BARRIER_STAGE_BOTTOM) psfDst |= VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
CUtlVector<VkImageMemoryBarrier> imb = {};
CUtlVector<VkBufferMemoryBarrier> bmb = {};
for (auto &buffer: buffers)
{
CVkBuffer *pVkBuffer = (CVkBuffer*)buffer.pBuffer;
VkBufferMemoryBarrier b = {};
b.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
b.buffer = pVkBuffer->m_buffer.m_buffer;
b.size = pVkBuffer->m_buffer.m_nSize;
b.srcQueueFamilyIndex = g_drawfamily;
b.dstQueueFamilyIndex = g_drawfamily;
switch (buffer.in)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
switch (buffer.out)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
bmb.AppendTail(b);
}
for (auto &image: images)
{
CVkImage *pVkImage = (CVkImage*)image.pImage;
VkImageMemoryBarrier b = {};
b.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
b.image = pVkImage->m_image.m_image;
VkImageSubresourceRange isr = {
.aspectMask = (pVkImage->format == IMAGE_FORMAT_DEPTH) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
};
b.subresourceRange = isr;
if (pVkImage->m_usage == IMAGE_USAGE_COLOR_ATTACHMENT)
{
b.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
b.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
if (pVkImage->m_usage == IMAGE_USAGE_DEPTH_ATTACHMENT)
{
b.oldLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
b.newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
}
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
switch (image.in)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_READ: b.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE: b.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
switch (image.out)
{
case BARRIER_MEMORY_PERMISSIONS_COLOR_READ: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE: b.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_READ: b.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; break;
case BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE: b.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; break;
default:
break;
};
imb.AppendTail(b);
}
vkCmdPipelineBarrier(g_vkCommandBuffer, psfSrc, psfDst, 0, 0, 0, bmb.GetSize(), bmb.GetData(), imb.GetSize(), imb.GetData());
}
void IRenderer::BindData( uint32_t binding, IBuffer *pBuffer, IImage* pImage)
{
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
CVkBuffer* pVkBuffer = (CVkBuffer*)pBuffer;
VkDescriptorBufferInfo dbi;
for (auto &input: pVkPipeline->m_inputs)
{
if (input.binding != binding)
continue;
switch (input.type)
{
case SHADER_INPUT_TYPE_STORAGE_BUFFER:
case SHADER_INPUT_TYPE_UNIFORM_BUFFER:
if (!pBuffer)
Plat_FatalErrorFunc("pBuffer is NULL\n");
if (pVkPipeline->m_writes[binding].pBufferInfo)
V_free((void*)pVkPipeline->m_writes[binding].pBufferInfo);
dbi = {
.buffer = pVkBuffer->m_buffer.m_buffer,
.offset = 0,
.range = pVkBuffer->m_buffer.m_nSize,
};
pVkPipeline->m_writes[binding].pBufferInfo = (VkDescriptorBufferInfo*)V_malloc(sizeof(VkDescriptorBufferInfo));
V_memcpy((void*)pVkPipeline->m_writes[binding].pBufferInfo, &dbi, sizeof(VkDescriptorBufferInfo));
break;
case SHADER_INPUT_TYPE_IMAGE:
break;
case SHADER_INPUT_TYPE_TLAS:
break;
case SHADER_INPUT_TYPE_TEXTURES:
break;
};
}
}
}
@@ -777,8 +1009,45 @@ void IRenderer::BindPipeline( IPipeline *pPipeline )
if (pPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)pPipeline;
vkCmdBindPipeline(g_vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pVkPipeline->m_pipeline.m_pipeline);
}
g_pCurrentPipeline = pPipeline;
}
void IRenderer::PushBindings()
{
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
CUtlVector<VkDescriptorImageInfo> textures;
textures.Reserve(g_textures.GetSize());
for (ITexture *t: g_textures)
{
CVkTexture *texture = (CVkTexture*)t;
VkDescriptorImageInfo image = {};
image.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
image.imageView = texture->image.m_imageView;
image.sampler = g_invalidTextureSampler;
textures.AppendTail(image);
};
for ( int i = 0; i < pVkPipeline->m_inputs.GetSize(); i++ )
{
if (pVkPipeline->m_inputs[i].type == SHADER_INPUT_TYPE_TEXTURES)
{
pVkPipeline->m_writes[i].descriptorCount = textures.GetSize();
pVkPipeline->m_writes[i].pImageInfo = textures.GetData();
}
}
textures[0].sampler = g_invalidTextureSampler;
vkUpdateDescriptorSets(g_vkDevice, pVkPipeline->m_writes.GetSize(), pVkPipeline->m_writes.GetData(), 0, NULL);
vkCmdBindDescriptorSets(g_vkCommandBuffer,VK_PIPELINE_BIND_POINT_GRAPHICS, pVkPipeline->m_pipeline.m_layout, 0, 1, &pVkPipeline->m_descriptorSet, 0, NULL);
}
}
@@ -823,6 +1092,7 @@ void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingCo
}
depthAttachment.loadOp = IRenderer_LoadOpVk(depth.loadMode);
depthAttachment.storeOp = IRenderer_StoreOpVk(depth.storeMode);
depthAttachment.clearValue = (VkClearValue){.depthStencil = {.depth = 1}};
VkRenderingInfo renderInfo = {
.sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
@@ -838,6 +1108,29 @@ void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingCo
void IRenderer::ResetState()
{
vkCmdSetRasterizerDiscardEnable(g_vkCommandBuffer, VK_FALSE);
vkCmdSetDepthBiasEnable(g_vkCommandBuffer, VK_FALSE);
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);
_vkCmdSetPolygonModeEXT(g_vkCommandBuffer, VK_POLYGON_MODE_FILL);
_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);
}
void IRenderer::SetDepthMode( EDepthMode mode )
@@ -847,6 +1140,31 @@ void IRenderer::SetDepthMode( EDepthMode mode )
void IRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
{
CVkBuffer *pVkVertex = (CVkBuffer*)pVertex;
CVkBuffer *pVkIndex = (CVkBuffer*)pIndex;
if (!g_pCurrentPipeline)
return;
if (g_pCurrentPipeline->type == PIPELINE_TYPE_RASTERIZATION)
{
CVkGraphicsPipeline *pVkPipeline = (CVkGraphicsPipeline*)g_pCurrentPipeline;
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(g_vkCommandBuffer, 0, 1, &pVkVertex->m_buffer.m_buffer, &offset);
if (pVkIndex)
{
vkCmdBindIndexBuffer(
g_vkCommandBuffer,
pVkIndex->m_buffer.m_buffer,
0,
VK_INDEX_TYPE_UINT32
);
vkCmdDrawIndexed(g_vkCommandBuffer, pVkIndex->m_buffer.m_nSize/4, 1, 0, 0, 0);
}
else
{
vkCmdDraw(g_vkCommandBuffer, pVkVertex->m_buffer.m_nSize/pVkPipeline->nVertexSize,1,0,0);
}
}
}
@@ -855,15 +1173,14 @@ void IRenderer::End()
vkCmdEndRendering(g_vkCommandBuffer);
}
IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
CUtlVector<Shader_t> shaders,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize,
uint32_t nVertexSize,
CUtlVector<VertexAttribute_t> vertexFormats,
CUtlVector<EImageFormat> outputFormats
CUtlVector<EImageFormat> outputFormats,
bool bDepth
)
{
CVkGraphicsPipeline *pipeline = new CVkGraphicsPipeline;
@@ -884,6 +1201,8 @@ IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
{
vkbindings[i].binding = inputs[i].binding;
vkbindings[i].descriptorCount = 1;
vkbindings[i].stageFlags = VK_SHADER_STAGE_ALL;
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;
@@ -898,50 +1217,66 @@ IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
{
vkformats[i] = IRenderer_FormatToVk(outputFormats[i]);
}
pipeline->m_pipeline.Create(vkshaders, vkbindings, nConstantsSize, nVertexSize, vertexFormats, vkformats);
pipeline->nVertexSize = nVertexSize;
CUtlVector<VkDescriptorPoolSize> pools = {};
for (auto &binding: vkbindings)
{
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, &pipeline->m_descriptorPool);
VkDescriptorSetAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = pipeline->m_descriptorPool;
allocInfo.descriptorSetCount = 1;
allocInfo.pSetLayouts = &pipeline->m_pipeline.m_descriptorSetLayout;
vkAllocateDescriptorSets(g_vkDevice, &allocInfo, &pipeline->m_descriptorSet);
pipeline->m_writes = {};
for (auto &input: inputs)
{
VkWriteDescriptorSet write = {};
write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
write.dstSet = pipeline->m_descriptorSet;
write.dstArrayElement = 0;
write.dstBinding = input.binding;
write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
if (input.type == SHADER_INPUT_TYPE_IMAGE) write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
if (input.type == SHADER_INPUT_TYPE_UNIFORM_BUFFER) write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
if (input.type == SHADER_INPUT_TYPE_STORAGE_BUFFER) write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
if (input.type == SHADER_INPUT_TYPE_TLAS) write.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
if (input.type == SHADER_INPUT_TYPE_TEXTURES)
{
write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
write.descriptorCount = 1024;
} else
write.descriptorCount = 1;
pipeline->m_writes.AppendTail(write);
}
pipeline->m_inputs = inputs;
return pipeline;
};
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()
IBuffer *IRenderer::GetCameraMatrix()
{
return g_cameraProperties;
}
CRenderingStep::CRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
IImage *IRenderer::GetOutputImage()
{
}
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});
return &s_SwapchainImage;
}

67
engine/vk_videosdl.cpp
View File

@@ -1,3 +1,5 @@
#include "SDL3/SDL_gamepad.h"
#include "SDL3/SDL_joystick.h"
#include "rendering.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"
@@ -101,7 +103,7 @@ void IVideo_SwapchainInit()
swapchainCreateInfo.imageFormat = selectedFormat.format;
swapchainCreateInfo.imageColorSpace = selectedFormat.colorSpace;
swapchainCreateInfo.presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
swapchainCreateInfo.preTransform = surfaceCapatibilities.currentTransform;
swapchainCreateInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapchainCreateInfo.imageArrayLayers = 1;
@@ -232,9 +234,16 @@ EInputKey ISDL_KeyName(SDL_Keycode key)
void IVideo::Init()
{
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_GAMEPAD);
g_window = SDL_CreateWindow("rtt", 1280, 720, SDL_WINDOW_VULKAN);
int nNumGamepads = 0;
SDL_JoystickID *pGamepads = SDL_GetGamepads(&nNumGamepads);
for ( uint32_t i = 0; i < nNumGamepads; i++ )
{
SDL_OpenGamepad(pGamepads[i]);
}
unsigned int nExtensionCount = 0;
const char* const* szExtensions = SDL_Vulkan_GetInstanceExtensions(&nExtensionCount);
@@ -306,23 +315,20 @@ void IVideo::Init()
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT pdvidsfe = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
.vertexInputDynamicState = VK_TRUE,
VkPhysicalDeviceShaderObjectFeaturesEXT pdsofe = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT,
.pNext = 0,
.shaderObject = VK_TRUE,
};
VkPhysicalDeviceExtendedDynamicState3FeaturesEXT pdeds3fe = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
.pNext = &pdvidsfe,
.pNext = &pdsofe,
.extendedDynamicState3DepthClampEnable = VK_TRUE,
.extendedDynamicState3PolygonMode = VK_TRUE,
.extendedDynamicState3RasterizationSamples = VK_TRUE,
.extendedDynamicState3SampleMask = VK_TRUE,
.extendedDynamicState3AlphaToCoverageEnable = VK_TRUE,
.extendedDynamicState3LogicOpEnable = VK_TRUE,
.extendedDynamicState3ColorBlendEnable = VK_TRUE,
.extendedDynamicState3ColorBlendEquation = VK_TRUE,
.extendedDynamicState3ColorWriteMask = VK_TRUE,
};
VkPhysicalDeviceVulkan13Features pdv13f = {
@@ -344,7 +350,6 @@ void IVideo::Init()
const char *szEnabledGPUExtensions[] = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME,
VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME,
};
VkDeviceCreateInfo deviceCreateInfo = {};
@@ -395,6 +400,8 @@ void IInput::SetMouseMode( EMouseMode mode )
}
}
ConVar m_pitch("m_pitch", "0.022", FCVAR_ARCHIVE);
ConVar m_yaw("m_yaw", "0.022", FCVAR_ARCHIVE);
void IVideo_HandleEvents()
{
SDL_Event event;
@@ -419,8 +426,30 @@ void IVideo_HandleEvents()
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);
IInput::AxisEvent(AXIS_MOUSE_X, motion->yrel*m_pitch.GetFloat());
IInput::AxisEvent(AXIS_MOUSE_Y, -motion->xrel*m_yaw.GetFloat());
break;
case SDL_EVENT_GAMEPAD_AXIS_MOTION:
{
SDL_GamepadAxis axis = (SDL_GamepadAxis)event.gaxis.axis;
float value = event.gaxis.value / 32768.0f;
if (abs(event.gaxis.value)<1000)
value = 0;
SDL_JoystickID id = event.gaxis.which;
if (axis == SDL_GAMEPAD_AXIS_RIGHTY)
{
IInput::AxisEvent(AXIS_CONTROLLER_PITCH, value);
}
if (axis == SDL_GAMEPAD_AXIS_RIGHTX)
{
IInput::AxisEvent(AXIS_CONTROLLER_YAW, -value);
}
}
break;
case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
break;
case SDL_EVENT_GAMEPAD_BUTTON_UP:
break;
}
};
@@ -464,16 +493,6 @@ void IVideo::Frame( float fDelta )
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
vkBeginCommandBuffer(g_vkCommandBuffer, &beginInfo);
IVulkan::Frame();
VkClearColorValue clear = {
.float32 = {
1,1,0,1
}
};
VkImageSubresourceRange range = {
.levelCount = 1,
.layerCount = 1,
};
vkCmdClearColorImage(g_vkCommandBuffer, g_swapchainImage, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &clear, 1, &range);
vkEndCommandBuffer(g_vkCommandBuffer);
VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};