fteqw/engine/vk/vkrenderer.h

//#include "glquake.h"

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#define VK_USE_PLATFORM_WIN32_KHR
#define VKInstWin32Funcs VKFunc(CreateWin32SurfaceKHR)
#endif

#ifdef __linux__
#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
#define VKInstArchFuncs VKInstWin32Funcs VKInstXLibFuncs VKInstXCBFuncs


//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(DestroySurfaceKHR)						\
	VKFunc(CreateDevice)							\
	VKFunc(DestroyInstance)							\
	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(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(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 == %i", #f, err); } while(0)
#define VkWarnAssert(f) do {VkResult err = f; if (err) Con_Printf("%s == %i\n", #f, err); } while(0)
#else
#define VkAssert(f) f
#define VkWarnAssert(f) f
#endif

typedef struct vk_image_s
{
	VkImage image;
	VkDeviceMemory memory;
	VkImageView view;
	VkSampler sampler;
	VkImageLayout layout;

	uint32_t width;
	uint32_t height;
	uint32_t layers;
	uint32_t mipcount;
	uint32_t encoding;
	uint32_t type;
} vk_image_t;
enum dynbuf_e
{
	DB_VBO,
	DB_EBO,
	DB_UBO,
	DB_MAX
};
struct vk_rendertarg
{
	VkFramebuffer framebuffer;
	vk_image_t colour, depth;

	image_t q_colour, q_depth;	//extra sillyness...

	uint32_t width;
	uint32_t height;

	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_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		headless;
	qboolean		allowsubmissionthread;

	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;

#define ACQUIRELIMIT 8
	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 max_anistophy;

	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;
		VkBuffer stagingbuf;
		VkDeviceMemory stagingmemory;
		VkBuffer devicebuf;
		VkDeviceMemory devicememory;
		VkBuffer renderbuf;	//either staging or device.
		void *ptr;

		struct dynbuffer *next;
	} *dynbuf[DB_MAX];
	struct vk_rendertarg *backbufs;
	struct vk_rendertarg *rendertarg;
	struct vkframe {
		struct vkframe *next;
		VkCommandBuffer cbuf;
		struct dynbuffer *dynbufs[DB_MAX];
		struct descpool *descpools;
		VkFence finishedfence;
		struct vk_fencework *frameendjobs;

		struct vk_rendertarg *backbuf;
	} *frame, *unusedframes;
	struct vk_fencework *frameendjobs;
	uint32_t backbuf_count;

	VkRenderPass shadow_renderpass;	//clears depth etc.
	VkRenderPass renderpass[3];	//initial, resume
	VkSwapchainKHR swapchain;
	uint32_t bufferidx;

	VkFormat depthformat;
	VkFormat backbufformat;
	qboolean srgbcapable;

	qboolean neednewswapchain;

	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);

qboolean VK_LoadTextureMips (texid_t tex, struct pendingtextureinfo *mips);
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;
qboolean VK_LoadGLSL(struct programshared_s *prog, const char *name, unsigned int 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);

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);
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, qboolean isspot, 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);
void VKBE_RT_Begin(struct vk_rendertarg *targ);
void VKBE_RT_Destroy(struct vk_rendertarg *targ);


struct stagingbuf
{
	VkBuffer buf;
	VkBuffer retbuf;
	VkDeviceMemory memory;
	size_t size;
	VkBufferUsageFlags usage;
};
vk_image_t VK_CreateTexture2DArray(uint32_t width, uint32_t height, uint32_t layers, uint32_t mips, unsigned int encoding, unsigned int type);
void set_image_layout(VkCommandBuffer cmd, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout, VkAccessFlags srcaccess, VkImageLayout new_image_layout, VkAccessFlags dstaccess);
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, VkDeviceMemory *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), 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 anis);
qboolean VK_LoadTextureMips			(texid_t tex, 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));