nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-23 20:32:43 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/vk/vkrenderer.h
Spoike 3250de5851 Fix csqc polygon issue (using explicit glsl that doesn't need normals). 
Added gl_texture_lodbias cvar for the luls.
Fix some serious-but-situational traceline issues.



git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5402 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-02-19 06:49:03 +00:00

530 lines
17 KiB
C
Raw Blame History

//#include "glquake.h"
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#define VK_USE_PLATFORM_WIN32_KHR
#define VKInstWin32Funcs VKFunc(CreateWin32SurfaceKHR)
#elif defined(ANDROID)
#define VK_USE_PLATFORM_ANDROID_KHR
#define VKInstXLibFuncs VKFunc(CreateAndroidSurfaceKHR)
#elif defined(__linux__)
#ifndef NO_X11
#define VK_USE_PLATFORM_XLIB_KHR
#define VKInstXLibFuncs VKFunc(CreateXlibSurfaceKHR)
#define VK_USE_PLATFORM_XCB_KHR
#define VKInstXCBFuncs VKFunc(CreateXcbSurfaceKHR)
#endif
#ifdef WAYLANDQUAKE
#define VK_USE_PLATFORM_WAYLAND_KHR
#define VKInstWaylandFuncs VKFunc(CreateWaylandSurfaceKHR)
#endif
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
#define VK_USE_PLATFORM_XLIB_KHR
#define VKInstXLibFuncs VKFunc(CreateXlibSurfaceKHR)
#define VK_USE_PLATFORM_XCB_KHR
#define VKInstXCBFuncs VKFunc(CreateXcbSurfaceKHR)
#endif
#define VK_NO_PROTOTYPES
#include <../vulkan/vulkan.h>
#if defined(_MSC_VER) && !defined(UINT64_MAX)
#define UINT64_MAX _UI64_MAX
#ifndef _UI64_MAX
#define _UI64_MAX 0xffffffffffffffffui64
#endif
#endif
#ifndef VKInstWin32Funcs
#define VKInstWin32Funcs
#endif
#ifndef VKInstXLibFuncs
#define VKInstXLibFuncs
#endif
#ifndef VKInstXCBFuncs
#define VKInstXCBFuncs
#endif
#ifndef VKInstWaylandFuncs
#define VKInstWaylandFuncs
#endif
#define VKInstArchFuncs VKInstWin32Funcs VKInstXLibFuncs VKInstXCBFuncs VKInstWaylandFuncs
#ifdef VK_EXT_debug_utils
#define VKDebugFuncs \
VKFunc(SetDebugUtilsObjectNameEXT)
#else
#define VKDebugFuncs
#endif
//funcs needed for creating an instance
#define VKInstFuncs \
VKFunc(EnumerateInstanceLayerProperties) \
VKFunc(EnumerateInstanceExtensionProperties) \
VKFunc(CreateInstance)
//funcs specific to an instance
#define VKInst2Funcs \
VKFunc(EnumeratePhysicalDevices) \
VKFunc(EnumerateDeviceExtensionProperties) \
VKFunc(GetPhysicalDeviceProperties) \
VKFunc(GetPhysicalDeviceQueueFamilyProperties) \
VKFunc(GetPhysicalDeviceSurfaceSupportKHR) \
VKFunc(GetPhysicalDeviceSurfaceFormatsKHR) \
VKFunc(GetPhysicalDeviceSurfacePresentModesKHR) \
VKFunc(GetPhysicalDeviceSurfaceCapabilitiesKHR) \
VKFunc(GetPhysicalDeviceMemoryProperties) \
VKFunc(GetPhysicalDeviceFormatProperties) \
VKFunc(GetPhysicalDeviceFeatures) \
VKFunc(DestroySurfaceKHR) \
VKFunc(CreateDevice) \
VKFunc(DestroyInstance) \
VKDebugFuncs \
VKInstArchFuncs
//funcs specific to a device
#define VKDevFuncs \
VKFunc(AcquireNextImageKHR) \
VKFunc(QueuePresentKHR) \
VKFunc(CreateSwapchainKHR) \
VKFunc(GetSwapchainImagesKHR) \
VKFunc(DestroySwapchainKHR) \
VKFunc(CmdBeginRenderPass) \
VKFunc(CmdEndRenderPass) \
VKFunc(CmdBindPipeline) \
VKFunc(CmdDrawIndexedIndirect) \
VKFunc(CmdDraw) \
VKFunc(CmdDrawIndexed) \
VKFunc(CmdSetViewport) \
VKFunc(CmdSetScissor) \
VKFunc(CmdBindDescriptorSets) \
VKFunc(CmdBindIndexBuffer) \
VKFunc(CmdBindVertexBuffers) \
VKFunc(CmdPushConstants) \
VKFunc(CmdPushDescriptorSetKHR) \
VKFunc(CmdClearAttachments) \
VKFunc(CmdClearColorImage) \
VKFunc(CmdClearDepthStencilImage) \
VKFunc(CmdCopyImage) \
VKFunc(CmdCopyBuffer) \
VKFunc(CmdCopyImageToBuffer) \
VKFunc(CmdCopyBufferToImage) \
VKFunc(CmdBlitImage) \
VKFunc(CmdPipelineBarrier) \
VKFunc(CmdSetEvent) \
VKFunc(CmdResetEvent) \
VKFunc(CmdWaitEvents) \
VKFunc(CreateDescriptorSetLayout) \
VKFunc(DestroyDescriptorSetLayout) \
VKFunc(CreatePipelineLayout) \
VKFunc(DestroyPipelineLayout) \
VKFunc(CreateShaderModule) \
VKFunc(DestroyShaderModule) \
VKFunc(CreateGraphicsPipelines) \
VKFunc(DestroyPipeline) \
VKFunc(CreatePipelineCache) \
VKFunc(GetPipelineCacheData) \
VKFunc(DestroyPipelineCache) \
VKFunc(QueueSubmit) \
VKFunc(QueueWaitIdle) \
VKFunc(DeviceWaitIdle) \
VKFunc(BeginCommandBuffer) \
VKFunc(ResetCommandBuffer) \
VKFunc(EndCommandBuffer) \
VKFunc(DestroyDevice) \
VKFunc(GetDeviceQueue) \
VKFunc(GetBufferMemoryRequirements) \
VKFunc(GetImageMemoryRequirements) \
VKFunc(GetImageMemoryRequirements2KHR) \
VKFunc(GetImageSubresourceLayout) \
VKFunc(CreateFramebuffer) \
VKFunc(DestroyFramebuffer) \
VKFunc(CreateCommandPool) \
VKFunc(ResetCommandPool) \
VKFunc(DestroyCommandPool) \
VKFunc(CreateDescriptorPool) \
VKFunc(ResetDescriptorPool) \
VKFunc(DestroyDescriptorPool) \
VKFunc(AllocateDescriptorSets) \
VKFunc(CreateSampler) \
VKFunc(DestroySampler) \
VKFunc(CreateImage) \
VKFunc(DestroyImage) \
VKFunc(CreateBuffer) \
VKFunc(DestroyBuffer) \
VKFunc(AllocateMemory) \
VKFunc(FreeMemory) \
VKFunc(BindBufferMemory) \
VKFunc(BindImageMemory) \
VKFunc(MapMemory) \
VKFunc(FlushMappedMemoryRanges) \
VKFunc(UnmapMemory) \
VKFunc(UpdateDescriptorSets) \
VKFunc(AllocateCommandBuffers) \
VKFunc(FreeCommandBuffers) \
VKFunc(CreateRenderPass) \
VKFunc(DestroyRenderPass) \
VKFunc(CreateSemaphore) \
VKFunc(DestroySemaphore) \
VKFunc(CreateFence) \
VKFunc(GetFenceStatus) \
VKFunc(WaitForFences) \
VKFunc(ResetFences) \
VKFunc(DestroyFence) \
VKFunc(CreateImageView) \
VKFunc(DestroyImageView)
//all vulkan funcs
#define VKFuncs \
VKInstFuncs \
VKInst2Funcs \
VKDevFuncs \
VKFunc(GetInstanceProcAddr)\
VKFunc(GetDeviceProcAddr)
#ifdef VK_NO_PROTOTYPES
#define VKFunc(n) extern PFN_vk##n vk##n;
VKFuncs
#undef VKFunc
#else
// #define VKFunc(n) static const PFN_vk##n vk##n = vk##n;
// VKFuncs
// #undef VKFunc
#endif
#define vkallocationcb NULL
#ifdef _DEBUG
#define VkAssert(f) do {VkResult err = f; if (err) Sys_Error("%s == %s", #f, VK_VKErrorToString(err)); } while(0)
#define VkWarnAssert(f) do {VkResult err = f; if (err) Con_Printf("%s == %s\n", #f, VK_VKErrorToString(err)); } while(0)
#else
#define VkAssert(f) f
#define VkWarnAssert(f) f
#endif
typedef struct
{
struct vk_mempool_s *pool;
VkDeviceMemory memory;
size_t size;
size_t offset;
} vk_poolmem_t;
typedef struct vk_image_s
{
VkImage image;
vk_poolmem_t mem;
VkImageView view;
VkSampler sampler;
VkImageLayout layout;
uint32_t width;
uint32_t height;
uint32_t layers;
uint32_t mipcount;
uint32_t encoding;
uint32_t type; //PTI_2D/3D/CUBE
} vk_image_t;
enum dynbuf_e
{
DB_VBO,
DB_EBO,
DB_UBO,
DB_STAGING,
DB_MAX
};
struct vk_rendertarg
{
VkCommandBuffer cbuf; //cbuf allocated for this render target.
VkFramebuffer framebuffer;
vk_image_t colour, depth, mscolour;
image_t q_colour, q_depth, q_mscolour; //extra sillyness...
uint32_t width;
uint32_t height;
qboolean multisample;
qboolean depthcleared; //starting a new gameview needs cleared depth relative to other views, but the first probably won't.
VkRenderPassBeginInfo restartinfo;
VkSemaphore presentsemaphore;
qboolean firstuse;
struct vk_rendertarg *prevtarg;
};
struct vk_rendertarg_cube
{
uint32_t size;
image_t q_colour, q_depth; //extra sillyness...
vk_image_t colour, depth;
struct vk_rendertarg face[6];
};
#define VQ_RENDER 0
#define VQ_PRESENT 1
#define VQ_ALTRENDER 2
#define VQ_ALTRENDER_COUNT 16
#define VQ_COUNT 3
extern struct vulkaninfo_s
{
unsigned short triplebuffer;
qboolean vsync;
qboolean allowsubmissionthread;
qboolean khr_swapchain; //aka: not headless. we're actually rendering stuff!
qboolean nv_glsl_shader; //we can load glsl shaders. probably missing lots of reflection info though, so this is probably too limited.
qboolean khr_get_memory_requirements2; //slightly richer info
qboolean khr_dedicated_allocation; //standardised version of the above where the driver decides whether a resource is worth a dedicated allocation.
qboolean khr_push_descriptor; //more efficient descriptor streaming
qboolean amd_rasterization_order; //allows primitives to draw in any order
VkInstance instance;
VkDevice device;
VkPhysicalDevice gpu;
VkSurfaceKHR surface;
uint32_t queuefam[VQ_COUNT];
uint32_t queuenum[VQ_COUNT];
VkQueue queue_render;
VkQueue queue_present;
VkQueue queue_alt[1];
VkPhysicalDeviceMemoryProperties memory_properties;
VkCommandPool cmdpool;
VkPhysicalDeviceLimits limits;
#define ACQUIRELIMIT 8 //don't run more than this many frames behind
VkSemaphore acquiresemaphores[ACQUIRELIMIT];
VkFence acquirefences[ACQUIRELIMIT];
uint32_t acquirebufferidx[ACQUIRELIMIT];
unsigned int aquirenext;
volatile unsigned int aquirelast; //set inside the submission thread
VkPipelineCache pipelinecache;
struct vk_fencework
{
VkFence fence;
struct vk_fencework *next;
void (*Passed) (void*);
VkCommandBuffer cbuf;
} *fencework, *fencework_last; //callback for each fence as its passed. mostly for loading code or freeing memory.
int filtermip[3];
int filterpic[3];
int mipcap[2];
float lodbias;
float max_anistophy;
float max_anistophy_limit;
struct vk_mempool_s
{
struct vk_mempool_s *next;
uint32_t memtype;
VkDeviceMemory memory;
//FIXME: replace with an ordered list of free blocks.
VkDeviceSize gaps;
VkDeviceSize memoryoffset;
VkDeviceSize memorysize;
} *mempools;
struct descpool
{
VkDescriptorPool pool;
int availsets;
int totalsets;
struct descpool *next;
} *descpool;
struct dynbuffer
{
size_t flushed; //size already copied to the gpu
size_t offset; //size written by the cpu (that might not yet be flushed)
size_t size; //maximum buffer size
size_t align;
qboolean stagingcoherent;
VkBuffer stagingbuf;
VkDeviceMemory stagingmemory;
VkBuffer devicebuf;
VkDeviceMemory devicememory;
VkBuffer renderbuf; //either staging or device. this is the buffer that we tell vulkan about
void *ptr;
struct dynbuffer *next;
} *dynbuf[DB_MAX];
struct vk_rendertarg *backbufs;
struct vk_rendertarg *rendertarg;
struct vkframe {
struct vkframe *next;
struct dynbuffer *dynbufs[DB_MAX];
struct descpool *descpools;
VkSemaphore acquiresemaphore;
VkCommandBuffer *cbufs;
size_t numcbufs;
size_t maxcbufs;
VkFence finishedfence;
struct vk_frameend {
struct vk_frameend *next;
void (*FrameEnded) (void*);
} *frameendjobs;
struct vk_rendertarg *backbuf;
} *frame, *unusedframes;
struct vk_frameend *frameendjobs;
uint32_t backbuf_count;
VkRenderPass shadow_renderpass; //clears depth etc.
VkRenderPass renderpass[3]; //reload-both(resume prior renderpass), clear-depth-dontcare-colour(gl_clear==0), clear-both(cl_clear!=0)
VkSwapchainKHR swapchain;
uint32_t bufferidx;
VkSampleCountFlagBits multisamplebits;
VkFormat depthformat;
VkFormat backbufformat;
qboolean srgbcapable;
qboolean neednewswapchain; //something changed that invalidates the old one.
qboolean devicelost; //we seriously fucked up somewhere. or the gpu is shite.
struct vkwork_s
{
struct vkwork_s *next;
VkQueue queue;
VkCommandBuffer cmdbuf;
VkSemaphore semwait;
VkPipelineStageFlags semwaitstagemask;
VkSemaphore semsignal;
VkFence fencesignal;
struct vk_fencework *fencedwork;
struct vkframe *present;
} *work;
void *submitthread;
void *submitcondition;
void (*dopresent)(struct vkframe *theframe);
texid_t sourcecolour;
texid_t sourcedepth;
shader_t *scenepp_waterwarp;
shader_t *scenepp_antialias;
shader_t *scenepp_rescale;
} vk;
struct pipeline_s
{
struct pipeline_s *next;
unsigned int permu:16; //matches the permutation (masked by permutations that are supposed to be supported)
unsigned int flags:16; //matches the shader flags (cull etc)
unsigned int blendbits; //matches blend state.
VkPipeline pipeline;
};
uint32_t vk_find_memory_try(uint32_t typeBits, VkFlags requirements_mask);
uint32_t vk_find_memory_require(uint32_t typeBits, VkFlags requirements_mask);
void VK_DoPresent(struct vkframe *theframe);
qboolean VK_Init(rendererstate_t *info, const char **sysextname, qboolean (*createSurface)(void), void (*dopresent)(struct vkframe *theframe));
void VK_Shutdown(void);
void VK_R_BloomBlend (texid_t source, int x, int y, int w, int h);
void VK_R_BloomShutdown(void);
qboolean R_CanBloom(void);
struct programshared_s;
struct programpermu_s;
qboolean VK_LoadGLSL(struct programshared_s *prog, struct programpermu_s *permu, int ver, const char **precompilerconstants, const char *vert, const char *tcs, const char *tes, const char *geom, const char *frag, qboolean noerrors, vfsfile_t *blobfile);
VkCommandBuffer VK_AllocFrameCBuf(void);
void VK_Submit_Work(VkCommandBuffer cmdbuf, VkSemaphore semwait, VkPipelineStageFlags semwaitstagemask, VkSemaphore semsignal, VkFence fencesignal, struct vkframe *presentframe, struct vk_fencework *fencedwork);
void VKBE_Init(void);
void VKBE_InitFramePools(struct vkframe *frame);
void VKBE_RestartFrame(void);
void VKBE_FlushDynamicBuffers(void);
void VKBE_Set2D(qboolean twodee);
void VKBE_ShutdownFramePools(struct vkframe *frame);
void VKBE_Shutdown(void);
void VKBE_SelectMode(backendmode_t mode);
void VKBE_DrawMesh_List(shader_t *shader, int nummeshes, mesh_t **mesh, vbo_t *vbo, texnums_t *texnums, unsigned int beflags);
void VKBE_DrawMesh_Single(shader_t *shader, mesh_t *meshchain, vbo_t *vbo, unsigned int beflags);
void VKBE_SubmitBatch(batch_t *batch);
batch_t *VKBE_GetTempBatch(void);
void VKBE_GenBrushModelVBO(model_t *mod);
void VKBE_ClearVBO(vbo_t *vbo, qboolean dataonly);
void VKBE_UploadAllLightmaps(void);
void VKBE_DrawWorld (batch_t **worldbatches);
qboolean VKBE_LightCullModel(vec3_t org, model_t *model);
void VKBE_SelectEntity(entity_t *ent);
qboolean VKBE_SelectDLight(dlight_t *dl, vec3_t colour, vec3_t axis[3], unsigned int lmode);
void VKBE_VBO_Begin(vbobctx_t *ctx, size_t maxsize);
void VKBE_VBO_Data(vbobctx_t *ctx, void *data, size_t size, vboarray_t *varray);
void VKBE_VBO_Finish(vbobctx_t *ctx, void *edata, size_t esize, vboarray_t *earray, void **vbomem, void **ebomem);
void VKBE_VBO_Destroy(vboarray_t *vearray, void *mem);
void VKBE_Scissor(srect_t *rect);
void VKBE_BaseEntTextures(void);
struct vk_shadowbuffer;
struct vk_shadowbuffer *VKBE_GenerateShadowBuffer(vecV_t *verts, int numverts, index_t *indicies, int numindicies, qboolean istemp);
void VKBE_DestroyShadowBuffer(struct vk_shadowbuffer *buf);
void VKBE_RenderShadowBuffer(struct vk_shadowbuffer *buf);
void VKBE_SetupForShadowMap(dlight_t *dl, int texwidth, int texheight, float shadowscale);
qboolean VKBE_BeginShadowmap(qboolean isspot, uint32_t width, uint32_t height);
void VKBE_BeginShadowmapFace(void);
void VKBE_DoneShadows(void);
void VKBE_RT_Gen_Cube(struct vk_rendertarg_cube *targ, uint32_t size, qboolean clear);
void VKBE_RT_Gen(struct vk_rendertarg *targ, uint32_t width, uint32_t height, qboolean clear, unsigned int flags);
void VKBE_RT_Begin(struct vk_rendertarg *targ);
void VKBE_RT_End(struct vk_rendertarg *targ);
void VKBE_RT_Destroy(struct vk_rendertarg *targ);
char *VK_VKErrorToString(VkResult err); //helper for converting vulkan error codes to strings, if we get something unexpected.
qboolean VK_AllocatePoolMemory(uint32_t pooltype, VkDeviceSize memsize, VkDeviceSize poolalignment, vk_poolmem_t *mem);
void VK_ReleasePoolMemory(vk_poolmem_t *mem);
qboolean VK_AllocateImageMemory(VkImage image, qboolean dedicated, vk_poolmem_t *mem); //dedicated should normally be TRUE for render targets
qboolean VK_AllocateBindImageMemory(vk_image_t *image, qboolean dedicated); //dedicated should normally be TRUE for render targets
struct stagingbuf
{
VkBuffer buf;
VkBuffer retbuf;
vk_poolmem_t mem;
size_t size;
VkBufferUsageFlags usage;
};
vk_image_t VK_CreateTexture2DArray(uint32_t width, uint32_t height, uint32_t layers, uint32_t mips, uploadfmt_t encoding, unsigned int type, qboolean rendertarget, const char *debugname);
void set_image_layout(VkCommandBuffer cmd, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout, VkAccessFlags srcaccess, VkPipelineStageFlagBits srcstagemask, VkImageLayout new_image_layout, VkAccessFlags dstaccess, VkPipelineStageFlagBits dststagemask);
void VK_CreateSampler(unsigned int flags, vk_image_t *img);
void *VKBE_CreateStagingBuffer(struct stagingbuf *n, size_t size, VkBufferUsageFlags usage);
VkBuffer VKBE_FinishStaging(struct stagingbuf *n, vk_poolmem_t *memptr);
void *VK_FencedBegin(void (*passed)(void *work), size_t worksize);
void VK_FencedSubmit(void *work);
void VK_FencedCheck(void);
void *VK_AtFrameEnd(void (*passed)(void *work), void *data, size_t worksize);
void VK_Draw_Init(void);
void VK_Draw_Shutdown(void);
void VK_UpdateFiltering (image_t *imagelist, int filtermip[3], int filterpic[3], int mipcap[2], float lodbias, float anis);
qboolean VK_LoadTextureMips (texid_t tex, const struct pendingtextureinfo *mips);
void VK_DestroyTexture (texid_t tex);
void VK_DestroyVkTexture (vk_image_t *img);
void VK_R_Init (void);
void VK_R_DeInit (void);
void VK_R_RenderView (void);
char *VKVID_GetRGBInfo (int *bytestride, int *truevidwidth, int *truevidheight, enum uploadfmt *fmt);
qboolean VK_SCR_UpdateScreen (void);
void VKBE_RenderToTextureUpdate2d(qboolean destchanged);
//improved rgb get that calls the callback when the data is actually available. used for video capture.
void VKVID_QueueGetRGBData (void (*gotrgbdata) (void *rgbdata, qintptr_t bytestride, size_t width, size_t height, enum uploadfmt fmt));
Reference in a new issue View git blame Copy permalink