fteqw/engine/vk/vk_backend.c

#include "quakedef.h"
#ifdef VKQUAKE
#include "vkrenderer.h"
#include "glquake.h"
#include "gl_draw.h"
#include "shader.h"
#include "renderque.h"

//FIXME: instead of switching rendertargets and back, we should be using an alternative queue.

#define PERMUTATION_BEM_VR (1u<<11)
#define PERMUTATION_BEM_FP16 (1u<<12)
#define PERMUTATION_BEM_MULTISAMPLE (1u<<13)
#define PERMUTATION_BEM_DEPTHONLY (1u<<14)
#define PERMUTATION_BEM_WIREFRAME (1u<<15)

#undef BE_Init
#undef BE_SelectMode
#undef BE_GenBrushModelVBO
#undef BE_ClearVBO
#undef BE_UploadAllLightmaps
#undef BE_LightCullModel
#undef BE_SelectEntity
#undef BE_SelectDLight
#undef BE_GetTempBatch
#undef BE_SubmitBatch
#undef BE_DrawMesh_List
#undef BE_DrawMesh_Single
#undef BE_SubmitMeshes
#undef BE_DrawWorld
#undef BE_VBO_Begin
#undef BE_VBO_Data
#undef BE_VBO_Finish
#undef BE_VBO_Destroy
#undef BE_Scissor

#undef BE_RenderToTextureUpdate2d

extern cvar_t r_shadow_realtime_world_lightmaps;
extern cvar_t gl_overbright;
extern cvar_t r_portalrecursion;

extern cvar_t r_polygonoffset_shadowmap_offset, r_polygonoffset_shadowmap_factor;
extern cvar_t r_wireframe;
extern cvar_t vk_stagingbuffers;

static unsigned int vk_usedynamicstaging;

#ifdef RTLIGHTS
static void VK_TerminateShadowMap(void);
#endif
void VKBE_BeginShadowmapFace(void);

static void R_DrawPortal(batch_t *batch, batch_t **blist, batch_t *depthmasklist[2], int portaltype);

#define MAX_TMUS 32

extern texid_t r_whiteimage, missing_texture_gloss, missing_texture_normal;
extern texid_t r_blackimage, r_blackcubeimage, r_whitecubeimage;

static void BE_RotateForEntity (const entity_t *fte_restrict e, const model_t *fte_restrict mod);
void VKBE_SetupLightCBuffer(dlight_t *l, vec3_t colour);

#ifdef VK_EXT_debug_utils
static void DebugSetName(VkObjectType objtype, uint64_t handle, const char *name)
{
	if (vkSetDebugUtilsObjectNameEXT)
	{
		VkDebugUtilsObjectNameInfoEXT info =
		{
			VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
			NULL,
			objtype,
			handle,
			name?name:"UNNAMED"
		};
		vkSetDebugUtilsObjectNameEXT(vk.device, &info);
	}
}
#else
#define DebugSetName(t,h,n)
#endif

/*========================================== tables for deforms =====================================*/
#define frand() (rand()*(1.0/RAND_MAX))
#define FTABLE_SIZE		1024
#define FTABLE_CLAMP(x)	(((int)((x)*FTABLE_SIZE) & (FTABLE_SIZE-1)))
#define FTABLE_EVALUATE(table,x) (table ? table[FTABLE_CLAMP(x)] : frand()*((x)-floor(x)))
#define R_FastSin(x) r_sintable[FTABLE_CLAMP(x)]

static	float	r_sintable[FTABLE_SIZE];
static	float	r_triangletable[FTABLE_SIZE];
static	float	r_squaretable[FTABLE_SIZE];
static	float	r_sawtoothtable[FTABLE_SIZE];
static	float	r_inversesawtoothtable[FTABLE_SIZE];

static float *FTableForFunc ( unsigned int func )
{
	switch (func)
	{
		case SHADER_FUNC_SIN:
			return r_sintable;

		case SHADER_FUNC_TRIANGLE:
			return r_triangletable;

		case SHADER_FUNC_SQUARE:
			return r_squaretable;

		case SHADER_FUNC_SAWTOOTH:
			return r_sawtoothtable;

		case SHADER_FUNC_INVERSESAWTOOTH:
			return r_inversesawtoothtable;
	}

	//bad values allow us to crash (so I can debug em)
	return NULL;
}

static void FTable_Init(void)
{
	unsigned int i;
	double t;
	for (i = 0; i < FTABLE_SIZE; i++)
	{
		t = (double)i / (double)FTABLE_SIZE;

		r_sintable[i] = sin(t * 2*M_PI);

		if (t < 0.25)
			r_triangletable[i] = t * 4.0;
		else if (t < 0.75)
			r_triangletable[i] = 2 - 4.0 * t;
		else
			r_triangletable[i] = (t - 0.75) * 4.0 - 1.0;

		if (t < 0.5)
			r_squaretable[i] = 1.0f;
		else
			r_squaretable[i] = -1.0f;

		r_sawtoothtable[i] = t;
		r_inversesawtoothtable[i] = 1.0 - t;
	}
}

typedef vec3_t mat3_t[3];
static mat3_t axisDefault={{1, 0, 0},
					{0, 1, 0},
					{0, 0, 1}};

static void Matrix3_Transpose (mat3_t in, mat3_t out)
{
	out[0][0] = in[0][0];
	out[1][1] = in[1][1];
	out[2][2] = in[2][2];

	out[0][1] = in[1][0];
	out[0][2] = in[2][0];
	out[1][0] = in[0][1];
	out[1][2] = in[2][1];
	out[2][0] = in[0][2];
	out[2][1] = in[1][2];
}
static void Matrix3_Multiply_Vec3 (const mat3_t a, const vec3_t b, vec3_t product)
{
	product[0] = a[0][0]*b[0] + a[0][1]*b[1] + a[0][2]*b[2];
	product[1] = a[1][0]*b[0] + a[1][1]*b[1] + a[1][2]*b[2];
	product[2] = a[2][0]*b[0] + a[2][1]*b[1] + a[2][2]*b[2];
}

static int Matrix3_Compare(const mat3_t in, const mat3_t out)
{
	return !memcmp(in, out, sizeof(mat3_t));
}

/*================================================*/

//dlight-specific constant-buffer
typedef struct
{
	float l_cubematrix[16];
	vec3_t l_lightposition; float padl1;
	vec3_t l_colour; float pad2;
	vec3_t l_lightcolourscale; float l_lightradius;
	vec4_t l_shadowmapproj;
	vec2_t l_shadowmapscale; vec2_t pad3;
} vkcbuf_light_t;

//entity-specific constant-buffer
typedef struct
{
	float m_modelviewproj[16];
	float m_model[16];
	float m_modelinv[16];
	vec3_t e_eyepos;
	float e_time;
	vec3_t e_light_ambient; float pad1;
	vec3_t e_light_dir;		float pad2;
	vec3_t e_light_mul;		float pad3;
	vec4_t e_lmscale[4];
	vec3_t e_uppercolour;	float pad4;
	vec3_t e_lowercolour;	float pad5;
	vec3_t e_glowmod;		float pad6;
	vec4_t e_colourident;
	vec4_t w_fogcolours;
	float w_fogdensity;		float w_fogdepthbias;	vec2_t pad7;
} vkcbuf_entity_t;

enum 
{
	VK_BUFF_POS,
	VK_BUFF_TC,
	VK_BUFF_COL,
	VK_BUFF_LMTC,
	VK_BUFF_NORM,
	VK_BUFF_SDIR,
	VK_BUFF_TDIR,
	VK_BUFF_MAX
};

typedef struct
{	//there should be only one copy of this struct for each thread that renders anything in vulkan.

	//descriptor sets are: 0) entity+light 1) batch textures + pass textures
	VkDescriptorSet descriptorsets[1];

	//commandbuffer state, to avoid redundant state changes.
	VkPipeline activepipeline;

	float depthrange;

} vkrendercontext_t;

typedef struct
{
	unsigned int inited;

	backendmode_t mode;
	unsigned int modepermutation;
	unsigned int flags;
	unsigned int forcebeflags;

	float	identitylighting;
	float	identitylightmap;
	float		curtime;
	const entity_t	*curentity;
	const dlight_t	*curdlight;
	shader_t	*curshader;
	shader_t	*depthonly;
	texnums_t	*curtexnums;
	vbo_t *batchvbo;
	batch_t *curbatch;
	batch_t dummybatch;
	vec4_t lightshadowmapproj;
	vec2_t lightshadowmapscale;

	unsigned int curlmode;
	shader_t	*shader_rtlight[LSHADER_MODES];

	program_t			*programfixedemu[2];

	mesh_t		**meshlist;
	unsigned int nummeshes;

	unsigned int wbatch;
	unsigned int maxwbatches;
	batch_t *wbatches;

	VkDescriptorBufferInfo ubo_entity;
	VkDescriptorBufferInfo ubo_light;
	vec4_t lightinfo;	//org+radius

	VkBuffer staticbuf;	//holds fallback vertex info so we don't crash from it
	vk_poolmem_t staticbufmem;

	texid_t tex_currentrender;

	struct vk_rendertarg rt_reflection;
	struct vk_rendertarg rt_refraction;
	texid_t tex_refraction;	//separate from rt_reflection, because $reasons
	texid_t tex_ripplemap;

	vkrendercontext_t rc;

	struct shadowmaps_s
	{
		uint32_t width;
		uint32_t height;
		VkImage image;	//array. multiple allows for things to happen out of order, which should help to avoid barrier stalls.
		VkDeviceMemory memory;

		uint32_t seq;
		struct
		{
			VkFramebuffer framebuffer;
			image_t qimage;		//this is silly, but whatever.
			vk_image_t vimage;
		} buf[8];
	} shadow[2]; //omni, spot
	texid_t currentshadowmap;

	VkDescriptorSetLayout textureLayout;
} vkbackend_t;

#define VERTEXSTREAMSIZE (1024*1024*2)	//2mb = 1 PAE jumbo page

#define DYNVBUFFSIZE 65536
#define DYNIBUFFSIZE 65536

static vecV_t tmpbuf[65536];	//max verts per mesh

static vkbackend_t shaderstate;

extern int be_maxpasses;

struct blobheader
{
	unsigned char blobmagic[4];
	unsigned int blobversion;
	unsigned int defaulttextures;	//s_diffuse etc flags
	unsigned int numtextures;		//s_t0 count
	unsigned int permutations;		//

	unsigned int cvarsoffset;
	unsigned int cvarslength;

	unsigned int vertoffset;
	unsigned int vertlength;
	unsigned int fragoffset;
	unsigned int fraglength;
};

static float VK_ShaderReadArgument(const char *arglist, const char *arg, char type, qbyte size, void *out)
{
	qbyte i;
	const char *var;
	int arglen = strlen(arg);

	//grab an argument instead, otherwise 0
	var = arglist;
	while((var = strchr(var, '#')))
	{
		if (!Q_strncasecmp(var+1, arg, arglen))
		{
			if (var[1+arglen] == '=')
			{
				var = var+arglen+2;
				for (i = 0; i < size; i++)
				{
					while (*var == ' ' || *var == '\t' || *var == ',')
						var++;

					if (type == 'F')
						((float*)out)[i] = BigFloat(strtod(var, (char**)&var));
					else
						((int*)out)[i] = BigLong(strtol(var, (char**)&var, 0));
					if (!var)
						break;
				}
				return 1;
			}
			if (var[1+arglen] == '#' || !var[1+arglen])
			{
				for (i = 0; i < size; i++)
				{
					if (type == 'F')
						((float*)out)[i] = BigFloat(1);
					else
						((int*)out)[i] = BigLong(1);
				}
				return 1;	//present, but no value
			}
		}
		var++;
	}
	return 0;	//not present.
}

#if 0
//this should use shader pass flags, but those are specific to the shader, not the program, which makes this awkward.
static VkSampler VK_GetSampler(unsigned int flags)
{
	static VkSampler ret;
	qboolean clamptoedge = flags & IF_CLAMP;
	VkSamplerCreateInfo lmsampinfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
	if (ret)
		return ret;

	if (flags & IF_LINEAR)
	{
		lmsampinfo.minFilter = lmsampinfo.magFilter = VK_FILTER_LINEAR;
		lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
	}
	else if (flags & IF_NEAREST)
	{
		lmsampinfo.minFilter = lmsampinfo.magFilter = VK_FILTER_NEAREST;
		lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
	}
	else
	{
		int *filter = (flags & IF_UIPIC)?vk.filterpic:vk.filtermip;
		if (filter[0])
			lmsampinfo.minFilter = VK_FILTER_LINEAR;
		else
			lmsampinfo.minFilter = VK_FILTER_NEAREST;
		if (filter[1])
			lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
		else
			lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
		if (filter[2])
			lmsampinfo.magFilter = VK_FILTER_LINEAR;
		else
			lmsampinfo.magFilter = VK_FILTER_NEAREST;
	}

	lmsampinfo.addressModeU = clamptoedge?VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:VK_SAMPLER_ADDRESS_MODE_REPEAT;
	lmsampinfo.addressModeV = clamptoedge?VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:VK_SAMPLER_ADDRESS_MODE_REPEAT;
	lmsampinfo.addressModeW = clamptoedge?VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:VK_SAMPLER_ADDRESS_MODE_REPEAT;
	lmsampinfo.mipLodBias = 0.0;
	lmsampinfo.anisotropyEnable = (flags & IF_NEAREST)?false:(vk.max_anistophy > 1);
	lmsampinfo.maxAnisotropy = vk.max_anistophy;
	lmsampinfo.compareEnable = VK_FALSE;
	lmsampinfo.compareOp = VK_COMPARE_OP_NEVER;
	lmsampinfo.minLod = vk.mipcap[0];	//this isn't quite right
	lmsampinfo.maxLod = vk.mipcap[1];
	lmsampinfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
	lmsampinfo.unnormalizedCoordinates = VK_FALSE;
	VkAssert(vkCreateSampler(vk.device, &lmsampinfo, NULL, &ret));

	return ret;
}
#endif

//creates the layout stuff for the prog.
static void VK_FinishProg(program_t *prog, const char *name)
{
	{
		VkDescriptorSetLayout desclayout;
		VkDescriptorSetLayoutCreateInfo descSetLayoutCreateInfo = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
		VkDescriptorSetLayoutBinding dbs[2+MAX_TMUS], *db = dbs;
		uint32_t i;
		//VkSampler samp = VK_GetSampler(0);

		db->binding = db-dbs;
		db->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
		db->descriptorCount = 1;
		db->stageFlags = VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_FRAGMENT_BIT;
		db->pImmutableSamplers = NULL;
		db++;

		db->binding = db-dbs;
		db->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
		db->descriptorCount = 1;
		db->stageFlags = VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_FRAGMENT_BIT;
		db->pImmutableSamplers = NULL;
		db++;

		for (i = 0; i < 32; i++)
		{
			if (!(prog->defaulttextures & (1u<<i)))
				continue;
			db->binding = db-dbs;
			db->descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
			db->descriptorCount = 1;
			db->stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
			db->pImmutableSamplers = NULL;//&samp;
			db++;
		}

		for (i = 0; i < prog->numsamplers; i++)
		{
			db->binding = db-dbs;
			db->descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
			db->descriptorCount = 1;
			db->stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
			db->pImmutableSamplers = NULL;//&samp;
			db++;
		}

		descSetLayoutCreateInfo.bindingCount = db-dbs;
		descSetLayoutCreateInfo.pBindings = dbs;
		if (vk.khr_push_descriptor)
			descSetLayoutCreateInfo.flags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
		VkAssert(vkCreateDescriptorSetLayout(vk.device, &descSetLayoutCreateInfo, NULL, &desclayout));
		prog->desclayout = desclayout;
	}

	{
		VkDescriptorSetLayout sets[1] = {prog->desclayout};
		VkPipelineLayout layout;
		VkPushConstantRange push[1];
		VkPipelineLayoutCreateInfo pipeLayoutCreateInfo = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
		push[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
		push[0].offset = 0;
		push[0].size = sizeof(vec4_t);

		pipeLayoutCreateInfo.flags = 0;
		pipeLayoutCreateInfo.setLayoutCount = countof(sets);
		pipeLayoutCreateInfo.pSetLayouts = sets;
		pipeLayoutCreateInfo.pushConstantRangeCount = !strcmp(name, "fixedemu_flat");
		pipeLayoutCreateInfo.pPushConstantRanges = push;
		VkAssert(vkCreatePipelineLayout(vk.device, &pipeLayoutCreateInfo, vkallocationcb, &layout));
		prog->layout = layout;
	}
}

qboolean VK_LoadBlob(program_t *prog, void *blobdata, const char *name)
{
	//fixme: should validate that the offset+lengths are within the blobdata.
	struct blobheader *blob = blobdata;
	VkShaderModuleCreateInfo info = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
	VkShaderModule vert, frag;
	unsigned char *cvardata;

	if (blob->blobmagic[0] != 0xff || blob->blobmagic[1] != 'S' || blob->blobmagic[2] != 'P' || blob->blobmagic[3] != 'V')
		return false;	//bad magic.
	if (blob->blobversion != 1)
	{
		Con_Printf("Blob %s is outdated\n", name);
		return false;
	}

	info.flags = 0;
	info.codeSize = blob->vertlength;
	info.pCode = (uint32_t*)((char*)blob+blob->vertoffset);
	VkAssert(vkCreateShaderModule(vk.device, &info, vkallocationcb, &vert));
	DebugSetName(VK_OBJECT_TYPE_SHADER_MODULE, (uint64_t)vert, name);

	info.flags = 0;
	info.codeSize = blob->fraglength;
	info.pCode = (uint32_t*)((char*)blob+blob->fragoffset);
	VkAssert(vkCreateShaderModule(vk.device, &info, vkallocationcb, &frag));
	DebugSetName(VK_OBJECT_TYPE_SHADER_MODULE, (uint64_t)frag, name);

	prog->vert = vert;
	prog->frag = frag;
	prog->numsamplers = blob->numtextures;
	prog->defaulttextures = blob->defaulttextures;
	prog->supportedpermutations = blob->permutations;

	if (blob->cvarslength)
	{
		prog->cvardata = BZ_Malloc(blob->cvarslength);
		prog->cvardatasize = blob->cvarslength;
		memcpy(prog->cvardata, (char*)blob+blob->cvarsoffset, blob->cvarslength);
	}
	else
	{
		prog->cvardata = NULL;
		prog->cvardatasize = 0;
	}

	//go through the cvars and a) validate them. b) create them with the right defaults.
	//FIXME: validate
	for (cvardata = prog->cvardata; cvardata < prog->cvardata + prog->cvardatasize; )
	{
		unsigned char type = cvardata[2], size = cvardata[3]-'0';
		const char *cvarname;
		cvar_t *var;

		cvardata += 4;
		cvarname = cvardata;
		cvardata += strlen(cvarname)+1;

		if (type >= 'A' && type <= 'Z')
		{	//args will be handled by the blob loader.
			//the blob contains default values, overwrite them with the user's preferences...
			VK_ShaderReadArgument(name, cvarname, type, size, cvardata);
		}
		else
		{
			var = Cvar_FindVar(cvarname);
			if (var)
				var->flags |= CVAR_SHADERSYSTEM;	//just in case
			else
			{
				union
				{
					int i;
					float f;
				} u;
				char value[128];
				uint32_t i;
				*value = 0;
				for (i = 0; i < size; i++)
				{
					u.i = (cvardata[i*4+0]<<24)|(cvardata[i*4+1]<<16)|(cvardata[i*4+2]<<8)|(cvardata[i*4+3]<<0);
					if (i)
						Q_strncatz(value, " ", sizeof(value));
					if (type == 'i' || type == 'b')
						Q_strncatz(value, va("%i", u.i), sizeof(value));
					else
						Q_strncatz(value, va("%f", u.f), sizeof(value));
				}
				Cvar_Get(cvarname, value, CVAR_SHADERSYSTEM, "GLSL Settings");
			}
		}
		cvardata += 4*size;
	}

	VK_FinishProg(prog, name);

	prog->pipelines = NULL;	//generated as needed, depending on blend states etc.
	return true;
}
static void VKBE_ReallyDeleteProg(void *vprog)
{	//nothing else is refering to this data any more, its safe to obliterate it.
	program_t *prog = vprog;
	struct pipeline_s *pipe;
	while(prog->pipelines)
	{
		pipe = prog->pipelines;
		prog->pipelines = pipe->next;

		if (pipe->pipeline)
			vkDestroyPipeline(vk.device, pipe->pipeline, vkallocationcb);
		Z_Free(pipe);
	}
	if (prog->layout)
		vkDestroyPipelineLayout(vk.device, prog->layout, vkallocationcb);
	if (prog->desclayout)
		vkDestroyDescriptorSetLayout(vk.device, prog->desclayout, vkallocationcb);
	if (prog->vert)
		vkDestroyShaderModule(vk.device, prog->vert, vkallocationcb);
	if (prog->frag)
		vkDestroyShaderModule(vk.device, prog->frag, vkallocationcb);
}

void VKBE_DeleteProg(program_t *prog)
{
	//schedule the deletes when its safe to do so.
	VK_AtFrameEnd(VKBE_ReallyDeleteProg, prog, sizeof(*prog));

	//clear stuff out so that the caller doesn't get confused.
	Z_Free(prog->cvardata);
	prog->cvardata = NULL;
	prog->pipelines = NULL;
	prog->layout = VK_NULL_HANDLE;
	prog->desclayout = VK_NULL_HANDLE;
	prog->vert = VK_NULL_HANDLE;
	prog->frag = VK_NULL_HANDLE;
}

static unsigned int VKBE_ApplyShaderBits(unsigned int bits)
{
	if (shaderstate.flags & (BEF_FORCEADDITIVE|BEF_FORCETRANSPARENT|BEF_FORCENODEPTH|BEF_FORCEDEPTHTEST|BEF_FORCEDEPTHWRITE|BEF_LINES))
	{
		if (shaderstate.flags & BEF_FORCEADDITIVE)
			bits = (bits & ~(SBITS_MISC_DEPTHWRITE|SBITS_BLEND_BITS|SBITS_ATEST_BITS))
						| (SBITS_SRCBLEND_SRC_ALPHA | SBITS_DSTBLEND_ONE);
		else if (shaderstate.flags & BEF_FORCETRANSPARENT)
		{
			if ((bits & SBITS_BLEND_BITS) == (SBITS_SRCBLEND_ONE|SBITS_DSTBLEND_ZERO) || !(bits & SBITS_BLEND_BITS) || (bits&SBITS_ATEST_GE128)) 	/*if transparency is forced, clear alpha test bits*/
				bits = (bits & ~(SBITS_MISC_DEPTHWRITE|SBITS_BLEND_BITS|SBITS_ATEST_BITS))
							| (SBITS_SRCBLEND_SRC_ALPHA | SBITS_DSTBLEND_ONE_MINUS_SRC_ALPHA);
		}

		if (shaderstate.flags & BEF_FORCENODEPTH) 	/*EF_NODEPTHTEST dp extension*/
			bits |= SBITS_MISC_NODEPTHTEST;
		else
		{
			if (shaderstate.flags & BEF_FORCEDEPTHTEST)
				bits &= ~SBITS_MISC_NODEPTHTEST;
			if (shaderstate.flags & BEF_FORCEDEPTHWRITE)
				bits |= SBITS_MISC_DEPTHWRITE;
		}

		if (shaderstate.flags & BEF_LINES)
			bits |= SBITS_LINES;
	}
	return bits;
}

static const char LIGHTPASS_SHADER[] = "\
{\n\
	program rtlight\n\
	{\n\
		nodepth\n\
		blendfunc add\n\
	}\n\
}";

void VKBE_Init(void)
{
	int i;
	char *c;

	sh_config.pDeleteProg = VKBE_DeleteProg;

	be_maxpasses = 1;
	memset(&shaderstate, 0, sizeof(shaderstate));
	shaderstate.inited = true;
	for (i = 0; i < MAXRLIGHTMAPS; i++)
		shaderstate.dummybatch.lightmap[i] = -1;

	shaderstate.identitylighting = 1;
	shaderstate.identitylightmap = 1;

	//make sure the world draws correctly
	r_worldentity.shaderRGBAf[0] = 1;
	r_worldentity.shaderRGBAf[1] = 1;
	r_worldentity.shaderRGBAf[2] = 1;
	r_worldentity.shaderRGBAf[3] = 1;
	r_worldentity.axis[0][0] = 1;
	r_worldentity.axis[1][1] = 1;
	r_worldentity.axis[2][2] = 1;
	r_worldentity.light_avg[0] = 1;
	r_worldentity.light_avg[1] = 1;
	r_worldentity.light_avg[2] = 1;

	FTable_Init();

	shaderstate.depthonly = R_RegisterShader("depthonly", SUF_NONE, 
				"{\n"
					"program depthonly\n"
					"{\n"
						"depthwrite\n"
						"maskcolor\n"
					"}\n"
				"}\n");


	shaderstate.programfixedemu[0] = Shader_FindGeneric("fixedemu", QR_VULKAN);
	shaderstate.programfixedemu[1] = Shader_FindGeneric("fixedemu_flat", QR_VULKAN);

	R_InitFlashblends();

/*
	{
		VkDescriptorPoolCreateInfo dpi = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
		VkDescriptorPoolSize dpisz[2];
		dpi.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
		dpi.maxSets = 512;
		dpi.poolSizeCount = countof(dpisz);
		dpi.pPoolSizes = dpisz;

		dpisz[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
		dpisz[0].descriptorCount = 2;

		dpisz[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
		dpisz[1].descriptorCount = MAX_TMUS;

		VkAssert(vkCreateDescriptorPool(vk.device, &dpi, NULL, &shaderstate.texturedescpool));
	}
*/
	{
		struct stagingbuf lazybuf;
		void *buffer = VKBE_CreateStagingBuffer(&lazybuf, sizeof(vec4_t)*65536+sizeof(vec3_t)*3*65536, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
		vec4_t *col = buffer;
		vec3_t *norm = (vec3_t*)(col+65536);
		vec3_t *sdir = norm+65536;
		vec3_t *tdir = sdir+65536;
		for (i = 0; i < 65536; i++)
		{
			Vector4Set(col[i], 1, 1, 1, 1);
			VectorSet(norm[i], 1, 0, 0);
			VectorSet(sdir[i], 0, 1, 0);
			VectorSet(tdir[i], 0, 0, 1);
		}
		shaderstate.staticbuf = VKBE_FinishStaging(&lazybuf, &shaderstate.staticbufmem);
	}


	c = vk_stagingbuffers.string;
	if (*c)
	{
		vk_usedynamicstaging = 0;
		while (*c)
		{
			if (*c == 'u')
				vk_usedynamicstaging |= 1u<<DB_UBO;
			else if (*c == 'e' || *c == 'i')
				vk_usedynamicstaging |= 1u<<DB_EBO;
			else if (*c == 'v')
				vk_usedynamicstaging |= 1u<<DB_VBO;
			else if (*c == '0')
				vk_usedynamicstaging |= 0;	//for explicly none.
			else
				Con_Printf("%s: unknown char %c\n", vk_stagingbuffers.string, *c);
			c++;
		}
	}
	else
		vk_usedynamicstaging = 0u;
}

static struct descpool *VKBE_CreateDescriptorPool(void)
{
	struct descpool *np = Z_Malloc(sizeof(*np));
	
	VkDescriptorPoolCreateInfo dpi = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
	VkDescriptorPoolSize dpisz[2];
	dpi.flags = 0;
	dpi.maxSets = np->totalsets = 512;
	dpi.poolSizeCount = countof(dpisz);
	dpi.pPoolSizes = dpisz;

	dpisz[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
	dpisz[0].descriptorCount = 2*dpi.maxSets;

	dpisz[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
	dpisz[1].descriptorCount = MAX_TMUS*dpi.maxSets;

	VkAssert(vkCreateDescriptorPool(vk.device, &dpi, NULL, &np->pool));

	return np;
}
static VkDescriptorSet VKBE_TempDescriptorSet(VkDescriptorSetLayout layout)
{
	VkDescriptorSet ret;
	VkDescriptorSetAllocateInfo setinfo = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};

	if (vk.descpool->availsets == 0)
	{
		if (vk.descpool->next)
			vk.descpool = vk.descpool->next;
		else
			vk.descpool = vk.descpool->next = VKBE_CreateDescriptorPool();
		vkResetDescriptorPool(vk.device, vk.descpool->pool, 0);
		vk.descpool->availsets = vk.descpool->totalsets;
	}
	vk.descpool->availsets--;

	setinfo.descriptorPool = vk.descpool->pool;
	setinfo.descriptorSetCount = 1;
	setinfo.pSetLayouts = &layout;
	vkAllocateDescriptorSets(vk.device, &setinfo, &ret);

	return ret;
}

//creates a new dynamic buffer for us to use while streaming. because spoons.
static struct dynbuffer *VKBE_AllocNewBuffer(struct dynbuffer **link, enum dynbuf_e type, VkDeviceSize minsize)
{
	VkBufferUsageFlags ufl[] = {VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_BUFFER_USAGE_TRANSFER_SRC_BIT};
	VkBufferCreateInfo bufinf = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
	VkMemoryRequirements mem_reqs;
	VkMemoryAllocateInfo memAllocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
	struct dynbuffer *n = Z_Malloc(sizeof(*n));
	qboolean usestaging = (vk_usedynamicstaging & (1u<<type))!=0;

	while(1)
	{
		bufinf.flags = 0;
		bufinf.size = n->size = (1u<<20);
		bufinf.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
		bufinf.queueFamilyIndexCount = 0;
		bufinf.pQueueFamilyIndices = NULL;

		while (bufinf.size < minsize)
			bufinf.size *= 2;

		n->size = bufinf.size;

		if (type != DB_STAGING && usestaging)
		{
			//create two buffers, one staging/host buffer and one device buffer
			bufinf.usage = ufl[type]|VK_BUFFER_USAGE_TRANSFER_DST_BIT;
			vkCreateBuffer(vk.device, &bufinf, vkallocationcb, &n->devicebuf);
			bufinf.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
			vkCreateBuffer(vk.device, &bufinf, vkallocationcb, &n->stagingbuf);

			vkGetBufferMemoryRequirements(vk.device, n->devicebuf, &mem_reqs);
			n->align = mem_reqs.alignment-1;
			memAllocInfo.allocationSize = mem_reqs.size;
			memAllocInfo.memoryTypeIndex = vk_find_memory_require(mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
			VkAssert(vkAllocateMemory(vk.device, &memAllocInfo, vkallocationcb, &n->devicememory));
			VkAssert(vkBindBufferMemory(vk.device, n->devicebuf, n->devicememory, 0));

			n->renderbuf = n->devicebuf;
		}
		else
		{	//single buffer. we'll write directly to the buffer.
			bufinf.usage = ufl[type];
			vkCreateBuffer(vk.device, &bufinf, vkallocationcb, &n->stagingbuf);

			n->renderbuf = n->stagingbuf;
		}

		//now allocate some host-visible memory for the buffer that we're going to map.
		vkGetBufferMemoryRequirements(vk.device, n->stagingbuf, &mem_reqs);
		n->align = mem_reqs.alignment-1;
		memAllocInfo.allocationSize = mem_reqs.size;
		memAllocInfo.memoryTypeIndex = ~0;
	//	if (memAllocInfo.memoryTypeIndex == ~0)
	//		memAllocInfo.memoryTypeIndex = vk_find_memory_try(mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
		if (memAllocInfo.memoryTypeIndex == ~0 && n->renderbuf == n->stagingbuf)	//probably won't get anything, but whatever.
			memAllocInfo.memoryTypeIndex = vk_find_memory_try(mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
		if (memAllocInfo.memoryTypeIndex == ~0)
			memAllocInfo.memoryTypeIndex = vk_find_memory_try(mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
		if (memAllocInfo.memoryTypeIndex == ~0)
		{	//if we can't find any usable memory, force staging instead.
			vkDestroyBuffer(vk.device, n->stagingbuf, vkallocationcb);
			if (usestaging)
				Sys_Error("Unable to allocate buffer memory");
			usestaging = true;
			continue;
		}
		VkAssert(vkAllocateMemory(vk.device, &memAllocInfo, vkallocationcb, &n->stagingmemory));
		VkAssert(vkBindBufferMemory(vk.device, n->stagingbuf, n->stagingmemory, 0));

		VkAssert(vkMapMemory(vk.device, n->stagingmemory, 0, n->size, 0, &n->ptr));	//persistent-mapped.

		n->stagingcoherent = !!(vk.memory_properties.memoryTypes[memAllocInfo.memoryTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
		n->next = *link;
		*link = n;
		return n;
	}
}
static void *fte_restrict VKBE_AllocateBufferSpace(enum dynbuf_e type, size_t datasize, VkBuffer *buf, VkDeviceSize *offset)
{	//FIXME: ubos need alignment
	struct dynbuffer *b = vk.dynbuf[type];
	void *ret;
	if (b->offset + datasize > b->size)
	{
		//flush the old one, just in case.
		if (!b->stagingcoherent)
		{
			VkMappedMemoryRange range = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE};
			range.offset = b->flushed;
			range.size = b->offset-b->flushed;
			range.memory = b->stagingmemory;
			vkFlushMappedMemoryRanges(vk.device, 1, &range);
		}

		if (b->devicebuf != VK_NULL_HANDLE)
		{
			struct vk_fencework *fence = VK_FencedBegin(NULL, 0);
			VkBufferCopy bcr = {0};
			bcr.srcOffset = b->flushed;
			bcr.dstOffset = b->flushed;
			bcr.size = b->offset-b->flushed;
			vkCmdCopyBuffer(fence->cbuf, b->stagingbuf, b->devicebuf, 1, &bcr);
			VK_FencedSubmit(fence);
		}

		if (!b->next)
			VKBE_AllocNewBuffer(&b->next, type, datasize);
		b = vk.dynbuf[type] = b->next;
		b->offset = 0;
		b->flushed = 0;
	}

	*buf = b->renderbuf;
	*offset = b->offset;

	ret = (qbyte*)b->ptr + b->offset;
	b->offset += datasize;	//FIXME: alignment
	return ret;
}

//called when a new swapchain has been created.
//makes sure there's no nulls or anything.
void VKBE_InitFramePools(struct vkframe *frame)
{
	uint32_t i;
	for (i = 0; i < DB_MAX; i++)
	{
		frame->dynbufs[i] = NULL;
		VKBE_AllocNewBuffer(&frame->dynbufs[i], i, 0);
	}
	frame->descpools = vk.khr_push_descriptor?NULL:VKBE_CreateDescriptorPool();


	frame->numcbufs = 0;
	frame->maxcbufs = 0;
	frame->cbufs = NULL;
	/*{
		VkCommandBufferAllocateInfo cbai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
		cbai.commandPool = vk.cmdpool;
		cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
		cbai.commandBufferCount = frame->maxcbufs;
		VkAssert(vkAllocateCommandBuffers(vk.device, &cbai, frame->cbufs));
	}*/

	{
		VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
		fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
		VkAssert(vkCreateFence(vk.device,&fci,vkallocationcb,&frame->finishedfence));
	}
}

//called just before submits
//makes sure that our persistent-mapped memory writes can actually be seen by the hardware.
void VKBE_FlushDynamicBuffers(void)
{
	struct vk_fencework *fence = NULL;
	uint32_t i;
	struct dynbuffer *d;
	VkMappedMemoryRange range = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE};

	for (i = 0; i < DB_MAX; i++)
	{
		d = vk.dynbuf[i];
		if (d->flushed == d->offset)
			continue;

		if (!d->stagingcoherent)
		{
			range.offset = d->flushed;
			range.size = d->offset - d->flushed;
			range.memory = d->stagingmemory;
			vkFlushMappedMemoryRanges(vk.device, 1, &range);
		}

		if (d->devicebuf != VK_NULL_HANDLE)
		{	
			VkBufferCopy bcr = {0};
			bcr.srcOffset = d->flushed;
			bcr.dstOffset = d->flushed;
			bcr.size = d->offset - d->flushed;
			if (!fence)
				fence = VK_FencedBegin(NULL, 0);
			vkCmdCopyBuffer(fence->cbuf, d->stagingbuf, d->devicebuf, 1, &bcr);
		}
		d->flushed = d->offset;
	}

	if (fence)
		VK_FencedSubmit(fence);
}

void VKBE_Set2D(qboolean twodee)
{
	if (twodee)
		shaderstate.forcebeflags = BEF_FORCENODEPTH;
	else
		shaderstate.forcebeflags = 0;
	shaderstate.curtime = realtime;
}

//called at the start of each frame
//resets the working dynamic buffers to this frame's storage, to avoid stepping on frames owned by the gpu
void VKBE_RestartFrame(void)
{
	uint32_t i;
	for (i = 0; i < DB_MAX; i++)
	{
		vk.dynbuf[i] = vk.frame->dynbufs[i];
		vk.dynbuf[i]->offset = vk.dynbuf[i]->flushed = 0;
	}

	shaderstate.rc.activepipeline = VK_NULL_HANDLE;
	vk.descpool = vk.frame->descpools;
	if (vk.descpool)
	{
		vkResetDescriptorPool(vk.device, vk.descpool->pool, 0);
		vk.descpool->availsets = vk.descpool->totalsets;
	}
}

void VKBE_ShutdownFramePools(struct vkframe *frame)
{
	struct dynbuffer *db;
	struct descpool *dp;
	uint32_t i;

	for (i = 0; i < DB_MAX; i++)
	{
		while(frame->dynbufs[i])
		{
			db = frame->dynbufs[i];
			vkDestroyBuffer(vk.device, db->stagingbuf, vkallocationcb);
			vkFreeMemory(vk.device, db->stagingmemory, vkallocationcb);
			if (db->devicebuf != VK_NULL_HANDLE)
			{
				vkDestroyBuffer(vk.device, db->devicebuf, vkallocationcb);
				vkFreeMemory(vk.device, db->devicememory, vkallocationcb);
			}
			frame->dynbufs[i] = db->next;
			Z_Free(db);
		}
	}

	while(frame->descpools)
	{
		dp = frame->descpools;
		vkDestroyDescriptorPool(vk.device, dp->pool, vkallocationcb);
		frame->descpools = dp->next;
		Z_Free(dp);
	}
}

void VKBE_Shutdown(void)
{
	if (!shaderstate.inited)
		return;

#ifdef RTLIGHTS
	Sh_Shutdown();
#endif

	Shader_ReleaseGeneric(shaderstate.programfixedemu[0]);
	Shader_ReleaseGeneric(shaderstate.programfixedemu[1]);

	shaderstate.inited = false;
#ifdef RTLIGHTS
	VK_TerminateShadowMap();
#endif
	Z_Free(shaderstate.wbatches);
	shaderstate.wbatches = NULL;

	vkDestroyBuffer(vk.device, shaderstate.staticbuf, vkallocationcb);
	VK_ReleasePoolMemory(&shaderstate.staticbufmem);
}

static texid_t SelectPassTexture(const shaderpass_t *pass)
{
	safeswitch(pass->texgen)
	{
	case T_GEN_DIFFUSE:
		return shaderstate.curtexnums->base;
	case T_GEN_NORMALMAP:
		if (TEXLOADED(shaderstate.curtexnums->bump))
			return shaderstate.curtexnums->bump;
		else
			return missing_texture_normal;
	case T_GEN_SPECULAR:
		if (TEXLOADED(shaderstate.curtexnums->specular))
			return shaderstate.curtexnums->specular;
		else
			return missing_texture_gloss;
	case T_GEN_UPPEROVERLAY:
		return shaderstate.curtexnums->upperoverlay;
	case T_GEN_LOWEROVERLAY:
		return shaderstate.curtexnums->loweroverlay;
	case T_GEN_FULLBRIGHT:
		return shaderstate.curtexnums->fullbright;
	case T_GEN_PALETTED:
		return shaderstate.curtexnums->paletted;
	case T_GEN_REFLECTCUBE:
		if (TEXLOADED(shaderstate.curtexnums->reflectcube))
			return shaderstate.curtexnums->reflectcube;
		else if (shaderstate.curbatch->envmap)
			return shaderstate.curbatch->envmap;
		else
			return r_blackcubeimage;	//FIXME
	case T_GEN_REFLECTMASK:
		return shaderstate.curtexnums->reflectmask;
	case T_GEN_OCCLUSION:
		return shaderstate.curtexnums->occlusion;
	case T_GEN_DISPLACEMENT:
		return shaderstate.curtexnums->displacement;

	case T_GEN_ANIMMAP:
		return pass->anim_frames[(int)(pass->anim_fps * shaderstate.curtime) % pass->anim_numframes];
	case T_GEN_SINGLEMAP:
		return pass->anim_frames[0];
	case T_GEN_DELUXMAP:
		{
			int lmi = shaderstate.curbatch->lightmap[0];
			if (lmi < 0 || !lightmap[lmi]->hasdeluxe)
				return r_nulltex;
			else
			{
				lmi+=1;
				return lightmap[lmi]->lightmap_texture;
			}
		}
	case T_GEN_LIGHTMAP:
		{
			int lmi = shaderstate.curbatch->lightmap[0];
			if (lmi < 0)
				return r_whiteimage;
			else
				return lightmap[lmi]->lightmap_texture;
		}

	case T_GEN_CURRENTRENDER:
		return shaderstate.tex_currentrender;
#ifdef HAVE_MEDIA_DECODER
	case T_GEN_VIDEOMAP:
		if (pass->cin)
			return Media_UpdateForShader(pass->cin);
		return r_nulltex;
#endif

	case T_GEN_LIGHTCUBEMAP:	//light's projected cubemap
		if (shaderstate.curdlight)
			return shaderstate.curdlight->cubetexture;
		else
			return r_blackcubeimage;

	case T_GEN_SHADOWMAP:	//light's depth values.
		return shaderstate.currentshadowmap;

	case T_GEN_REFLECTION:	//reflection image (mirror-as-fbo)
		return &shaderstate.rt_reflection.q_colour;
	case T_GEN_REFRACTION:	//refraction image (portal-as-fbo)
		return shaderstate.tex_refraction;
	case T_GEN_REFRACTIONDEPTH:	//refraction image (portal-as-fbo)
		return &shaderstate.rt_refraction.q_depth;
	case T_GEN_RIPPLEMAP:	//ripplemap image (water surface distortions-as-fbo)
		return shaderstate.tex_ripplemap;

	case T_GEN_SOURCECOLOUR: //used for render-to-texture targets
		return vk.sourcecolour;
	case T_GEN_SOURCEDEPTH:	//used for render-to-texture targets
		return vk.sourcedepth;

	case T_GEN_SOURCECUBE:	//used for render-to-texture targets
		return r_blackcubeimage;

	case T_GEN_GBUFFER0:
	case T_GEN_GBUFFER1:
	case T_GEN_GBUFFER2:
	case T_GEN_GBUFFER3:
	case T_GEN_GBUFFER4:
	case T_GEN_GBUFFER5:
	case T_GEN_GBUFFER6:
	case T_GEN_GBUFFER7:
	safedefault:
		return r_nulltex;
	}
	return r_nulltex;
}

static void T_Gen_CurrentRender(void)
{
	vk_image_t *img;
	/*gah... I pitty the gl drivers*/
	if (!shaderstate.tex_currentrender)
	{
		shaderstate.tex_currentrender = Image_CreateTexture("***$currentrender***", NULL, 0);
		shaderstate.tex_currentrender->vkimage = Z_Malloc(sizeof(*shaderstate.tex_currentrender->vkimage));
	}
	img = shaderstate.tex_currentrender->vkimage;
	if (img->width != vid.fbpwidth || img->height != vid.fbpheight)
	{
		//FIXME: free the old image when its safe to do so.
		*img = VK_CreateTexture2DArray(vid.fbpwidth, vid.fbpheight, 1, 1, -vk.backbufformat, PTI_2D, false, shaderstate.tex_currentrender->ident);

		if (!img->sampler)
			VK_CreateSampler(shaderstate.tex_currentrender->flags, img);
	}


	vkCmdEndRenderPass(vk.rendertarg->cbuf);
	
	//submit now?

	//copy the backbuffer to our image
	{
		VkImageCopy region;
		region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		region.srcSubresource.mipLevel = 0;
		region.srcSubresource.baseArrayLayer = 0;
		region.srcSubresource.layerCount = 1;
		region.srcOffset.x = 0;
		region.srcOffset.y = 0;
		region.srcOffset.z = 0;
		region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		region.dstSubresource.mipLevel = 0;
		region.dstSubresource.baseArrayLayer = 0;
		region.dstSubresource.layerCount = 1;
		region.dstOffset.x = 0;
		region.dstOffset.y = 0;
		region.dstOffset.z = 0;
		region.extent.width = vid.fbpwidth;
		region.extent.height = vid.fbpheight;
		region.extent.depth = 1;

		set_image_layout(vk.rendertarg->cbuf, vk.frame->backbuf->colour.image, VK_IMAGE_ASPECT_COLOR_BIT,
				VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,	VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		VK_ACCESS_TRANSFER_READ_BIT,		VK_PIPELINE_STAGE_TRANSFER_BIT);
		set_image_layout(vk.rendertarg->cbuf, img->image, VK_IMAGE_ASPECT_COLOR_BIT,
				VK_IMAGE_LAYOUT_UNDEFINED,			0,					VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
				VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,		VK_ACCESS_TRANSFER_WRITE_BIT,		VK_PIPELINE_STAGE_TRANSFER_BIT);
		vkCmdCopyImage(vk.rendertarg->cbuf, vk.frame->backbuf->colour.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, img->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
		set_image_layout(vk.rendertarg->cbuf, img->image, VK_IMAGE_ASPECT_COLOR_BIT,
				VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,		VK_ACCESS_TRANSFER_WRITE_BIT,		VK_PIPELINE_STAGE_TRANSFER_BIT,
				VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,	VK_ACCESS_SHADER_READ_BIT,		VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
		set_image_layout(vk.rendertarg->cbuf, vk.frame->backbuf->colour.image, VK_IMAGE_ASPECT_COLOR_BIT,
				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		VK_ACCESS_TRANSFER_READ_BIT,		VK_PIPELINE_STAGE_TRANSFER_BIT,
				VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,	VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);

		img->layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
	}


	//submit now?
	//barrier?
	vkCmdBeginRenderPass(vk.rendertarg->cbuf, &vk.rendertarg->restartinfo, VK_SUBPASS_CONTENTS_INLINE);
	//fixme: viewport+scissor?
}

static void R_FetchPlayerColour(unsigned int cv, vec3_t rgb)
{
	int i;

	if (cv >= 16)
	{
		rgb[0] = (((cv&0xff0000)>>16)**((unsigned char*)&d_8to24rgbtable[15]+0)) / (256.0*256);
		rgb[1] = (((cv&0x00ff00)>>8)**((unsigned char*)&d_8to24rgbtable[15]+1)) / (256.0*256);
		rgb[2] = (((cv&0x0000ff)>>0)**((unsigned char*)&d_8to24rgbtable[15]+2)) / (256.0*256);
		return;
	}
	i = cv;
	if (i >= 8)
	{
		i<<=4;
	}
	else
	{
		i<<=4;
		i+=15;
	}
	i*=3;
	rgb[0] = host_basepal[i+0] / 255.0;
	rgb[1] = host_basepal[i+1] / 255.0;
	rgb[2] = host_basepal[i+2] / 255.0;
/*	if (!gammaworks)
	{
		*retred = gammatable[*retred];
		*retgreen = gammatable[*retgreen];
		*retblue = gammatable[*retblue];
	}*/
}

//source is always packed
//dest is packed too
static void colourgen(const shaderpass_t *pass, int cnt, byte_vec4_t *srcb, avec4_t *srcf, vec4_t *dst, const mesh_t *mesh)
{
	switch (pass->rgbgen)
	{
	case RGB_GEN_ENTITY:
		while((cnt)--)
		{
			dst[cnt][0] = shaderstate.curentity->shaderRGBAf[0];
			dst[cnt][1] = shaderstate.curentity->shaderRGBAf[1];
			dst[cnt][2] = shaderstate.curentity->shaderRGBAf[2];
		}
		break;
	case RGB_GEN_ONE_MINUS_ENTITY:
		while((cnt)--)
		{
			dst[cnt][0] = 1-shaderstate.curentity->shaderRGBAf[0];
			dst[cnt][1] = 1-shaderstate.curentity->shaderRGBAf[1];
			dst[cnt][2] = 1-shaderstate.curentity->shaderRGBAf[2];
		}
		break;
	case RGB_GEN_VERTEX_LIGHTING:
#if MAXRLIGHTMAPS > 1
		if (mesh->colors4f_array[1])
		{
			float lm[MAXRLIGHTMAPS];
			lm[0] = d_lightstylevalue[shaderstate.curbatch->vtlightstyle[0]]/256.0f*shaderstate.identitylighting;
			lm[1] = d_lightstylevalue[shaderstate.curbatch->vtlightstyle[1]]/256.0f*shaderstate.identitylighting;
			lm[2] = d_lightstylevalue[shaderstate.curbatch->vtlightstyle[2]]/256.0f*shaderstate.identitylighting;
			lm[3] = d_lightstylevalue[shaderstate.curbatch->vtlightstyle[3]]/256.0f*shaderstate.identitylighting;
			while((cnt)--)
			{
				VectorScale(		mesh->colors4f_array[0][cnt], lm[0], dst[cnt]);
				VectorMA(dst[cnt],	lm[1], mesh->colors4f_array[1][cnt], dst[cnt]);
				VectorMA(dst[cnt],	lm[2], mesh->colors4f_array[2][cnt], dst[cnt]);
				VectorMA(dst[cnt],	lm[3], mesh->colors4f_array[3][cnt], dst[cnt]);
			}
			break;
		}
#endif

		if (shaderstate.identitylighting != 1)
		{
			if (srcf)
			{
				while((cnt)--)
				{
					dst[cnt][0] = srcf[cnt][0]*shaderstate.identitylighting;
					dst[cnt][1] = srcf[cnt][1]*shaderstate.identitylighting;
					dst[cnt][2] = srcf[cnt][2]*shaderstate.identitylighting;
				}
			}
			else if (srcb)
			{
				float t = shaderstate.identitylighting * (1/255.0);
				while((cnt)--)
				{
					dst[cnt][0] = srcb[cnt][0]*t;
					dst[cnt][1] = srcb[cnt][1]*t;
					dst[cnt][2] = srcb[cnt][2]*t;
				}
			}
			else
			{
				while((cnt)--)
				{
					dst[cnt][0] = shaderstate.identitylighting;
					dst[cnt][1] = shaderstate.identitylighting;
					dst[cnt][2] = shaderstate.identitylighting;
				}
			}
			break;
		}
	case RGB_GEN_VERTEX_EXACT:
		if (srcf)
		{
			while((cnt)--)
			{
				dst[cnt][0] = srcf[cnt][0];
				dst[cnt][1] = srcf[cnt][1];
				dst[cnt][2] = srcf[cnt][2];
			}
		}
		else if (srcb)
		{
			float t = 1/255.0;
			while((cnt)--)
			{
				dst[cnt][0] = srcb[cnt][0]*t;
				dst[cnt][1] = srcb[cnt][1]*t;
				dst[cnt][2] = srcb[cnt][2]*t;
			}
		}
		else
		{
			while((cnt)--)
			{
				dst[cnt][0] = 1;
				dst[cnt][1] = 1;
				dst[cnt][2] = 1;
			}
			break;
		}
		break;
	case RGB_GEN_ONE_MINUS_VERTEX:
		if (srcf)
		{
			while((cnt)--)
			{
				dst[cnt][0] = 1-srcf[cnt][0];
				dst[cnt][1] = 1-srcf[cnt][1];
				dst[cnt][2] = 1-srcf[cnt][2];
			}
		}
		break;
	case RGB_GEN_IDENTITY_LIGHTING:
		if (shaderstate.curbatch->vtlightstyle[0] != 255 && d_lightstylevalue[shaderstate.curbatch->vtlightstyle[0]] != 256)
		{
			vec_t val = shaderstate.identitylighting * d_lightstylevalue[shaderstate.curbatch->vtlightstyle[0]]/256.0f;
			while((cnt)--)
			{
				dst[cnt][0] = val;
				dst[cnt][1] = val;
				dst[cnt][2] = val;
			}
		}
		else
		{
			//compensate for overbrights
			while((cnt)--)
			{
				dst[cnt][0] = shaderstate.identitylighting;
				dst[cnt][1] = shaderstate.identitylighting;
				dst[cnt][2] = shaderstate.identitylighting;
			}
		}
		break;
	case RGB_GEN_IDENTITY_OVERBRIGHT:
		while((cnt)--)
		{
			dst[cnt][0] = shaderstate.identitylightmap;
			dst[cnt][1] = shaderstate.identitylightmap;
			dst[cnt][2] = shaderstate.identitylightmap;
		}
		break;
	default:
	case RGB_GEN_IDENTITY:
		while((cnt)--)
		{
			dst[cnt][0] = shaderstate.identitylighting;
			dst[cnt][1] = shaderstate.identitylighting;
			dst[cnt][2] = shaderstate.identitylighting;
		}
		break;
	case RGB_GEN_CONST:
		while((cnt)--)
		{
			dst[cnt][0] = pass->rgbgen_func.args[0];
			dst[cnt][1] = pass->rgbgen_func.args[1];
			dst[cnt][2] = pass->rgbgen_func.args[2];
		}
		break;
	case RGB_GEN_ENTITY_LIGHTING_DIFFUSE:
		R_LightArrays(shaderstate.curentity, mesh->xyz_array, dst, cnt, mesh->normals_array, shaderstate.identitylighting, true);
		break;
	case RGB_GEN_LIGHTING_DIFFUSE:
		R_LightArrays(shaderstate.curentity, mesh->xyz_array, dst, cnt, mesh->normals_array, shaderstate.identitylighting, false);
		break;
	case RGB_GEN_WAVE:
		{
			float *table;
			float c;

			table = FTableForFunc(pass->rgbgen_func.type);
			c = pass->rgbgen_func.args[2] + shaderstate.curtime * pass->rgbgen_func.args[3];
			c = FTABLE_EVALUATE(table, c) * pass->rgbgen_func.args[1] + pass->rgbgen_func.args[0];
			c = bound(0.0f, c, 1.0f);

			while((cnt)--)
			{
				dst[cnt][0] = c;
				dst[cnt][1] = c;
				dst[cnt][2] = c;
			}
		}
		break;

	case RGB_GEN_TOPCOLOR:
		if (cnt)
		{
			vec3_t rgb;
			R_FetchPlayerColour(shaderstate.curentity->topcolour, rgb);
			while((cnt)--)
			{
				dst[cnt][0] = rgb[0];
				dst[cnt][1] = rgb[1];
				dst[cnt][2] = rgb[2];
			}
		}
		break;
	case RGB_GEN_BOTTOMCOLOR:
		if (cnt)
		{
			vec3_t rgb;
			R_FetchPlayerColour(shaderstate.curentity->bottomcolour, rgb);
			while((cnt)--)
			{
				dst[cnt][0] = rgb[0];
				dst[cnt][1] = rgb[1];
				dst[cnt][2] = rgb[2];
			}
		}
		break;
	}
}
static void alphagen(const shaderpass_t *pass, int cnt, byte_vec4_t *srcb, avec4_t *srcf, avec4_t *dst, const mesh_t *mesh)
{
	float *table;
	float t;
	float f;
	vec3_t v1, v2;
	int i;

	switch (pass->alphagen)
	{
	default:
	case ALPHA_GEN_IDENTITY:
		if (shaderstate.flags & BEF_FORCETRANSPARENT)
		{
			while(cnt--)
				dst[cnt][3] = shaderstate.curentity->shaderRGBAf[3];
		}
		else
		{
			while(cnt--)
				dst[cnt][3] = 1;
		}
		break;

	case ALPHA_GEN_CONST:
		t = pass->alphagen_func.args[0];
		while(cnt--)
			dst[cnt][3] = t;
		break;

	case ALPHA_GEN_WAVE:
		table = FTableForFunc(pass->alphagen_func.type);
		f = pass->alphagen_func.args[2] + shaderstate.curtime * pass->alphagen_func.args[3];
		f = FTABLE_EVALUATE(table, f) * pass->alphagen_func.args[1] + pass->alphagen_func.args[0];
		t = bound(0.0f, f, 1.0f);
		while(cnt--)
			dst[cnt][3] = t;
		break;

	case ALPHA_GEN_PORTAL:
		//FIXME: should this be per-vert?
		if (r_refdef.recurse)
			f = 1;
		else
		{
			VectorAdd(mesh->xyz_array[0], shaderstate.curentity->origin, v1);
			VectorSubtract(r_origin, v1, v2);
			f = VectorLength(v2) * (1.0 / shaderstate.curshader->portaldist);
			f = bound(0.0f, f, 1.0f);
		}

		while(cnt--)
			dst[cnt][3] = f;
		break;

	case ALPHA_GEN_VERTEX:
		if (srcf)
		{
			while(cnt--)
			{
				dst[cnt][3] = srcf[cnt][3];
			}
		}
		else if (srcb)
		{
			float t = 1/255.0;
			while(cnt--)
			{
				dst[cnt][3] = srcb[cnt][3]*t;
			}
		}
		else
		{
			while(cnt--)
			{
				dst[cnt][3] = 1;
			}
			break;
		}
		break;

	case ALPHA_GEN_ENTITY:
		f = bound(0, shaderstate.curentity->shaderRGBAf[3], 1);
		while(cnt--)
		{
			dst[cnt][3] = f;
		}
		break;


	case ALPHA_GEN_SPECULAR:
		{
			VectorSubtract(r_origin, shaderstate.curentity->origin, v1);

			if (!Matrix3_Compare((const vec3_t*)shaderstate.curentity->axis, (const vec3_t*)axisDefault))
			{
				Matrix3_Multiply_Vec3(shaderstate.curentity->axis, v1, v2);
			}
			else
			{
				VectorCopy(v1, v2);
			}

			for (i = 0; i < cnt; i++)
			{
				VectorSubtract(v2, mesh->xyz_array[i], v1);
				f = DotProduct(v1, mesh->normals_array[i] ) * Q_rsqrt(DotProduct(v1,v1));
				f = f * f * f * f * f;
				dst[i][3] = bound (0.0f, f, 1.0f);
			}
		}
		break;
	}
}

//true if we used an array (flag to use uniforms for it instead if false)
static void BE_GenerateColourMods(unsigned int vertcount, const shaderpass_t *pass, VkBuffer *buffer, VkDeviceSize *offset)
{
	const mesh_t *m = shaderstate.meshlist[0];
//	if (pass->flags & SHADER_PASS_NOCOLORARRAY)
//		error
	if (					   ((pass->rgbgen == RGB_GEN_VERTEX_LIGHTING) ||
								(pass->rgbgen == RGB_GEN_VERTEX_EXACT) ||
								(pass->rgbgen == RGB_GEN_ONE_MINUS_VERTEX)) &&
								(pass->alphagen == ALPHA_GEN_VERTEX))
	{
		if (shaderstate.batchvbo)
		{	//just use the colour vbo provided
			*buffer = shaderstate.batchvbo->colours[0].vk.buff;
			*offset = shaderstate.batchvbo->colours[0].vk.offs;
		}
		else
		{	//we can't use the vbo due to gaps that we don't want to have to deal with
			//we can at least ensure that the data is written in one go to aid cpu cache.
			vec4_t *fte_restrict map;
			unsigned int mno;
			map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec4_t), buffer, offset);
			if (m->colors4f_array[0])
			{
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->colors4f_array[0], m->numvertexes * sizeof(vec4_t));
					map += m->numvertexes;
				}
			}
			else if (m->colors4b_array)
			{
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					uint32_t v;
					m = shaderstate.meshlist[mno];
					for (v = 0; v < m->numvertexes; v++)
						Vector4Scale(m->colors4b_array[v], 1.0/255, map[v]);
					map += m->numvertexes;
				}
			}
			else
			{
				for (mno = 0; mno < vertcount; mno++)
					Vector4Set(map[mno], 1, 1, 1, 1);
			}
		}
	}
	else
	{
		vec4_t *fte_restrict map;
		unsigned int mno;
		map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec4_t), buffer, offset);
		for (mno = 0; mno < shaderstate.nummeshes; mno++)
		{
			m = shaderstate.meshlist[mno];
			colourgen(pass, m->numvertexes, m->colors4b_array, m->colors4f_array[0], map, m);
			alphagen(pass, m->numvertexes, m->colors4b_array, m->colors4f_array[0], map, m);
			map += m->numvertexes;
		}
	}
}

/*********************************************************************************************************/
/*========================================== texture coord generation =====================================*/
static void tcgen_environment(float *st, unsigned int numverts, float *xyz, float *normal)
{
	int			i;
	vec3_t		viewer, reflected;
	float		d;

	vec3_t		rorg;

	RotateLightVector(shaderstate.curentity->axis, shaderstate.curentity->origin, r_origin, rorg);

	for (i = 0 ; i < numverts ; i++, xyz += sizeof(vecV_t)/sizeof(vec_t), normal += 3, st += 2 )
	{
		VectorSubtract (rorg, xyz, viewer);
		VectorNormalizeFast (viewer);

		d = DotProduct (normal, viewer);

		reflected[0] = normal[0]*2*d - viewer[0];
		reflected[1] = normal[1]*2*d - viewer[1];
		reflected[2] = normal[2]*2*d - viewer[2];

		st[0] = 0.5 + reflected[1] * 0.5;
		st[1] = 0.5 - reflected[2] * 0.5;
	}
}

static float *tcgen(const shaderpass_t *pass, int cnt, float *dst, const mesh_t *mesh)
{
	int i;
	vecV_t *src;
	switch (pass->tcgen)
	{
	default:
	case TC_GEN_BASE:
		return (float*)mesh->st_array;
	case TC_GEN_LIGHTMAP:
		return (float*)mesh->lmst_array[0];
	case TC_GEN_NORMAL:
		return (float*)mesh->normals_array;
	case TC_GEN_SVECTOR:
		return (float*)mesh->snormals_array;
	case TC_GEN_TVECTOR:
		return (float*)mesh->tnormals_array;
	case TC_GEN_ENVIRONMENT:
		if (!mesh->normals_array)
			return (float*)mesh->st_array;
		tcgen_environment(dst, cnt, (float*)mesh->xyz_array, (float*)mesh->normals_array);
		return dst;

	case TC_GEN_DOTPRODUCT:
		return dst;//mesh->st_array[0];
	case TC_GEN_VECTOR:
		src = mesh->xyz_array;
		for (i = 0; i < cnt; i++, dst += 2)
		{
			dst[0] = DotProduct(pass->tcgenvec[0], src[i]);
			dst[1] = DotProduct(pass->tcgenvec[1], src[i]);
		}
		return dst;
	}
}

/*src and dst can be the same address when tcmods are chained*/
static void tcmod(const tcmod_t *tcmod, int cnt, const float *src, float *dst, const mesh_t *mesh)
{
	float *table;
	float t1, t2;
	float cost, sint;
	int j;

	switch (tcmod->type)
	{
		case SHADER_TCMOD_ROTATE:
			cost = tcmod->args[0] * shaderstate.curtime;
			sint = R_FastSin(cost);
			cost = R_FastSin(cost + 0.25);

			for (j = 0; j < cnt; j++, dst+=2,src+=2)
			{
				t1 = cost * (src[0] - 0.5f) - sint * (src[1] - 0.5f) + 0.5f;
				t2 = cost * (src[1] - 0.5f) + sint * (src[0] - 0.5f) + 0.5f;
				dst[0] = t1;
				dst[1] = t2;
			}
			break;

		case SHADER_TCMOD_SCALE:
			t1 = tcmod->args[0];
			t2 = tcmod->args[1];

			for (j = 0; j < cnt; j++, dst+=2,src+=2)
			{
				dst[0] = src[0] * t1;
				dst[1] = src[1] * t2;
			}
			break;

		case SHADER_TCMOD_TURB:
			t1 = tcmod->args[2] + shaderstate.curtime * tcmod->args[3];
			t2 = tcmod->args[1];

			for (j = 0; j < cnt; j++, dst+=2,src+=2)
			{
				dst[0] = src[0] + R_FastSin (src[0]*t2+t1) * t2;
				dst[1] = src[1] + R_FastSin (src[1]*t2+t1) * t2;
			}
			break;

		case SHADER_TCMOD_STRETCH:
			table = FTableForFunc(tcmod->args[0]);
			t2 = tcmod->args[3] + shaderstate.curtime * tcmod->args[4];
			t1 = FTABLE_EVALUATE(table, t2) * tcmod->args[2] + tcmod->args[1];
			t1 = t1 ? 1.0f / t1 : 1.0f;
			t2 = 0.5f - 0.5f * t1;
			for (j = 0; j < cnt; j++, dst+=2,src+=2)
			{
				dst[0] = src[0] * t1 + t2;
				dst[1] = src[1] * t1 + t2;
			}
			break;

		case SHADER_TCMOD_SCROLL:
			t1 = tcmod->args[0] * shaderstate.curtime;
			t2 = tcmod->args[1] * shaderstate.curtime;

			for (j = 0; j < cnt; j++, dst += 2, src+=2)
			{
				dst[0] = src[0] + t1;
				dst[1] = src[1] + t2;
			}
			break;

		case SHADER_TCMOD_TRANSFORM:
			for (j = 0; j < cnt; j++, dst+=2, src+=2)
			{
				t1 = src[0];
				t2 = src[1];
				dst[0] = t1 * tcmod->args[0] + t2 * tcmod->args[2] + tcmod->args[4];
				dst[1] = t1 * tcmod->args[1] + t1 * tcmod->args[3] + tcmod->args[5];
			}
			break;

		case SHADER_TCMOD_PAGE:
		default:
			for (j = 0; j < cnt; j++, dst += 2, src+=2)
			{
				dst[0] = src[0];
				dst[1] = src[1];
			}
			break;
	}
}

static void BE_GenerateTCMods(const shaderpass_t *pass, float *dest)
{
	mesh_t *mesh;
	unsigned int mno;
	int i;
	float *src;
	for (mno = 0; mno < shaderstate.nummeshes; mno++)
	{
		mesh = shaderstate.meshlist[mno];
		src = tcgen(pass, mesh->numvertexes, dest, mesh);
		//tcgen might return unmodified info
		if (pass->numtcmods)
		{
			tcmod(&pass->tcmods[0], mesh->numvertexes, src, dest, mesh);
			for (i = 1; i < pass->numtcmods; i++)
			{
				tcmod(&pass->tcmods[i], mesh->numvertexes, dest, dest, mesh);
			}
		}
		else if (src != dest)
		{
			memcpy(dest, src, sizeof(vec2_t)*mesh->numvertexes);
		}
		dest += mesh->numvertexes*2;
	}
}

//end texture coords
/*******************************************************************************************************************/
static void deformgen(const deformv_t *deformv, int cnt, vecV_t *src, vecV_t *dst, const mesh_t *mesh)
{
	float *table;
	int j, k;
	float args[4];
	float deflect;
	switch (deformv->type)
	{
	default:
	case DEFORMV_NONE:
		if (src != dst)
			memcpy(dst, src, sizeof(*src)*cnt);
		break;

	case DEFORMV_WAVE:
		if (!mesh->normals_array)
		{
			if (src != dst)
				memcpy(dst, src, sizeof(*src)*cnt);
			return;
		}
		args[0] = deformv->func.args[0];
		args[1] = deformv->func.args[1];
		args[3] = deformv->func.args[2] + deformv->func.args[3] * shaderstate.curtime;
		table = FTableForFunc(deformv->func.type);

		for ( j = 0; j < cnt; j++ )
		{
			deflect = deformv->args[0] * (src[j][0]+src[j][1]+src[j][2]) + args[3];
			deflect = FTABLE_EVALUATE(table, deflect) * args[1] + args[0];

			// Deflect vertex along its normal by wave amount
			VectorMA(src[j], deflect, mesh->normals_array[j], dst[j]);
		}
		break;

	case DEFORMV_NORMAL:
		//normal does not actually move the verts, but it does change the normals array
		//we don't currently support that.
		if (src != dst)
			memcpy(dst, src, sizeof(*src)*cnt);
/*
		args[0] = deformv->args[1] * shaderstate.curtime;

		for ( j = 0; j < cnt; j++ )
		{
			args[1] = normalsArray[j][2] * args[0];

			deflect = deformv->args[0] * R_FastSin(args[1]);
			normalsArray[j][0] *= deflect;
			deflect = deformv->args[0] * R_FastSin(args[1] + 0.25);
			normalsArray[j][1] *= deflect;
			VectorNormalizeFast(normalsArray[j]);
		}
*/		break;

	case DEFORMV_MOVE:
		table = FTableForFunc(deformv->func.type);
		deflect = deformv->func.args[2] + shaderstate.curtime * deformv->func.args[3];
		deflect = FTABLE_EVALUATE(table, deflect) * deformv->func.args[1] + deformv->func.args[0];

		for ( j = 0; j < cnt; j++ )
			VectorMA(src[j], deflect, deformv->args, dst[j]);
		break;

	case DEFORMV_BULGE:
		args[0] = deformv->args[0]/(2*M_PI);
		args[1] = deformv->args[1];
		args[2] = shaderstate.curtime * deformv->args[2]/(2*M_PI);

		for (j = 0; j < cnt; j++)
		{
			deflect = R_FastSin(mesh->st_array[j][0]*args[0] + args[2])*args[1];
			dst[j][0] = src[j][0]+deflect*mesh->normals_array[j][0];
			dst[j][1] = src[j][1]+deflect*mesh->normals_array[j][1];
			dst[j][2] = src[j][2]+deflect*mesh->normals_array[j][2];
		}
		break;

	case DEFORMV_AUTOSPRITE:
		if (mesh->numindexes < 6)
			break;

		for (j = 0; j < cnt-3; j+=4, src+=4, dst+=4)
		{
			vec3_t mid, d;
			float radius;
			mid[0] = 0.25*(src[0][0] + src[1][0] + src[2][0] + src[3][0]);
			mid[1] = 0.25*(src[0][1] + src[1][1] + src[2][1] + src[3][1]);
			mid[2] = 0.25*(src[0][2] + src[1][2] + src[2][2] + src[3][2]);
			VectorSubtract(src[0], mid, d);
			radius = 2*VectorLength(d);

			for (k = 0; k < 4; k++)
			{
				dst[k][0] = mid[0] + radius*((mesh->st_array[j+k][0]-0.5)*r_refdef.m_view[0+0]-(mesh->st_array[j+k][1]-0.5)*r_refdef.m_view[0+1]);
				dst[k][1] = mid[1] + radius*((mesh->st_array[j+k][0]-0.5)*r_refdef.m_view[4+0]-(mesh->st_array[j+k][1]-0.5)*r_refdef.m_view[4+1]);
				dst[k][2] = mid[2] + radius*((mesh->st_array[j+k][0]-0.5)*r_refdef.m_view[8+0]-(mesh->st_array[j+k][1]-0.5)*r_refdef.m_view[8+1]);
			}
		}
		break;

	case DEFORMV_AUTOSPRITE2:
		if (mesh->numindexes < 6)
			break;

		for (k = 0; k < mesh->numindexes; k += 6)
		{
			int long_axis, short_axis;
			vec3_t axis;
			float len[3];
			mat3_t m0, m1, m2, result;
			float *quad[4];
			vec3_t rot_centre, tv, tv2;

			quad[0] = (float *)(src + mesh->indexes[k+0]);
			quad[1] = (float *)(src + mesh->indexes[k+1]);
			quad[2] = (float *)(src + mesh->indexes[k+2]);

			for (j = 2; j >= 0; j--)
			{
				quad[3] = (float *)(src + mesh->indexes[k+3+j]);
				if (!VectorEquals (quad[3], quad[0]) &&
					!VectorEquals (quad[3], quad[1]) &&
					!VectorEquals (quad[3], quad[2]))
				{
					break;
				}
			}

			// build a matrix were the longest axis of the billboard is the Y-Axis
			VectorSubtract(quad[1], quad[0], m0[0]);
			VectorSubtract(quad[2], quad[0], m0[1]);
			VectorSubtract(quad[2], quad[1], m0[2]);
			len[0] = DotProduct(m0[0], m0[0]);
			len[1] = DotProduct(m0[1], m0[1]);
			len[2] = DotProduct(m0[2], m0[2]);

			if ((len[2] > len[1]) && (len[2] > len[0]))
			{
				if (len[1] > len[0])
				{
					long_axis = 1;
					short_axis = 0;
				}
				else
				{
					long_axis = 0;
					short_axis = 1;
				}
			}
			else if ((len[1] > len[2]) && (len[1] > len[0]))
			{
				if (len[2] > len[0])
				{
					long_axis = 2;
					short_axis = 0;
				}
				else
				{
					long_axis = 0;
					short_axis = 2;
				}
			}
			else //if ( (len[0] > len[1]) && (len[0] > len[2]) )
			{
				if (len[2] > len[1])
				{
					long_axis = 2;
					short_axis = 1;
				}
				else
				{
					long_axis = 1;
					short_axis = 2;
				}
			}

			if (DotProduct(m0[long_axis], m0[short_axis]))
			{
				VectorNormalize2(m0[long_axis], axis);
				VectorCopy(axis, m0[1]);

				if (axis[0] || axis[1])
				{
					VectorVectors(m0[1], m0[2], m0[0]);
				}
				else
				{
					VectorVectors(m0[1], m0[0], m0[2]);
				}
			}
			else
			{
				VectorNormalize2(m0[long_axis], axis);
				VectorNormalize2(m0[short_axis], m0[0]);
				VectorCopy(axis, m0[1]);
				CrossProduct(m0[0], m0[1], m0[2]);
			}

			for (j = 0; j < 3; j++)
				rot_centre[j] = (quad[0][j] + quad[1][j] + quad[2][j] + quad[3][j]) * 0.25;

			if (shaderstate.curentity)
			{
				VectorAdd(shaderstate.curentity->origin, rot_centre, tv);
			}
			else
			{
				VectorCopy(rot_centre, tv);
			}
			VectorSubtract(r_origin, tv, tv);

			// filter any longest-axis-parts off the camera-direction
			deflect = -DotProduct(tv, axis);

			VectorMA(tv, deflect, axis, m1[2]);
			VectorNormalizeFast(m1[2]);
			VectorCopy(axis, m1[1]);
			CrossProduct(m1[1], m1[2], m1[0]);

			Matrix3_Transpose(m1, m2);
			Matrix3_Multiply(m2, m0, result);

			for (j = 0; j < 4; j++)
			{
				int v = ((vecV_t*)quad[j]-src);
				VectorSubtract(quad[j], rot_centre, tv);
				Matrix3_Multiply_Vec3((void *)result, tv, tv2);
				VectorAdd(rot_centre, tv2, dst[v]);
			}
		}
		break;

//	case DEFORMV_PROJECTION_SHADOW:
//		break;
	}
}

static void BE_CreatePipeline(program_t *p, unsigned int shaderflags, unsigned int blendflags, unsigned int permu)
{
	struct pipeline_s *pipe;
	VkDynamicState dynamicStateEnables[2]={0};
	VkPipelineDynamicStateCreateInfo dyn = {VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO};
	VkVertexInputBindingDescription vbinds[VK_BUFF_MAX] = {{0}};
	VkVertexInputAttributeDescription vattrs[VK_BUFF_MAX] = {{0}};
	VkPipelineVertexInputStateCreateInfo vi = {VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO};
	VkPipelineInputAssemblyStateCreateInfo ia = {VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
	VkPipelineViewportStateCreateInfo vp = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
	VkPipelineRasterizationStateCreateInfo rs = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
	VkPipelineMultisampleStateCreateInfo ms = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
	VkPipelineDepthStencilStateCreateInfo ds = {VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO};
	VkPipelineColorBlendStateCreateInfo cb = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
	VkPipelineColorBlendAttachmentState att_state[1];
	VkGraphicsPipelineCreateInfo pipeCreateInfo = {VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
	VkPipelineShaderStageCreateInfo shaderStages[2] = {{0}};
	VkPipelineRasterizationStateRasterizationOrderAMD ro = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD};	//long enough names for you?
	struct specdata_s
	{
		int alphamode;
		int permu[16];
		union
		{
			float f;
			int i;
		} cvars[64];
	} specdata;
	VkSpecializationMapEntry specentries[256] = {{0}};
	VkSpecializationInfo specInfo = {0}, *bugsbeware;
	VkResult err;
	uint32_t i, s;
	unsigned char *cvardata;

	if (!p->vert || !p->frag)
		Sys_Error("program missing required shader\n");	//PANIC


	pipe = Z_Malloc(sizeof(*pipe));
	if (!p->pipelines)
		p->pipelines = pipe;
	else
	{	//insert at end. if it took us a while to realise that we needed it, chances are its not that common.
		//so don't cause the other pipelines to waste cycles for it.
		struct pipeline_s *prev;
		for (prev = p->pipelines; ; prev = prev->next)
			if (!prev->next)
				break;
		prev->next = pipe;
	}

	pipe->flags = shaderflags;
	pipe->blendbits = blendflags;
	pipe->permu = permu;

	if (permu&PERMUTATION_BEM_WIREFRAME)
	{
		blendflags |= SBITS_MISC_NODEPTHTEST;
		blendflags &= ~SBITS_MISC_DEPTHWRITE;

		blendflags &= ~(SHADER_CULL_FRONT|SHADER_CULL_BACK);
	}

	dyn.flags = 0;
	dyn.dynamicStateCount = 0;
	dyn.pDynamicStates = dynamicStateEnables;

	//it wasn't supposed to be like this!
	//this stuff gets messy with tcmods and rgbgen/alphagen stuff
	vbinds[VK_BUFF_POS].binding = VK_BUFF_POS;
	vbinds[VK_BUFF_POS].stride = sizeof(vecV_t);
	vbinds[VK_BUFF_POS].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_POS].binding = vbinds[VK_BUFF_POS].binding;
	vattrs[VK_BUFF_POS].location = VK_BUFF_POS;
	vattrs[VK_BUFF_POS].format = VK_FORMAT_R32G32B32_SFLOAT;
	vattrs[VK_BUFF_POS].offset = 0;
	vbinds[VK_BUFF_TC].binding = VK_BUFF_TC;
	vbinds[VK_BUFF_TC].stride = sizeof(vec2_t);
	vbinds[VK_BUFF_TC].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_TC].binding = vbinds[VK_BUFF_TC].binding;
	vattrs[VK_BUFF_TC].location = VK_BUFF_TC;
	vattrs[VK_BUFF_TC].format = VK_FORMAT_R32G32_SFLOAT;
	vattrs[VK_BUFF_TC].offset = 0;
	vbinds[VK_BUFF_COL].binding = VK_BUFF_COL;
	vbinds[VK_BUFF_COL].stride = sizeof(vec4_t);
	vbinds[VK_BUFF_COL].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_COL].binding = vbinds[VK_BUFF_COL].binding;
	vattrs[VK_BUFF_COL].location = VK_BUFF_COL;
	vattrs[VK_BUFF_COL].format = VK_FORMAT_R32G32B32A32_SFLOAT;
	vattrs[VK_BUFF_COL].offset = 0;
	vbinds[VK_BUFF_LMTC].binding = VK_BUFF_LMTC;
	vbinds[VK_BUFF_LMTC].stride = sizeof(vec2_t);
	vbinds[VK_BUFF_LMTC].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_LMTC].binding = vbinds[VK_BUFF_LMTC].binding;
	vattrs[VK_BUFF_LMTC].location = VK_BUFF_LMTC;
	vattrs[VK_BUFF_LMTC].format = VK_FORMAT_R32G32_SFLOAT;
	vattrs[VK_BUFF_LMTC].offset = 0;

	//fixme: in all seriousness, why is this not a single buffer?
	vbinds[VK_BUFF_NORM].binding = VK_BUFF_NORM;
	vbinds[VK_BUFF_NORM].stride = sizeof(vec3_t);
	vbinds[VK_BUFF_NORM].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_NORM].binding = vbinds[VK_BUFF_NORM].binding;
	vattrs[VK_BUFF_NORM].location = VK_BUFF_NORM;
	vattrs[VK_BUFF_NORM].format = VK_FORMAT_R32G32B32_SFLOAT;
	vattrs[VK_BUFF_NORM].offset = 0;
	vbinds[VK_BUFF_SDIR].binding = VK_BUFF_SDIR;
	vbinds[VK_BUFF_SDIR].stride = sizeof(vec3_t);
	vbinds[VK_BUFF_SDIR].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_SDIR].binding = vbinds[VK_BUFF_SDIR].binding;
	vattrs[VK_BUFF_SDIR].location = VK_BUFF_SDIR;
	vattrs[VK_BUFF_SDIR].format = VK_FORMAT_R32G32B32_SFLOAT;
	vattrs[VK_BUFF_SDIR].offset = 0;
	vbinds[VK_BUFF_TDIR].binding = VK_BUFF_TDIR;
	vbinds[VK_BUFF_TDIR].stride = sizeof(vec3_t);
	vbinds[VK_BUFF_TDIR].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	vattrs[VK_BUFF_TDIR].binding = vbinds[VK_BUFF_TDIR].binding;
	vattrs[VK_BUFF_TDIR].location = VK_BUFF_TDIR;
	vattrs[VK_BUFF_TDIR].format = VK_FORMAT_R32G32B32_SFLOAT;
	vattrs[VK_BUFF_TDIR].offset = 0;

	vi.vertexBindingDescriptionCount = countof(vbinds);
	vi.pVertexBindingDescriptions = vbinds;
	vi.vertexAttributeDescriptionCount = countof(vattrs);
	vi.pVertexAttributeDescriptions = vattrs;

	ia.topology = (blendflags&SBITS_LINES)?VK_PRIMITIVE_TOPOLOGY_LINE_LIST:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
	vp.viewportCount = 1;
	dynamicStateEnables[dyn.dynamicStateCount++] =	VK_DYNAMIC_STATE_VIEWPORT;
	vp.scissorCount = 1;
	dynamicStateEnables[dyn.dynamicStateCount++] =	VK_DYNAMIC_STATE_SCISSOR;
	//FIXME: fillModeNonSolid might mean mode_line is not supported.
	rs.polygonMode = (permu&PERMUTATION_BEM_WIREFRAME)?VK_POLYGON_MODE_LINE:VK_POLYGON_MODE_FILL;
	rs.lineWidth = 1;
	rs.cullMode = ((shaderflags&SHADER_CULL_FRONT)?VK_CULL_MODE_FRONT_BIT:0) | ((shaderflags&SHADER_CULL_BACK)?VK_CULL_MODE_BACK_BIT:0);
	rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
	rs.depthClampEnable = VK_FALSE;
	rs.rasterizerDiscardEnable = VK_FALSE;
	if (shaderflags & SHADER_POLYGONOFFSET)
	{
		rs.depthBiasEnable = VK_TRUE;
		rs.depthBiasConstantFactor = -25;//shader->polyoffset.unit;
		rs.depthBiasClamp = 0;
		rs.depthBiasSlopeFactor = -0.05;//shader->polyoffset.factor;
	}
	else
		rs.depthBiasEnable = VK_FALSE;

	if (vk.amd_rasterization_order)
	{
		unsigned int b = blendflags & SBITS_BLEND_BITS;
		//we potentially allow a little z-fighting if they're equal. a single batch shouldn't really have such primitives.
		//must be no blending, or additive blending.
		switch(blendflags & SBITS_DEPTHFUNC_BITS)
		{
		case SBITS_DEPTHFUNC_EQUAL:
			break;
		default:
			if ((blendflags&(SBITS_MISC_NODEPTHTEST|SBITS_MISC_DEPTHWRITE)) == SBITS_MISC_DEPTHWRITE &&
				(!b || b == (SBITS_SRCBLEND_ONE|SBITS_DSTBLEND_ZERO) || b == SBITS_DSTBLEND_ONE))
			{
				rs.pNext = &ro;
				ro.rasterizationOrder = VK_RASTERIZATION_ORDER_RELAXED_AMD;
			}
		}
	}

	ms.pSampleMask = NULL;
	if (permu & PERMUTATION_BEM_MULTISAMPLE)
		ms.rasterizationSamples = vk.multisamplebits;
	else
		ms.rasterizationSamples = 1;
//	ms.sampleShadingEnable = VK_TRUE;	//call the fragment shader multiple times, instead of just once per final pixel
//	ms.minSampleShading = 0.25;
	ds.depthTestEnable = (blendflags&SBITS_MISC_NODEPTHTEST)?VK_FALSE:VK_TRUE;
	ds.depthWriteEnable = (blendflags&SBITS_MISC_DEPTHWRITE)?VK_TRUE:VK_FALSE;
	switch(blendflags & SBITS_DEPTHFUNC_BITS)
	{
	default:
	case SBITS_DEPTHFUNC_CLOSEREQUAL:	ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;	break;
	case SBITS_DEPTHFUNC_EQUAL:			ds.depthCompareOp = VK_COMPARE_OP_EQUAL;			break;
	case SBITS_DEPTHFUNC_CLOSER:		ds.depthCompareOp = VK_COMPARE_OP_LESS;				break;
	case SBITS_DEPTHFUNC_FURTHER:		ds.depthCompareOp = VK_COMPARE_OP_GREATER;			break;
	}
	ds.depthBoundsTestEnable = VK_FALSE;
	ds.back.failOp = VK_STENCIL_OP_KEEP;
	ds.back.passOp = VK_STENCIL_OP_KEEP;
	ds.back.compareOp = VK_COMPARE_OP_NEVER;//VK_COMPARE_OP_ALWAYS;
	ds.stencilTestEnable = VK_FALSE;
	ds.front = ds.back;
	memset(att_state, 0, sizeof(att_state));
	att_state[0].colorWriteMask =
		((blendflags&SBITS_MASK_RED)?0:VK_COLOR_COMPONENT_R_BIT) |
		((blendflags&SBITS_MASK_GREEN)?0:VK_COLOR_COMPONENT_G_BIT) |
		((blendflags&SBITS_MASK_BLUE)?0:VK_COLOR_COMPONENT_B_BIT) |
		((blendflags&SBITS_MASK_ALPHA)?0:VK_COLOR_COMPONENT_A_BIT);

	if ((blendflags & SBITS_BLEND_BITS) && (blendflags & SBITS_BLEND_BITS)!=(SBITS_SRCBLEND_ONE|SBITS_DSTBLEND_ZERO))
	{
		switch(blendflags & SBITS_SRCBLEND_BITS)
		{
		case SBITS_SRCBLEND_ZERO:					att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ZERO;				att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;				break;
		case SBITS_SRCBLEND_ONE:					att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE;					att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;					break;
		case SBITS_SRCBLEND_DST_COLOR:				att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_DST_COLOR;			att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;			break;
		case SBITS_SRCBLEND_ONE_MINUS_DST_COLOR:	att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;	att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;	break;
		case SBITS_SRCBLEND_SRC_ALPHA:				att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;			att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;			break;
		case SBITS_SRCBLEND_ONE_MINUS_SRC_ALPHA:	att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;	att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;	break;
		case SBITS_SRCBLEND_DST_ALPHA:				att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;			att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;			break;
		case SBITS_SRCBLEND_ONE_MINUS_DST_ALPHA:	att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;	att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;	break;
		case SBITS_SRCBLEND_ALPHA_SATURATE:			att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;	att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;	break;
		default:	Sys_Error("Bad shader blend src\n"); return;
		}
		switch(blendflags & SBITS_DSTBLEND_BITS)
		{
		case SBITS_DSTBLEND_ZERO:					att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;				att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;				break;
		case SBITS_DSTBLEND_ONE:					att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE;					att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;					break;
		case SBITS_DSTBLEND_SRC_ALPHA:				att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;			att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;			break;
		case SBITS_DSTBLEND_ONE_MINUS_SRC_ALPHA:	att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;	att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;	break;
		case SBITS_DSTBLEND_DST_ALPHA:				att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;			att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;			break;
		case SBITS_DSTBLEND_ONE_MINUS_DST_ALPHA:	att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;	att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;	break;
		case SBITS_DSTBLEND_SRC_COLOR:				att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_SRC_COLOR;			att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;			break;
		case SBITS_DSTBLEND_ONE_MINUS_SRC_COLOR:	att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;	att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;	break;
		default:	Sys_Error("Bad shader blend dst\n"); return;
		}
		att_state[0].colorBlendOp = VK_BLEND_OP_ADD;
		att_state[0].alphaBlendOp = VK_BLEND_OP_ADD;
		att_state[0].blendEnable = VK_TRUE;
	}
	else
	{
		att_state[0].blendEnable = VK_FALSE;
	}
	if (permu&PERMUTATION_BEM_DEPTHONLY)
		cb.attachmentCount = 0;
	else
		cb.attachmentCount = 1;
	cb.pAttachments = att_state;


	s = 0;
	specentries[s].constantID = 0;
	specentries[s].offset = offsetof(struct specdata_s, alphamode);
	specentries[s].size = sizeof(specdata.alphamode);
	s++;
	if (blendflags & SBITS_ATEST_GE128)
		specdata.alphamode = 3;
	else if (blendflags & SBITS_ATEST_GT0)
		specdata.alphamode = 2;
	else if (blendflags & SBITS_ATEST_LT128)
		specdata.alphamode = 1;
	else //if (blendflags & SBITS_ATEST_NONE)
		specdata.alphamode = 0;

	for (i = 0; i < countof(specdata.permu); i++)
	{
		specentries[s].constantID = 16+i;
		specentries[s].offset = offsetof(struct specdata_s, permu[i]);
		specentries[s].size = sizeof(specdata.permu[i]);
		s++;
		specdata.permu[i] = !!(permu & (1u<<i));
	}

	//cvars
	for (cvardata = p->cvardata, i = 0; cvardata < p->cvardata + p->cvardatasize; )
	{
		unsigned short id = (cvardata[0]<<8)|cvardata[1];
		unsigned char type = cvardata[2], size = cvardata[3]-'0';
		char *name;
		cvar_t *var;
		unsigned int u;

		cvardata += 4;
		name = cvardata;
		cvardata += strlen(name)+1;

		if (i + size > countof(specdata.cvars))
			break;	//error

		if (type >= 'A' && type <= 'Z')
		{	//args will be handled by the blob loader.
			for (u = 0; u < size && u < 4; u++)
			{
				specentries[s].constantID = id;
				specentries[s].offset = offsetof(struct specdata_s, cvars[i]);
				specentries[s].size = sizeof(specdata.cvars[i]);

				specdata.cvars[i].i = (cvardata[u*4+0]<<24)|(cvardata[u*4+1]<<16)|(cvardata[u*4+2]<<8)|(cvardata[u*4+3]<<0);
				s++;
				i++;
				id++;
			}
		}
		else
		{
			var = Cvar_FindVar(name);
			if (var)
			{
				for (u = 0; u < size && u < 4; u++)
				{
					specentries[s].constantID = id;
					specentries[s].offset = offsetof(struct specdata_s, cvars[i]);
					specentries[s].size = sizeof(specdata.cvars[i]);

					if (type == 'i')
						specdata.cvars[i].i = var->ival;
					else
						specdata.cvars[i].f = var->vec4[u];
					s++;
					i++;
					id++;
				}
			}
		}
		cvardata += 4*size;
	}

	specInfo.mapEntryCount = s;
	specInfo.pMapEntries = specentries;
	specInfo.dataSize = sizeof(specdata);
	specInfo.pData = &specdata;

#if 0//def _DEBUG
	//vk_layer_lunarg_drawstate fucks up and pokes invalid bits of stack.
	bugsbeware = Z_Malloc(sizeof(*bugsbeware) + sizeof(*specentries)*s + sizeof(specdata));
	*bugsbeware = specInfo;
	bugsbeware->pData = bugsbeware+1;
	bugsbeware->pMapEntries = (VkSpecializationMapEntry*)((char*)bugsbeware->pData + specInfo.dataSize);
	memcpy((void*)bugsbeware->pData, specInfo.pData, specInfo.dataSize);
	memcpy((void*)bugsbeware->pMapEntries, specInfo.pMapEntries, sizeof(*specInfo.pMapEntries)*specInfo.mapEntryCount);
#else
	bugsbeware = &specInfo;
#endif
	//fixme: add more specialisations for custom cvars (yes, this'll flush+reload pipelines if they're changed)
	//fixme: add specialisations for permutations I guess
	//fixme: add geometry+tesselation support. because we can.

	shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
	shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
	shaderStages[0].module = p->vert;
	shaderStages[0].pName = "main";
	shaderStages[0].pSpecializationInfo = bugsbeware;
	shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
	shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
	shaderStages[1].module = p->frag;
	shaderStages[1].pName = "main";
	shaderStages[1].pSpecializationInfo = bugsbeware;

	pipeCreateInfo.flags				= 0;
	pipeCreateInfo.stageCount			= countof(shaderStages);
	pipeCreateInfo.pStages				= shaderStages;
	pipeCreateInfo.pVertexInputState	= &vi;
	pipeCreateInfo.pInputAssemblyState	= &ia;
	pipeCreateInfo.pTessellationState	= NULL;	//null is okay!
	pipeCreateInfo.pViewportState		= &vp;
	pipeCreateInfo.pRasterizationState	= &rs;
	pipeCreateInfo.pMultisampleState	= &ms;
	pipeCreateInfo.pDepthStencilState	= &ds;
	pipeCreateInfo.pColorBlendState		= &cb;
	pipeCreateInfo.pDynamicState		= &dyn;
	pipeCreateInfo.layout				= p->layout;
	i = (permu&PERMUTATION_BEM_DEPTHONLY)?RP_DEPTHONLY:RP_FULLCLEAR;
	if (permu&PERMUTATION_BEM_MULTISAMPLE)
		i |= RP_MULTISAMPLE;
	if (permu&PERMUTATION_BEM_FP16)
		i |= RP_FP16;
	if (permu&PERMUTATION_BEM_VR)
		i |= RP_VR;
	pipeCreateInfo.renderPass			= VK_GetRenderPass(i);
	pipeCreateInfo.subpass				= 0;
	pipeCreateInfo.basePipelineHandle	= VK_NULL_HANDLE;
	pipeCreateInfo.basePipelineIndex	= -1;	//used to create derivatives for pipelines created in the same call.

//	pipeCreateInfo.flags = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT;

	err = vkCreateGraphicsPipelines(vk.device, vk.pipelinecache, 1, &pipeCreateInfo, vkallocationcb, &pipe->pipeline);
	DebugSetName(VK_OBJECT_TYPE_PIPELINE, (uint64_t)pipe->pipeline, p->name);

	if (err)
	{	//valid err values are VK_ERROR_OUT_OF_HOST_MEMORY, VK_ERROR_OUT_OF_DEVICE_MEMORY, VK_ERROR_INVALID_SHADER_NV
		//VK_INCOMPLETE is a Qualcom bug with certain spirv-opt optimisations.
		shaderstate.rc.activepipeline = VK_NULL_HANDLE;
		Sys_Error("%s creating pipeline %s for material %s. Check spir-v modules / drivers.\n", VK_VKErrorToString(err), p->name, shaderstate.curshader->name);
		return;
	}

	vkCmdBindPipeline(vk.rendertarg->cbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, shaderstate.rc.activepipeline=pipe->pipeline);
}
static void BE_BindPipeline(program_t *p, unsigned int shaderflags, unsigned int blendflags, unsigned int permu)
{
	struct pipeline_s *pipe;
	blendflags &=	0
					| SBITS_SRCBLEND_BITS | SBITS_DSTBLEND_BITS | SBITS_MASK_BITS | SBITS_ATEST_BITS
					| SBITS_MISC_DEPTHWRITE | SBITS_MISC_NODEPTHTEST | SBITS_DEPTHFUNC_BITS
					| SBITS_LINES
					;
	shaderflags &= 0
					| SHADER_CULL_FRONT | SHADER_CULL_BACK
					| SHADER_POLYGONOFFSET
					;
	permu |= shaderstate.modepermutation;

	if (shaderflags & (SHADER_CULL_FRONT | SHADER_CULL_BACK))
		shaderflags ^= r_refdef.flipcull;

	for (pipe = p->pipelines; pipe; pipe = pipe->next)
	{
		if (pipe->flags == shaderflags)
			if (pipe->blendbits == blendflags)
				if (pipe->permu == permu)
				{
					if (pipe->pipeline != shaderstate.rc.activepipeline)
					{
						shaderstate.rc.activepipeline = pipe->pipeline;
						if (shaderstate.rc.activepipeline)
							vkCmdBindPipeline(vk.rendertarg->cbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, shaderstate.rc.activepipeline);
					}
					return;
				}
	}

	//oh look. we need to build an entirely new pipeline object. hurrah... not.
	//split into a different function because of abusive stack combined with windows stack probes.
	BE_CreatePipeline(p, shaderflags, blendflags, permu);
}

static void BE_SetupTextureDescriptor(texid_t tex, texid_t fallbacktex, VkDescriptorSet set, VkWriteDescriptorSet *firstdesc, VkWriteDescriptorSet *desc, VkDescriptorImageInfo *img)
{
	if (!tex || !tex->vkimage)
		tex = fallbacktex;

	desc->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
	desc->pNext = NULL;
	desc->dstSet = set;
	desc->dstBinding = desc-firstdesc;
	desc->dstArrayElement = 0;
	desc->descriptorCount = 1;
	desc->descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
	img->imageLayout = tex->vkimage->layout;
	img->imageView = tex->vkimage->view;
	img->sampler = tex->vkimage->sampler;
	desc->pImageInfo = img;
	desc->pBufferInfo = NULL;
	desc->pTexelBufferView = NULL;
}
static void BE_SetupUBODescriptor(VkDescriptorSet set, VkWriteDescriptorSet *firstdesc, VkWriteDescriptorSet *desc, VkDescriptorBufferInfo *info)
{
	desc->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
	desc->pNext = NULL;
	desc->dstSet = set;
	desc->dstBinding = desc-firstdesc;
	desc->dstArrayElement = 0;
	desc->descriptorCount = 1;
	desc->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
	desc->pImageInfo = NULL;
	desc->pBufferInfo = info;
	desc->pTexelBufferView = NULL;
}

static qboolean BE_SetupMeshProgram(program_t *p, shaderpass_t *pass, unsigned int shaderbits, unsigned int idxcount)
{
	int perm = 0;
	if (!p)
		return false;

	if (TEXLOADED(shaderstate.curtexnums->bump))
		perm |= PERMUTATION_BUMPMAP;
	if (TEXLOADED(shaderstate.curtexnums->fullbright))
		perm |= PERMUTATION_FULLBRIGHT;
	if (TEXLOADED(shaderstate.curtexnums->upperoverlay) || TEXLOADED(shaderstate.curtexnums->loweroverlay))
		perm |= PERMUTATION_UPPERLOWER;
	if (TEXLOADED(shaderstate.curtexnums->reflectcube) || TEXLOADED(shaderstate.curtexnums->reflectmask))
		perm |= PERMUTATION_REFLECTCUBEMASK;
	if (r_refdef.globalfog.density)
		perm |= PERMUTATION_FOG;
//	if (r_glsl_offsetmapping.ival && TEXLOADED(shaderstate.curtexnums->bump))
//		perm |= PERMUTATION_OFFSET;
	perm &= p->supportedpermutations;

	BE_BindPipeline(p, shaderbits, VKBE_ApplyShaderBits(pass->shaderbits), perm);
	if (!shaderstate.rc.activepipeline)
		return false;	//err, something bad happened.

	//most gpus will have a fairly low descriptor set limit of 4 (this is the minimum required)
	//that isn't enough for all our textures, so we need to make stuff up as required.
	{
		VkDescriptorSet set = shaderstate.rc.descriptorsets[0] = vk.khr_push_descriptor?VK_NULL_HANDLE:VKBE_TempDescriptorSet(p->desclayout);
		VkWriteDescriptorSet descs[MAX_TMUS], *desc = descs;
		VkDescriptorImageInfo imgs[MAX_TMUS], *img = imgs;
		unsigned int i;
		texid_t t;
		//why do I keep wanting to write 'desk'? its quite annoying.

		//light / scene
		BE_SetupUBODescriptor(set, descs, desc++, &shaderstate.ubo_entity);
		BE_SetupUBODescriptor(set, descs, desc++, &shaderstate.ubo_light);
		if (p->defaulttextures & (1u<<S_SHADOWMAP))
			BE_SetupTextureDescriptor(shaderstate.currentshadowmap, r_whiteimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_PROJECTIONMAP))
			BE_SetupTextureDescriptor(shaderstate.curdlight?shaderstate.curdlight->cubetexture:r_nulltex, r_whitecubeimage, set, descs, desc++, img++);

		//material
		if (p->defaulttextures & (1u<<S_DIFFUSE))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->base, r_blackimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_NORMALMAP))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->bump, missing_texture_normal, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_SPECULAR))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->specular, missing_texture_gloss, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_UPPERMAP))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->upperoverlay, r_blackimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_LOWERMAP))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->loweroverlay, r_blackimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_FULLBRIGHT))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->fullbright, r_blackimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_PALETTED))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->paletted, r_blackimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_REFLECTCUBE))
		{
			if (shaderstate.curtexnums && TEXLOADED(shaderstate.curtexnums->reflectcube))
				t = shaderstate.curtexnums->reflectcube;
			else if (shaderstate.curbatch->envmap)
				t = shaderstate.curbatch->envmap;
			else
				t = r_blackcubeimage;	//FIXME
			BE_SetupTextureDescriptor(t, r_blackcubeimage, set, descs, desc++, img++);
		}
		if (p->defaulttextures & (1u<<S_REFLECTMASK))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->reflectmask, r_whiteimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_DISPLACEMENT))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->displacement, r_whiteimage, set, descs, desc++, img++);
		if (p->defaulttextures & (1u<<S_OCCLUSION))
			BE_SetupTextureDescriptor(shaderstate.curtexnums->occlusion, r_whiteimage, set, descs, desc++, img++);

		//batch
		if (p->defaulttextures & (1u<<S_LIGHTMAP0))
		{
			unsigned int lmi = shaderstate.curbatch->lightmap[0];
			BE_SetupTextureDescriptor((lmi<numlightmaps)?lightmap[lmi]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
		}
		if (p->defaulttextures & (1u<<S_DELUXEMAP0))
		{
			texid_t delux = NULL;
			unsigned int lmi = shaderstate.curbatch->lightmap[0];
			if (lmi<numlightmaps && lightmap[lmi]->hasdeluxe)
				delux = lightmap[lmi+1]->lightmap_texture;
			BE_SetupTextureDescriptor(delux, r_whiteimage, set, descs, desc++, img++);
		}
#if MAXRLIGHTMAPS > 1
		if (p->defaulttextures & ((1u<<S_LIGHTMAP1)|(1u<<S_LIGHTMAP2)|(1u<<S_LIGHTMAP3)))
		{
			int lmi = shaderstate.curbatch->lightmap[1];
			BE_SetupTextureDescriptor((lmi<numlightmaps)?lightmap[lmi]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
			lmi = shaderstate.curbatch->lightmap[2];
			BE_SetupTextureDescriptor((lmi<numlightmaps)?lightmap[lmi]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
			lmi = shaderstate.curbatch->lightmap[3];
			BE_SetupTextureDescriptor((lmi<numlightmaps)?lightmap[lmi]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
		}
		if (p->defaulttextures & ((1u<<S_DELUXEMAP1)|(1u<<S_DELUXEMAP2)|(1u<<S_DELUXEMAP3)))
		{
			int lmi = shaderstate.curbatch->lightmap[1];
			if (lmi<numlightmaps && lightmap[lmi]->hasdeluxe)
			{
				BE_SetupTextureDescriptor((lmi+1<numlightmaps)?lightmap[lmi+1]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
				lmi = shaderstate.curbatch->lightmap[2];
				BE_SetupTextureDescriptor((lmi+1<numlightmaps)?lightmap[lmi+1]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
				lmi = shaderstate.curbatch->lightmap[3];
				BE_SetupTextureDescriptor((lmi+1<numlightmaps)?lightmap[lmi+1]->lightmap_texture:NULL, r_whiteimage, set, descs, desc++, img++);
			}
			else
			{
				BE_SetupTextureDescriptor(NULL, r_whiteimage, set, descs, desc++, img++);
				BE_SetupTextureDescriptor(NULL, r_whiteimage, set, descs, desc++, img++);
				BE_SetupTextureDescriptor(NULL, r_whiteimage, set, descs, desc++, img++);
			}
		}
#endif

		//shader / pass
		for (i = 0; i < p->numsamplers; i++)
			BE_SetupTextureDescriptor(SelectPassTexture(pass+i), r_blackimage, set, descs, desc++, img++);

		if (!set)
			vkCmdPushDescriptorSetKHR(vk.rendertarg->cbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, p->layout, 0, desc-descs, descs);
		else
			vkUpdateDescriptorSets(vk.device, desc-descs, descs, 0, NULL);
	}
	if (!vk.khr_push_descriptor)
		vkCmdBindDescriptorSets(vk.rendertarg->cbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, p->layout, 0, countof(shaderstate.rc.descriptorsets), shaderstate.rc.descriptorsets, 0, NULL);

	RQuantAdd(RQUANT_PRIMITIVEINDICIES, idxcount);
	RQuantAdd(RQUANT_DRAWS, 1);

	return true;
}

static void BE_DrawMeshChain_Internal(void)
{
	shader_t *altshader;
	unsigned int vertcount, idxcount, idxfirst;
	mesh_t *m;
	qboolean vblends;	//software
//	void *map;
//	int i;
	unsigned int mno;
	unsigned int passno;
	//extern cvar_t r_polygonoffset_submodel_factor;
//	float pushdepth;
//	float pushfactor;

	//I wasn't going to do this... but gah.
	VkBuffer vertexbuffers[VK_BUFF_MAX];
	VkDeviceSize vertexoffsets[VK_BUFF_MAX];

	altshader = shaderstate.curshader;
	switch (shaderstate.mode)
	{
	case BEM_LIGHT:
		altshader = shaderstate.shader_rtlight[shaderstate.curlmode];
		break;
	case BEM_DEPTHONLY:
		altshader = shaderstate.curshader->bemoverrides[bemoverride_depthonly];
		if (!altshader)
			altshader = shaderstate.depthonly;
		break;
	case BEM_WIREFRAME:
		altshader = R_RegisterShader("wireframe", SUF_NONE, 
			"{\n"
				"{\n"
					"map $whiteimage\n"
				"}\n"
			"}\n"
			);
		break;
	default:
	case BEM_STANDARD:
		altshader = shaderstate.curshader;
		break;
	}
	if (!altshader)
		return;

	if (shaderstate.forcebeflags & BEF_FORCENODEPTH)
	{
		RQuantAdd(RQUANT_2DBATCHES, 1);
	}
	else if (shaderstate.curentity == &r_worldentity)
	{
		RQuantAdd(RQUANT_WORLDBATCHES, 1);
	}
	else
	{
		RQuantAdd(RQUANT_ENTBATCHES, 1);
	}

	if (altshader->flags & SHADER_HASCURRENTRENDER)
		T_Gen_CurrentRender();	//requires lots of pass-related work...

	//if this flag is set, then we have to generate our own arrays. to avoid processing extra verticies this may require that we re-pack the verts
	if (shaderstate.meshlist[0]->xyz2_array)// && !altshader->prog)
	{
		vblends = true;
		shaderstate.batchvbo = NULL;
	}
	else
	{
		vblends = false;
		if (altshader->flags & SHADER_NEEDSARRAYS)
			shaderstate.batchvbo = NULL;
		else if (shaderstate.curshader->numdeforms)
			shaderstate.batchvbo = NULL;
	}

	/*index buffers are common to all passes*/
	if (shaderstate.batchvbo)
	{
		/*however, we still want to try to avoid discontinuities, because that would otherwise be more draw calls. we can have gaps in verts though*/
		if (shaderstate.nummeshes == 1)
		{
			m = shaderstate.meshlist[0];

			vkCmdBindIndexBuffer(vk.rendertarg->cbuf, shaderstate.batchvbo->indicies.vk.buff, shaderstate.batchvbo->indicies.vk.offs, VK_INDEX_TYPE);
			idxfirst = m->vbofirstelement;

			vertcount = m->vbofirstvert + m->numvertexes;
			idxcount = m->numindexes;
		}
		else if (0)//shaderstate.nummeshes == shaderstate.curbatch->maxmeshes)
		{
			idxfirst = 0;
			vertcount = shaderstate.batchvbo->vertcount;
			idxcount = shaderstate.batchvbo->indexcount;

			vkCmdBindIndexBuffer(vk.rendertarg->cbuf, shaderstate.batchvbo->indicies.vk.buff, shaderstate.batchvbo->indicies.vk.offs, VK_INDEX_TYPE);
		}
		else
		{
			index_t *fte_restrict map;
			VkBuffer buf;
			unsigned int i;
			VkDeviceSize offset;
			vertcount = shaderstate.batchvbo->vertcount;
			for (mno = 0, idxcount = 0; mno < shaderstate.nummeshes; mno++)
			{
				m = shaderstate.meshlist[mno];
				idxcount += m->numindexes;
			}
			map = VKBE_AllocateBufferSpace(DB_EBO, idxcount * sizeof(*map), &buf, &offset);
			for (mno = 0; mno < shaderstate.nummeshes; mno++)
			{
				m = shaderstate.meshlist[mno];
				for (i = 0; i < m->numindexes; i++)
					map[i] = m->indexes[i]+m->vbofirstvert;
				map += m->numindexes;
			}
			vkCmdBindIndexBuffer(vk.rendertarg->cbuf, buf, offset, VK_INDEX_TYPE);
			idxfirst = 0;
		}
	}
	else
	{	/*we're going to be using dynamic array stuff here, so generate an index array list that has no vertex gaps*/
		index_t *fte_restrict map;
		VkBuffer buf;
		unsigned int i;
		VkDeviceSize offset;
		for (mno = 0, vertcount = 0, idxcount = 0; mno < shaderstate.nummeshes; mno++)
		{
			m = shaderstate.meshlist[mno];
			vertcount += m->numvertexes;
			idxcount += m->numindexes;
		}

		map = VKBE_AllocateBufferSpace(DB_EBO, idxcount * sizeof(*map), &buf, &offset);
		for (mno = 0, vertcount = 0; mno < shaderstate.nummeshes; mno++)
		{
			m = shaderstate.meshlist[mno];
			if (!vertcount)
				memcpy(map, m->indexes, sizeof(index_t)*m->numindexes);
			else
			{
				for (i = 0; i < m->numindexes; i++)
					map[i] = m->indexes[i]+vertcount;
			}
			map += m->numindexes;
			vertcount += m->numvertexes;
		}
		vkCmdBindIndexBuffer(vk.rendertarg->cbuf, buf, offset, VK_INDEX_TYPE);
		idxfirst = 0;
	}

	/*vertex buffers are common to all passes*/
	if (shaderstate.batchvbo && !vblends)
	{
		vertexbuffers[VK_BUFF_POS] = shaderstate.batchvbo->coord.vk.buff;
		vertexoffsets[VK_BUFF_POS] = shaderstate.batchvbo->coord.vk.offs;
	}
	else
	{
		vecV_t *fte_restrict map;
		const mesh_t *m;
		unsigned int mno;
		unsigned int i;

		map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vecV_t), &vertexbuffers[VK_BUFF_POS], &vertexoffsets[VK_BUFF_POS]);
		
		if (vblends)
		{
			for (mno = 0; mno < shaderstate.nummeshes; mno++)
			{
				const mesh_t *m = shaderstate.meshlist[mno];
				vecV_t *ov = shaderstate.curshader->numdeforms?tmpbuf:map;
				vecV_t *iv1 = m->xyz_array;
				vecV_t *iv2 = m->xyz2_array;
				float w1 = m->xyz_blendw[0];
				float w2 = m->xyz_blendw[1];
				for (i = 0; i < m->numvertexes; i++)
				{
					ov[i][0] = iv1[i][0]*w1 + iv2[i][0]*w2;
					ov[i][1] = iv1[i][1]*w1 + iv2[i][1]*w2;
					ov[i][2] = iv1[i][2]*w1 + iv2[i][2]*w2;
				}
				if (shaderstate.curshader->numdeforms)
				{
					for (i = 0; i < shaderstate.curshader->numdeforms-1; i++)
						deformgen(&shaderstate.curshader->deforms[i], m->numvertexes, tmpbuf, tmpbuf, m);
					deformgen(&shaderstate.curshader->deforms[i], m->numvertexes, tmpbuf, map, m);
				}
				map += m->numvertexes;
			}
		}
		else if (shaderstate.curshader->numdeforms > 1)
		{	//horrible code, because multiple deforms would otherwise READ from the gpu memory
			for (mno = 0; mno < shaderstate.nummeshes; mno++)
			{
				m = shaderstate.meshlist[mno];
				deformgen(&shaderstate.curshader->deforms[0], m->numvertexes, m->xyz_array, tmpbuf, m);
				for (i = 1; i < shaderstate.curshader->numdeforms-1; i++)
					deformgen(&shaderstate.curshader->deforms[i], m->numvertexes, tmpbuf, tmpbuf, m);
				deformgen(&shaderstate.curshader->deforms[i], m->numvertexes, tmpbuf, map, m);
				map += m->numvertexes;
			}
		}
		else
		{
			for (mno = 0; mno < shaderstate.nummeshes; mno++)
			{
				m = shaderstate.meshlist[mno];
				deformgen(&shaderstate.curshader->deforms[0], m->numvertexes, m->xyz_array, map, m);
				map += m->numvertexes;
			}
		}
	}

	if (altshader->prog)
	{
		if (shaderstate.batchvbo)
		{
			vertexbuffers[VK_BUFF_COL] = shaderstate.batchvbo->colours[0].vk.buff;
			vertexoffsets[VK_BUFF_COL] = shaderstate.batchvbo->colours[0].vk.offs;
			vertexbuffers[VK_BUFF_TC]  = shaderstate.batchvbo->texcoord.vk.buff;
			vertexoffsets[VK_BUFF_TC]  = shaderstate.batchvbo->texcoord.vk.offs;
			vertexbuffers[VK_BUFF_LMTC]= shaderstate.batchvbo->lmcoord[0].vk.buff;
			vertexoffsets[VK_BUFF_LMTC]= shaderstate.batchvbo->lmcoord[0].vk.offs;

			vertexbuffers[VK_BUFF_NORM]= shaderstate.batchvbo->normals.vk.buff;
			vertexoffsets[VK_BUFF_NORM]= shaderstate.batchvbo->normals.vk.offs;
			vertexbuffers[VK_BUFF_SDIR]= shaderstate.batchvbo->svector.vk.buff;
			vertexoffsets[VK_BUFF_SDIR]= shaderstate.batchvbo->svector.vk.offs;
			vertexbuffers[VK_BUFF_TDIR]= shaderstate.batchvbo->tvector.vk.buff;
			vertexoffsets[VK_BUFF_TDIR]= shaderstate.batchvbo->tvector.vk.offs;

			if (!vertexbuffers[VK_BUFF_COL])
			{
				vertexbuffers[VK_BUFF_COL] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_COL] = 0;
			}
			if (!vertexbuffers[VK_BUFF_LMTC])
			{
				vertexbuffers[VK_BUFF_LMTC] = vertexbuffers[VK_BUFF_TC];
				vertexoffsets[VK_BUFF_LMTC] = vertexoffsets[VK_BUFF_TC];
			}
		}
		else
		{
			const mesh_t *m;
			unsigned int mno;
			unsigned int i;

			if (shaderstate.meshlist[0]->normals_array[0])
			{
				vec4_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec3_t), &vertexbuffers[VK_BUFF_NORM], &vertexoffsets[VK_BUFF_NORM]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->normals_array[0], sizeof(vec3_t)*m->numvertexes);
					map += m->numvertexes;
				}
			}
			else
			{
				vertexbuffers[VK_BUFF_NORM] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_NORM] = sizeof(vec4_t)*65536;
			}

			if (shaderstate.meshlist[0]->snormals_array[0])
			{
				vec4_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec3_t), &vertexbuffers[VK_BUFF_SDIR], &vertexoffsets[VK_BUFF_SDIR]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->snormals_array[0], sizeof(vec3_t)*m->numvertexes);
					map += m->numvertexes;
				}
			}
			else
			{
				vertexbuffers[VK_BUFF_SDIR] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_SDIR] = sizeof(vec4_t)*65536 + sizeof(vec3_t)*65536;
			}

			if (shaderstate.meshlist[0]->tnormals_array[0])
			{
				vec4_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec3_t), &vertexbuffers[VK_BUFF_TDIR], &vertexoffsets[VK_BUFF_TDIR]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->tnormals_array[0], sizeof(vec3_t)*m->numvertexes);
					map += m->numvertexes;
				}
			}
			else
			{
				vertexbuffers[VK_BUFF_TDIR] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_TDIR] = sizeof(vec4_t)*65536 + sizeof(vec3_t)*65536 + sizeof(vec3_t)*65536;
			}

			if (shaderstate.meshlist[0]->colors4f_array[0])
			{
				vec4_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec4_t), &vertexbuffers[VK_BUFF_COL], &vertexoffsets[VK_BUFF_COL]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->colors4f_array[0], sizeof(vec4_t)*m->numvertexes);
					map += m->numvertexes;
				}
			}
			else if (shaderstate.meshlist[0]->colors4b_array)
			{
				vec4_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec4_t), &vertexbuffers[VK_BUFF_COL], &vertexoffsets[VK_BUFF_COL]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					for (i = 0; i < m->numvertexes; i++)
					{
						Vector4Scale(m->colors4b_array[i], (1/255.0), map[i]);
					}
					map += m->numvertexes;
				}
			}
			else
			{	//FIXME: use some predefined buffer
				vec4_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec4_t), &vertexbuffers[VK_BUFF_COL], &vertexoffsets[VK_BUFF_COL]);
				for (i = 0; i < vertcount; i++)
				{
					Vector4Set(map[i], 1, 1, 1, 1);
				}
			}

			if (shaderstate.meshlist[0]->lmst_array[0])
			{
				vec2_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec2_t), &vertexbuffers[VK_BUFF_TC], &vertexoffsets[VK_BUFF_TC]);
				vec2_t *fte_restrict lmmap = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec2_t), &vertexbuffers[VK_BUFF_LMTC], &vertexoffsets[VK_BUFF_LMTC]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->st_array, sizeof(vec2_t)*m->numvertexes);
					memcpy(lmmap, m->lmst_array[0], sizeof(vec2_t)*m->numvertexes);
					map += m->numvertexes;
					lmmap += m->numvertexes;
				}
			}
			else
			{
				vec2_t *fte_restrict map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec2_t), &vertexbuffers[VK_BUFF_TC], &vertexoffsets[VK_BUFF_TC]);
				for (mno = 0; mno < shaderstate.nummeshes; mno++)
				{
					m = shaderstate.meshlist[mno];
					memcpy(map, m->st_array, sizeof(*m->st_array)*m->numvertexes);
					map += m->numvertexes;
				}
				
				vertexbuffers[VK_BUFF_LMTC] = vertexbuffers[VK_BUFF_TC];
				vertexoffsets[VK_BUFF_LMTC] = vertexoffsets[VK_BUFF_TC];
			}
		}

		vkCmdBindVertexBuffers(vk.rendertarg->cbuf, 0, VK_BUFF_MAX, vertexbuffers, vertexoffsets);
		if (BE_SetupMeshProgram(altshader->prog, altshader->passes, altshader->flags, idxcount))
		{
//			vkCmdPushConstants(vk.rendertarg->cbuf, altshader->prog->layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(shaderstate.curtexnums->factors), shaderstate.curtexnums->factors);
			vkCmdDrawIndexed(vk.rendertarg->cbuf, idxcount, 1, idxfirst, 0, 0);
		}
	}
	else if (1)
	{
		shaderpass_t *p;

		//Vulkan has no fixed function pipeline. we emulate it if we were given no spir-v to run.

		for (passno = 0; passno < altshader->numpasses; passno += p->numMergedPasses)
		{
			p = &altshader->passes[passno];

			if (p->texgen == T_GEN_UPPEROVERLAY && !TEXLOADED(shaderstate.curtexnums->upperoverlay))
				continue;
			if (p->texgen == T_GEN_LOWEROVERLAY && !TEXLOADED(shaderstate.curtexnums->loweroverlay))
				continue;
			if (p->texgen == T_GEN_FULLBRIGHT && !TEXLOADED(shaderstate.curtexnums->fullbright))
				continue;

			if (p->prog)
			{
				if (shaderstate.batchvbo)
				{
					vertexbuffers[VK_BUFF_TC] = shaderstate.batchvbo->texcoord.vk.buff;
					vertexoffsets[VK_BUFF_TC] = shaderstate.batchvbo->texcoord.vk.offs;
					vertexbuffers[VK_BUFF_LMTC] = shaderstate.batchvbo->lmcoord[0].vk.buff;
					vertexoffsets[VK_BUFF_LMTC] = shaderstate.batchvbo->lmcoord[0].vk.offs;
				}
				else
				{
					float *map;
					map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec2_t), &vertexbuffers[VK_BUFF_TC], &vertexoffsets[VK_BUFF_TC]);
					BE_GenerateTCMods(p, map);

					vertexbuffers[VK_BUFF_LMTC] = vertexbuffers[VK_BUFF_TC];
					vertexoffsets[VK_BUFF_LMTC] = vertexoffsets[VK_BUFF_TC];
				}

				BE_GenerateColourMods(vertcount, p, &vertexbuffers[VK_BUFF_COL], &vertexoffsets[VK_BUFF_COL]);

				vertexbuffers[VK_BUFF_NORM] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_NORM] = sizeof(vec4_t)*65536;
				vertexbuffers[VK_BUFF_SDIR] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_SDIR] = vertexoffsets[VK_BUFF_NORM] + sizeof(vec3_t)*65536;
				vertexbuffers[VK_BUFF_TDIR] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_TDIR] = vertexoffsets[VK_BUFF_SDIR] + sizeof(vec3_t)*65536;

				vkCmdBindVertexBuffers(vk.rendertarg->cbuf, 0, VK_BUFF_MAX, vertexbuffers, vertexoffsets);
				if (BE_SetupMeshProgram(p->prog, p, altshader->flags, idxcount))
					vkCmdDrawIndexed(vk.rendertarg->cbuf, idxcount, 1, idxfirst, 0, 0);
				continue;
			}

			if (shaderstate.batchvbo)
			{	//texcoords are all compatible with static arrays, supposedly
				if (p->tcgen == TC_GEN_LIGHTMAP)
				{
					vertexbuffers[VK_BUFF_TC] = shaderstate.batchvbo->lmcoord[0].vk.buff;
					vertexoffsets[VK_BUFF_TC] = shaderstate.batchvbo->lmcoord[0].vk.offs;
				}
				else if (p->tcgen == TC_GEN_BASE)
				{
					vertexbuffers[VK_BUFF_TC] = shaderstate.batchvbo->texcoord.vk.buff;
					vertexoffsets[VK_BUFF_TC] = shaderstate.batchvbo->texcoord.vk.offs;
				}
				else
					Sys_Error("tcgen %u not supported\n", p->tcgen);
			}
			else
			{
				float *map;
				map = VKBE_AllocateBufferSpace(DB_VBO, vertcount * sizeof(vec2_t), &vertexbuffers[VK_BUFF_TC], &vertexoffsets[VK_BUFF_TC]);
				BE_GenerateTCMods(p, map);
			}

			vertexbuffers[VK_BUFF_LMTC] = vertexbuffers[VK_BUFF_TC];
			vertexoffsets[VK_BUFF_LMTC] = vertexoffsets[VK_BUFF_TC];

			vertexbuffers[VK_BUFF_NORM] = shaderstate.staticbuf;
			vertexoffsets[VK_BUFF_NORM] = sizeof(vec4_t)*65536;
			vertexbuffers[VK_BUFF_SDIR] = shaderstate.staticbuf;
			vertexoffsets[VK_BUFF_SDIR] = vertexoffsets[VK_BUFF_NORM] + sizeof(vec3_t)*65536;
			vertexbuffers[VK_BUFF_TDIR] = shaderstate.staticbuf;
			vertexoffsets[VK_BUFF_TDIR] = vertexoffsets[VK_BUFF_SDIR] + sizeof(vec3_t)*65536;

			if (p->flags & SHADER_PASS_NOCOLORARRAY)
			{
				avec4_t passcolour;
				static avec4_t fakesource = {1,1,1,1};
				m = shaderstate.meshlist[0];
				colourgen(p, 1, NULL, &fakesource, &passcolour, m);
				alphagen(p, 1, NULL, &fakesource, &passcolour, m);

				//make sure nothing bugs out... this should be pure white.
				vertexbuffers[VK_BUFF_COL] = shaderstate.staticbuf;
				vertexoffsets[VK_BUFF_COL] = 0;

				vkCmdBindVertexBuffers(vk.rendertarg->cbuf, 0, VK_BUFF_MAX, vertexbuffers, vertexoffsets);
				if (BE_SetupMeshProgram(shaderstate.programfixedemu[1], p, altshader->flags, idxcount))
				{
					vkCmdPushConstants(vk.rendertarg->cbuf, shaderstate.programfixedemu[1]->layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(passcolour), passcolour);
					vkCmdDrawIndexed(vk.rendertarg->cbuf, idxcount, 1, idxfirst, 0, 0);
				}
			}
			else
			{
				BE_GenerateColourMods(vertcount, p, &vertexbuffers[VK_BUFF_COL], &vertexoffsets[VK_BUFF_COL]);
				vkCmdBindVertexBuffers(vk.rendertarg->cbuf, 0, VK_BUFF_MAX, vertexbuffers, vertexoffsets);
				if (BE_SetupMeshProgram(shaderstate.programfixedemu[0], p, altshader->flags, idxcount))
					vkCmdDrawIndexed(vk.rendertarg->cbuf, idxcount, 1, idxfirst, 0, 0);
			}
		}
	}
}

void VKBE_SelectMode(backendmode_t mode)
{
	shaderstate.mode = mode;
	shaderstate.modepermutation = 0;

	if (vk.rendertarg->rpassflags & RP_MULTISAMPLE)
		shaderstate.modepermutation |= PERMUTATION_BEM_MULTISAMPLE;
	if (vk.rendertarg->rpassflags & RP_FP16)
		shaderstate.modepermutation |= PERMUTATION_BEM_FP16;
	if (vk.rendertarg->rpassflags & RP_VR)
		shaderstate.modepermutation |= PERMUTATION_BEM_VR;

	switch(mode)
	{
	default:
		break;

	case BEM_DEPTHONLY:
		shaderstate.modepermutation |= PERMUTATION_BEM_DEPTHONLY;
		break;

	case BEM_WIREFRAME:
		shaderstate.modepermutation |= PERMUTATION_BEM_WIREFRAME;
		break;

	case BEM_LIGHT:
		//fixme: is this actually needed, or just a waste of time?
		VKBE_SelectEntity(&r_worldentity);
		break;
	}
}
qboolean VKBE_GenerateRTLightShader(unsigned int lmode)
{
	if (!shaderstate.shader_rtlight[lmode])
	{
		shaderstate.shader_rtlight[lmode] = R_RegisterShader(va("rtlight%s%s%s", 
															(lmode & LSHADER_SMAP)?"#PCF=1":"#PCF=0",
															(lmode & LSHADER_SPOT)?"#SPOT=1":"#SPOT=0",
															(lmode & LSHADER_CUBE)?"#CUBE=1":"#CUBE=0")
														, SUF_NONE, LIGHTPASS_SHADER);
	}
	if (shaderstate.shader_rtlight[lmode]->flags & SHADER_NODRAW)
		return false;
	return true;
}
qboolean VKBE_SelectDLight(dlight_t *dl, vec3_t colour, vec3_t axis[3], unsigned int lmode)
{
	if (dl && TEXLOADED(dl->cubetexture))
		lmode |= LSHADER_CUBE;

	if (!VKBE_GenerateRTLightShader(lmode))
	{
		lmode &= ~(LSHADER_SMAP|LSHADER_CUBE);
		if (!VKBE_GenerateRTLightShader(lmode))
		{
			VKBE_SetupLightCBuffer(NULL, colour);
			return false;
		}
	}
	shaderstate.curdlight = dl;
	shaderstate.curlmode = lmode;

	VKBE_SetupLightCBuffer(dl, colour);
	return true;
}

void VKBE_SelectEntity(entity_t *ent)
{
	BE_RotateForEntity(ent, ent->model);
}

//fixme: create allocations within larger ring buffers, use separate staging.
void *VKBE_CreateStagingBuffer(struct stagingbuf *n, size_t size, VkBufferUsageFlags usage)
{
	void *ptr;
	VkBufferCreateInfo bufinf = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
	VkMemoryRequirements mem_reqs;
	VkMemoryAllocateInfo memAllocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};

	memset(&n->mem, 0, sizeof(n->mem));

	n->retbuf = VK_NULL_HANDLE;
	n->usage = usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
	bufinf.flags = 0;
	bufinf.size = n->size = size;
	bufinf.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
	bufinf.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	bufinf.queueFamilyIndexCount = 0;
	bufinf.pQueueFamilyIndices = NULL;
	vkCreateBuffer(vk.device, &bufinf, vkallocationcb, &n->buf);

	vkGetBufferMemoryRequirements(vk.device, n->buf, &mem_reqs);

	memAllocInfo.allocationSize = mem_reqs.size;
	memAllocInfo.memoryTypeIndex = vk_find_memory_require(mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
	if (memAllocInfo.memoryTypeIndex == ~0)
		Sys_Error("Unable to allocate buffer memory");

	VkAssert(vkAllocateMemory(vk.device, &memAllocInfo, vkallocationcb, &n->mem.memory));
	VkAssert(vkBindBufferMemory(vk.device, n->buf, n->mem.memory, n->mem.offset));
	VkAssert(vkMapMemory(vk.device, n->mem.memory, 0, n->size, 0, &ptr));

	return ptr;
}

struct fencedbufferwork
{
	struct vk_fencework fw;

	VkBuffer buf;
	vk_poolmem_t mem;
};
static void VKBE_DoneBufferStaging(void *staging)
{
	struct fencedbufferwork *n = staging;
	vkDestroyBuffer(vk.device, n->buf, vkallocationcb);
	VK_ReleasePoolMemory(&n->mem);
}
VkBuffer VKBE_FinishStaging(struct stagingbuf *n, vk_poolmem_t *mem)
{
	struct fencedbufferwork *fence;
	VkBuffer retbuf;
	
	//caller filled the staging buffer, and now wants to copy stuff to the gpu.
	vkUnmapMemory(vk.device, n->mem.memory);

	//create the hardware buffer
	if (n->retbuf)
		retbuf = n->retbuf;
	else
	{
		VkBufferCreateInfo bufinf = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};

		bufinf.flags = 0;
		bufinf.size = n->size;
		bufinf.usage = n->usage;
		bufinf.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
		bufinf.queueFamilyIndexCount = 0;
		bufinf.pQueueFamilyIndices = NULL;
		vkCreateBuffer(vk.device, &bufinf, vkallocationcb, &retbuf);
	}

	//sort out its memory
	{
		VkMemoryRequirements mem_reqs;
		vkGetBufferMemoryRequirements(vk.device, retbuf, &mem_reqs);
		if (!VK_AllocatePoolMemory(vk_find_memory_require(mem_reqs.memoryTypeBits, 0), mem_reqs.size, mem_reqs.alignment, mem))
		{
			VkMemoryAllocateInfo memAllocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
			VkMemoryDedicatedAllocateInfoKHR khr_mdai = {VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR};

			//shouldn't really happen, but just in case...
			mem_reqs.size = max(1,mem_reqs.size);

			memAllocInfo.allocationSize = mem_reqs.size;
			memAllocInfo.memoryTypeIndex = vk_find_memory_require(mem_reqs.memoryTypeBits, 0);
			if (vk.khr_dedicated_allocation)
			{
				khr_mdai.buffer = retbuf;
				khr_mdai.pNext = memAllocInfo.pNext;
				memAllocInfo.pNext = &khr_mdai;
			}

			mem->pool = NULL;
			mem->offset = 0;
			mem->size = mem_reqs.size;
			mem->memory = VK_NULL_HANDLE;

			VkAssert(vkAllocateMemory(vk.device, &memAllocInfo, vkallocationcb, &mem->memory));
		}
		VkAssert(vkBindBufferMemory(vk.device, retbuf, mem->memory, mem->offset));
	}
	

	fence = VK_FencedBegin(VKBE_DoneBufferStaging, sizeof(*fence));
	fence->buf = n->buf;
	fence->mem = n->mem;

	//FIXME: barrier?

	//add the copy command
	{
		VkBufferCopy bcr = {0};
		bcr.srcOffset = 0;
		bcr.dstOffset = 0;
		bcr.size = n->size;
		vkCmdCopyBuffer(fence->fw.cbuf, n->buf, retbuf, 1, &bcr);
	}

	//FIXME: barrier?

	VK_FencedSubmit(fence);

	return retbuf;
}

void VKBE_GenBatchVBOs(vbo_t **vbochain, batch_t *firstbatch, batch_t *stopbatch)
{
	int maxvboelements;
	int maxvboverts;
	int vert = 0, idx = 0;
	batch_t *batch;
	vbo_t *vbo;
	int i, j;
	mesh_t *m;
	index_t *vboedata;
	qbyte *vbovdatastart, *vbovdata;
	struct stagingbuf vbuf, ebuf;
	vk_poolmem_t *poolmem;

	vbo = Z_Malloc(sizeof(*vbo));

	maxvboverts = 0;
	maxvboelements = 0;
	for(batch = firstbatch; batch != stopbatch; batch = batch->next)
	{
		for (i=0 ; i<batch->maxmeshes ; i++)
		{
			m = batch->mesh[i];
			maxvboelements += m->numindexes;
			maxvboverts += m->numvertexes;
		}
	}

	if (!maxvboverts || !maxvboelements)
		return;

	//determine array offsets.
	vbovdatastart = vbovdata = NULL;
	vbo->coord.vk.offs = vbovdata-vbovdatastart;		vbovdata += sizeof(vecV_t)*maxvboverts;
	vbo->texcoord.vk.offs = vbovdata-vbovdatastart;		vbovdata += sizeof(vec2_t)*maxvboverts;
	vbo->lmcoord[0].vk.offs = vbovdata-vbovdatastart;	vbovdata += sizeof(vec2_t)*maxvboverts;
	vbo->normals.vk.offs = vbovdata-vbovdatastart;		vbovdata += sizeof(vec3_t)*maxvboverts;
	vbo->svector.vk.offs = vbovdata-vbovdatastart;		vbovdata += sizeof(vec3_t)*maxvboverts;
	vbo->tvector.vk.offs = vbovdata-vbovdatastart;		vbovdata += sizeof(vec3_t)*maxvboverts;
	vbo->colours[0].vk.offs = vbovdata-vbovdatastart;	vbovdata += sizeof(vec4_t)*maxvboverts;

	vbovdatastart = vbovdata = VKBE_CreateStagingBuffer(&vbuf, vbovdata-vbovdatastart, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
	vboedata = VKBE_CreateStagingBuffer(&ebuf, sizeof(*vboedata) * maxvboelements, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);

	vbo->indicies.vk.offs = 0;

	for(batch = firstbatch; batch != stopbatch; batch = batch->next)
	{
		batch->vbo = vbo;
		for (j=0 ; j<batch->maxmeshes ; j++)
		{
			m = batch->mesh[j];
			m->vbofirstvert = vert;

			if (m->xyz_array)
				memcpy(vbovdata + vbo->coord.vk.offs		+ vert*sizeof(vecV_t), m->xyz_array,		sizeof(vecV_t)*m->numvertexes);
			if (m->st_array)
				memcpy(vbovdata + vbo->texcoord.vk.offs		+ vert*sizeof(vec2_t), m->st_array,			sizeof(vec2_t)*m->numvertexes);
			if (m->lmst_array[0])
				memcpy(vbovdata + vbo->lmcoord[0].vk.offs	+ vert*sizeof(vec2_t), m->lmst_array[0],	sizeof(vec2_t)*m->numvertexes);
			if (m->normals_array)
				memcpy(vbovdata + vbo->normals.vk.offs		+ vert*sizeof(vec3_t), m->normals_array,	sizeof(vec3_t)*m->numvertexes);
			if (m->snormals_array)
				memcpy(vbovdata + vbo->svector.vk.offs		+ vert*sizeof(vec3_t), m->snormals_array,	sizeof(vec3_t)*m->numvertexes);
			if (m->tnormals_array)
				memcpy(vbovdata + vbo->tvector.vk.offs		+ vert*sizeof(vec3_t), m->tnormals_array,	sizeof(vec3_t)*m->numvertexes);
			if (m->colors4f_array[0])
				memcpy(vbovdata + vbo->colours[0].vk.offs	+ vert*sizeof(vec4_t), m->colors4f_array[0],sizeof(vec4_t)*m->numvertexes);

			m->vbofirstelement = idx;
			for (i = 0; i < m->numindexes; i++)
			{
				*vboedata++ = vert + m->indexes[i];
			}
			idx += m->numindexes;
			vert += m->numvertexes;
		}
	}

	vbo->vbomem = poolmem = Z_Malloc(sizeof(*poolmem));
	vbo->coord.vk.buff = 
	vbo->texcoord.vk.buff = 
	vbo->lmcoord[0].vk.buff = 
	vbo->normals.vk.buff = 
	vbo->svector.vk.buff = 
	vbo->tvector.vk.buff = 
	vbo->colours[0].vk.buff = VKBE_FinishStaging(&vbuf, poolmem);

	vbo->ebomem = poolmem = Z_Malloc(sizeof(*poolmem));
	vbo->indicies.vk.buff = VKBE_FinishStaging(&ebuf, poolmem);
	vbo->indicies.vk.offs = 0;

	vbo->indexcount = maxvboelements;
	vbo->vertcount = maxvboverts;

	vbo->next = *vbochain;
	*vbochain = vbo;
}

void VKBE_GenBrushModelVBO(model_t *mod)
{
	unsigned int vcount, cvcount;

	batch_t *batch, *fbatch;
	int sortid;
	int i;

	fbatch = NULL;
	vcount = 0;
	for (sortid = 0; sortid < SHADER_SORT_COUNT; sortid++)
	{
		if (!mod->batches[sortid])
			continue;

		for (fbatch = batch = mod->batches[sortid]; batch != NULL; batch = batch->next)
		{
			for (i = 0, cvcount = 0; i < batch->maxmeshes; i++)
				cvcount += batch->mesh[i]->numvertexes;

			if (vcount + cvcount > MAX_INDICIES)
			{
				VKBE_GenBatchVBOs(&mod->vbos, fbatch, batch);
				fbatch = batch;
				vcount = 0;
			}

			vcount += cvcount;
		}

		VKBE_GenBatchVBOs(&mod->vbos, fbatch, batch);
	}
}

struct vkbe_clearvbo
{
	struct vk_frameend fe;
	vbo_t *vbo;
};
static void VKBE_SafeClearVBO(void *vboptr)
{
	vbo_t *vbo = *(vbo_t**)vboptr;

	if (vbo->indicies.vk.buff)
	{
		vkDestroyBuffer(vk.device, vbo->indicies.vk.buff, vkallocationcb);
		VK_ReleasePoolMemory(vbo->ebomem);
		BZ_Free(vbo->ebomem);
	}

	if (vbo->coord.vk.buff)
	{
		vkDestroyBuffer(vk.device, vbo->coord.vk.buff, vkallocationcb);
		VK_ReleasePoolMemory(vbo->vbomem);
		BZ_Free(vbo->vbomem);
	}

	BZ_Free(vbo);
}
/*Wipes a vbo*/
void VKBE_ClearVBO(vbo_t *vbo, qboolean dataonly)
{
	if (dataonly)
	{
		//create one for the safe callback to clear.
		vbo_t *nvbo = BZ_Malloc(sizeof(*vbo));
		nvbo->indicies = vbo->indicies;
		nvbo->coord = vbo->coord;

		//scrub it now
		memset(&vbo->indicies, 0, sizeof(vbo->indicies));
		memset(&vbo->coord, 0, sizeof(vbo->coord));
		vbo = nvbo;
	}
	VK_AtFrameEnd(VKBE_SafeClearVBO, &vbo, sizeof(vbo));
}

void VK_UploadLightmap(lightmapinfo_t *lm)
{
	extern cvar_t r_lightmap_nearest;
	struct pendingtextureinfo mips;
	image_t *tex;

	lm->modified = false;
	if (!TEXVALID(lm->lightmap_texture))
	{
		lm->lightmap_texture = Image_CreateTexture("***lightmap***", NULL, (r_lightmap_nearest.ival?IF_NEAREST:IF_LINEAR));
		if (!lm->lightmap_texture)
			return;
	}
	tex = lm->lightmap_texture;

	if (0)//vk.frame && tex->vkimage)
	{	//the inline streaming path.
		//the double-copy sucks but at least ensures that the dma copies stuff from THIS frame and not some of the next one too.
		int *data;
		VkBufferImageCopy bic;
		VkBuffer buf;
		//size_t x = 0, w = lm->width;
		size_t x = lm->rectchange.l, w = lm->rectchange.r - lm->rectchange.l;
		size_t y = lm->rectchange.t, h = lm->rectchange.b - lm->rectchange.t, i;

		data = VKBE_AllocateBufferSpace(DB_STAGING, w * h * 4, &buf, &bic.bufferOffset);
		bic.bufferRowLength = w;
		bic.bufferImageHeight = h;
		bic.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		bic.imageSubresource.mipLevel = 0;
		bic.imageSubresource.baseArrayLayer = 0;
		bic.imageSubresource.layerCount = 1;
		bic.imageOffset.x = x;
		bic.imageOffset.y = y;
		bic.imageOffset.z = 0;
		bic.imageExtent.width = w;
		bic.imageExtent.height = h;
		bic.imageExtent.depth = 1;

		if (w == lm->width)	//can just copy the lot in a single call.
			memcpy(data, lm->lightmaps + 4*(y * lm->width), w*h*4);
		else
		{	//there's unused data on each row, oh well.
			for (i = 0; i < h; i++)
				memcpy(data + i * w, lm->lightmaps + 4*((y+i) * lm->width + x), w*4);
		}
		vkCmdCopyBufferToImage(vk.rendertarg->cbuf, buf, tex->vkimage->image, tex->vkimage->layout, 1, &bic);
	}
	else
	{	//the slow out-of-frame generic path.
		mips.extrafree = NULL;
		mips.type = PTI_2D;
		mips.mip[0].data = lm->lightmaps;
		mips.mip[0].needfree = false;
		mips.mip[0].width = lm->width;
		mips.mip[0].height = lm->height;
		mips.mip[0].depth = 1;
		switch(lm->fmt)
		{
		default:
		case PTI_A2BGR10:
		case PTI_E5BGR9:
		case PTI_RGBA16F:
		case PTI_RGBA32F:
		case PTI_L8:
			mips.encoding = lm->fmt;
			break;
		case PTI_BGRA8:
			mips.encoding = PTI_BGRX8;
			break;
		case TF_BGR24:	//shouldn't happen
			mips.encoding = PTI_R8;
			break;
		}
		mips.mipcount = 1;
		VK_LoadTextureMips(tex, &mips);
		tex->status = TEX_LOADED;
		tex->width = lm->width;
		tex->height = lm->height;
	}

	//invert the size so we're not always updating the entire thing.
	lm->rectchange.l = lm->width;
	lm->rectchange.t = lm->height;
	lm->rectchange.r = 0;
	lm->rectchange.b = 0;
	lm->modified = false;
}
/*upload all lightmaps at the start to reduce lags*/
static void BE_UploadLightmaps(qboolean force)
{
	int i;

	for (i = 0; i < numlightmaps; i++)
	{
		if (!lightmap[i])
			continue;

		if (force && !lightmap[i]->external)
		{
			lightmap[i]->rectchange.l = 0;
			lightmap[i]->rectchange.t = 0;
			lightmap[i]->rectchange.r = lightmap[i]->width;
			lightmap[i]->rectchange.b = lightmap[i]->height;
			lightmap[i]->modified = true;
		}

		if (lightmap[i]->modified)
		{
			VK_UploadLightmap(lightmap[i]);
		}
	}
}

void VKBE_UploadAllLightmaps(void)
{
	BE_UploadLightmaps(true);
}

qboolean VKBE_LightCullModel(vec3_t org, model_t *model)
{
#ifdef RTLIGHTS
	if ((shaderstate.mode == BEM_LIGHT || shaderstate.mode == BEM_STENCIL || shaderstate.mode == BEM_DEPTHONLY))
	{
		float dist;
		vec3_t disp;
		if (model->type == mod_alias)
		{
			VectorSubtract(org, shaderstate.lightinfo, disp);
			dist = DotProduct(disp, disp);
			if (dist > model->radius*model->radius + shaderstate.lightinfo[3]*shaderstate.lightinfo[3])
				return true;
		}
		else
		{
			int i;

			for (i = 0; i < 3; i++)
			{
				if (shaderstate.lightinfo[i]-shaderstate.lightinfo[3] > org[i] + model->maxs[i])
					return true;
				if (shaderstate.lightinfo[i]+shaderstate.lightinfo[3] < org[i] + model->mins[i])
					return true;
			}
		}
	}
#endif
	return false;
}

batch_t *VKBE_GetTempBatch(void)
{
	if (shaderstate.wbatch >= shaderstate.maxwbatches)
	{
		shaderstate.wbatch++;
		return NULL;
	}
	return &shaderstate.wbatches[shaderstate.wbatch++];
}

void VKBE_SetupLightCBuffer(dlight_t *l, vec3_t colour)
{
#ifdef RTLIGHTS
	extern cvar_t gl_specular;
#endif
	vkcbuf_light_t *cbl = VKBE_AllocateBufferSpace(DB_UBO, (sizeof(*cbl) + 0x0ff) & ~0xff, &shaderstate.ubo_light.buffer, &shaderstate.ubo_light.offset);
	shaderstate.ubo_light.range = sizeof(*cbl);

	if (!l)
	{
		memset(cbl, 0, sizeof(*cbl));

		Vector4Set(shaderstate.lightinfo, 0, 0, 0, 0);
		return;
	}


	cbl->l_lightradius = l->radius;

#ifdef RTLIGHTS
	if (shaderstate.curlmode & LSHADER_SPOT)
	{
		float view[16];
		float proj[16];
		extern cvar_t r_shadow_shadowmapping_nearclip;
		Matrix4x4_CM_Projection_Far(proj, l->fov, l->fov, l->nearclip?l->nearclip:r_shadow_shadowmapping_nearclip.value, l->radius, false);
		Matrix4x4_CM_ModelViewMatrixFromAxis(view, l->axis[0], l->axis[1], l->axis[2], l->origin);
		Matrix4_Multiply(proj, view, cbl->l_cubematrix);
	}
	else
#endif
		Matrix4x4_CM_LightMatrixFromAxis(cbl->l_cubematrix, l->axis[0], l->axis[1], l->axis[2], l->origin);
	VectorCopy(l->origin, cbl->l_lightposition);
	cbl->padl1 = 0;
	VectorCopy(colour, cbl->l_colour);
#ifdef RTLIGHTS
	VectorCopy(l->lightcolourscales, cbl->l_lightcolourscale);
	cbl->l_lightcolourscale[0] = l->lightcolourscales[0];
	cbl->l_lightcolourscale[1] = l->lightcolourscales[1];
	cbl->l_lightcolourscale[2] = l->lightcolourscales[2] * gl_specular.value;
#endif
	cbl->l_lightradius = l->radius;
	Vector4Copy(shaderstate.lightshadowmapproj, cbl->l_shadowmapproj);
	Vector2Copy(shaderstate.lightshadowmapscale, cbl->l_shadowmapscale);

	VectorCopy(l->origin, shaderstate.lightinfo);
	shaderstate.lightinfo[3] = l->radius;
}


//also updates the entity constant buffer
static void BE_RotateForEntity (const entity_t *fte_restrict e, const model_t *fte_restrict mod)
{
	int i;
	float modelmatrix[16];
	float *m = modelmatrix;
	float *proj;
	vkcbuf_entity_t *fte_restrict cbe = VKBE_AllocateBufferSpace(DB_UBO, (sizeof(*cbe) + 0x0ff) & ~0xff, &shaderstate.ubo_entity.buffer, &shaderstate.ubo_entity.offset);
	shaderstate.ubo_entity.range = sizeof(*cbe);

	shaderstate.curentity = e;

	if (e->flags & RF_DEPTHHACK)
		proj = r_refdef.m_projection_view;
	else
		proj = r_refdef.m_projection_std;

	if ((e->flags & RF_WEAPONMODEL) && r_refdef.playerview->viewentity > 0)
	{
		float em[16];
		float vm[16];

		if (e->flags & RF_WEAPONMODELNOBOB)
		{
			vm[0] = vpn[0];
			vm[1] = vpn[1];
			vm[2] = vpn[2];
			vm[3] = 0;

			vm[4] = -vright[0];
			vm[5] = -vright[1];
			vm[6] = -vright[2];
			vm[7] = 0;

			vm[8] = vup[0];
			vm[9] = vup[1];
			vm[10] = vup[2];
			vm[11] = 0;

			vm[12] = r_refdef.vieworg[0];
			vm[13] = r_refdef.vieworg[1];
			vm[14] = r_refdef.vieworg[2];
			vm[15] = 1;
		}
		else
		{
			vm[0] = r_refdef.playerview->vw_axis[0][0];
			vm[1] = r_refdef.playerview->vw_axis[0][1];
			vm[2] = r_refdef.playerview->vw_axis[0][2];
			vm[3] = 0;

			vm[4] = r_refdef.playerview->vw_axis[1][0];
			vm[5] = r_refdef.playerview->vw_axis[1][1];
			vm[6] = r_refdef.playerview->vw_axis[1][2];
			vm[7] = 0;

			vm[8] = r_refdef.playerview->vw_axis[2][0];
			vm[9] = r_refdef.playerview->vw_axis[2][1];
			vm[10] = r_refdef.playerview->vw_axis[2][2];
			vm[11] = 0;

			vm[12] = r_refdef.playerview->vw_origin[0];
			vm[13] = r_refdef.playerview->vw_origin[1];
			vm[14] = r_refdef.playerview->vw_origin[2];
			vm[15] = 1;
		}

		em[0] = e->axis[0][0];
		em[1] = e->axis[0][1];
		em[2] = e->axis[0][2];
		em[3] = 0;

		em[4] = e->axis[1][0];
		em[5] = e->axis[1][1];
		em[6] = e->axis[1][2];
		em[7] = 0;

		em[8] = e->axis[2][0];
		em[9] = e->axis[2][1];
		em[10] = e->axis[2][2];
		em[11] = 0;

		em[12] = e->origin[0];
		em[13] = e->origin[1];
		em[14] = e->origin[2];
		em[15] = 1;

		Matrix4_Multiply(vm, em, m);
	}
	else
	{
		m[0] = e->axis[0][0];
		m[1] = e->axis[0][1];
		m[2] = e->axis[0][2];
		m[3] = 0;

		m[4] = e->axis[1][0];
		m[5] = e->axis[1][1];
		m[6] = e->axis[1][2];
		m[7] = 0;

		m[8] = e->axis[2][0];
		m[9] = e->axis[2][1];
		m[10] = e->axis[2][2];
		m[11] = 0;

		m[12] = e->origin[0];
		m[13] = e->origin[1];
		m[14] = e->origin[2];
		m[15] = 1;
	}

	if (e->scale != 1 && e->scale != 0)	//hexen 2 stuff
	{
#ifdef HEXEN2
		float z;
		float escale;
		escale = e->scale;
		switch(e->drawflags&SCALE_TYPE_MASK)
		{
		default:
		case SCALE_TYPE_UNIFORM:
			VectorScale((m+0), escale, (m+0));
			VectorScale((m+4), escale, (m+4));
			VectorScale((m+8), escale, (m+8));
			break;
		case SCALE_TYPE_XYONLY:
			VectorScale((m+0), escale, (m+0));
			VectorScale((m+4), escale, (m+4));
			break;
		case SCALE_TYPE_ZONLY:
			VectorScale((m+8), escale, (m+8));
			break;
		}
		if (mod && (e->drawflags&SCALE_TYPE_MASK) != SCALE_TYPE_XYONLY)
		{
			switch(e->drawflags&SCALE_ORIGIN_MASK)
			{
			case SCALE_ORIGIN_CENTER:
				z = ((mod->maxs[2] + mod->mins[2]) * (1-escale))/2;
				VectorMA((m+12), z, e->axis[2], (m+12));
				break;
			case SCALE_ORIGIN_BOTTOM:
				VectorMA((m+12), mod->mins[2]*(1-escale), e->axis[2], (m+12));
				break;
			case SCALE_ORIGIN_TOP:
				VectorMA((m+12), -mod->maxs[2], e->axis[2], (m+12));
				break;
			}
		}
#else
		VectorScale((m+0), e->scale, (m+0));
		VectorScale((m+4), e->scale, (m+4));
		VectorScale((m+8), e->scale, (m+8));
#endif
	}
	else if (mod && !strcmp(mod->name, "progs/eyes.mdl"))
	{
		/*resize eyes, to make them easier to see*/
		m[14] -= (22 + 8);
		VectorScale((m+0), 2, (m+0));
		VectorScale((m+4), 2, (m+4));
		VectorScale((m+8), 2, (m+8));
	}
	if (mod && !ruleset_allow_larger_models.ival && mod->clampscale != 1)
	{	//possibly this should be on a per-frame basis, but that's a real pain to do
		Con_DPrintf("Rescaling %s by %f\n", mod->name, mod->clampscale);
		VectorScale((m+0), mod->clampscale, (m+0));
		VectorScale((m+4), mod->clampscale, (m+4));
		VectorScale((m+8), mod->clampscale, (m+8));
	}

	{
		float modelview[16];
		Matrix4_Multiply(r_refdef.m_view, m, modelview);
		Matrix4_Multiply(proj, modelview, cbe->m_modelviewproj);
	}
	memcpy(cbe->m_model, m, sizeof(cbe->m_model));
	Matrix4_Invert(modelmatrix, cbe->m_modelinv);
	Matrix4x4_CM_Transform3(cbe->m_modelinv, r_origin, cbe->e_eyepos);

	cbe->e_time = shaderstate.curtime = r_refdef.time - shaderstate.curentity->shaderTime;

	VectorCopy(e->light_avg, cbe->e_light_ambient);	cbe->pad1 = 0;
	VectorCopy(e->light_dir, cbe->e_light_dir);		cbe->pad2 = 0;
	VectorCopy(e->light_range, cbe->e_light_mul);	cbe->pad3 = 0;

	for (i = 0; i < MAXRLIGHTMAPS ; i++)
	{
		//FIXME: this is fucked, the batch isn't known yet.
		#if 0
		extern cvar_t gl_overbright;
		unsigned char s = shaderstate.curbatch?shaderstate.curbatch->lmlightstyle[i]:0;
		float sc;
		if (s == 255)
		{
			if (i == 0)
			{
				if (shaderstate.curentity->model && shaderstate.curentity->model->engineflags & MDLF_NEEDOVERBRIGHT)
					sc = (1<<bound(0, gl_overbright.ival, 2)) * shaderstate.identitylighting;
				else
					sc = shaderstate.identitylighting;
				cbe->e_lmscale[i][0] = sc;
				cbe->e_lmscale[i][1] = sc;
				cbe->e_lmscale[i][2] = sc;
				cbe->e_lmscale[i][3] = 1;
				i++;
			}
			for (; i < MAXRLIGHTMAPS ; i++)
			{
				cbe->e_lmscale[i][0] = 0;
				cbe->e_lmscale[i][1] = 0;
				cbe->e_lmscale[i][2] = 0;
				cbe->e_lmscale[i][3] = 1;
			}
			break;
		}
		#else
		float sc = 1;
		#endif
		if (shaderstate.curentity->model && shaderstate.curentity->model->engineflags & MDLF_NEEDOVERBRIGHT)
			sc = (1<<bound(0, gl_overbright.ival, 2)) * shaderstate.identitylighting;
		else
			sc = shaderstate.identitylighting;
//		sc *= d_lightstylevalue[s]/256.0f;

		Vector4Set(cbe->e_lmscale[i], sc, sc, sc, 1);
	}

	R_FetchPlayerColour(e->topcolour, cbe->e_uppercolour);		cbe->pad4 = 0;
	R_FetchPlayerColour(e->bottomcolour, cbe->e_lowercolour);	cbe->pad5 = 0;
	VectorCopy(e->glowmod, cbe->e_glowmod);						cbe->pad6 = 0;
	if (shaderstate.flags & BEF_FORCECOLOURMOD)
		Vector4Copy(e->shaderRGBAf, cbe->e_colourident);
	else
		Vector4Set(cbe->e_colourident, 1, 1, 1, e->shaderRGBAf[3]);

	VectorCopy(r_refdef.globalfog.colour, cbe->w_fogcolours);
	cbe->w_fogcolours[3] = r_refdef.globalfog.alpha;

	cbe->w_fogdensity = r_refdef.globalfog.density;
	cbe->w_fogdepthbias = r_refdef.globalfog.depthbias;
	Vector2Set(cbe->pad7, 0, 0);

	/*ndr = (e->flags & RF_DEPTHHACK)?0.333:1;
	if (ndr != shaderstate.rc.depthrange)
	{
		VkViewport viewport;
		shaderstate.rc.depthrange = ndr;

		viewport.x = r_refdef.pxrect.x;
		viewport.y = r_refdef.pxrect.y;
		viewport.width = r_refdef.pxrect.width;
		viewport.height = r_refdef.pxrect.height;
		viewport.minDepth = 0;
		viewport.maxDepth = ndr;
		vkCmdSetViewport(vk.rendertarg->cbuf, 0, 1, &viewport);
	}*/
}

void VKBE_SubmitBatch(batch_t *batch)
{
	shader_t *shader = batch->shader;
	unsigned int bf;
	shaderstate.nummeshes = batch->meshes - batch->firstmesh;
	if (!shaderstate.nummeshes)
		return;
	shaderstate.curbatch = batch;
	shaderstate.batchvbo = batch->vbo;
	shaderstate.meshlist = batch->mesh + batch->firstmesh;
	shaderstate.curshader = shader->remapto;
	bf = batch->flags | shaderstate.forcebeflags;
	if (shaderstate.curentity != batch->ent || shaderstate.flags != bf)
	{
		shaderstate.flags = bf;
		BE_RotateForEntity(batch->ent, batch->ent->model);
		shaderstate.curtime = r_refdef.time - shaderstate.curentity->shaderTime;
	}
	if (batch->skin)
		shaderstate.curtexnums = batch->skin;
	else if (shader->numdefaulttextures)
		shaderstate.curtexnums = shader->defaulttextures + ((int)(shader->defaulttextures_fps * shaderstate.curtime) % shader->numdefaulttextures);
	else
		shaderstate.curtexnums = shader->defaulttextures;

	BE_DrawMeshChain_Internal();
}

void VKBE_DrawMesh_List(shader_t *shader, int nummeshes, mesh_t **meshlist, vbo_t *vbo, texnums_t *texnums, unsigned int beflags)
{
	shaderstate.curbatch = &shaderstate.dummybatch;
	shaderstate.batchvbo = vbo;
	shaderstate.curshader = shader->remapto;
	if (texnums)
		shaderstate.curtexnums = texnums;
	else if (shader->numdefaulttextures)
		shaderstate.curtexnums = shader->defaulttextures + ((int)(shader->defaulttextures_fps * shaderstate.curtime) % shader->numdefaulttextures);
	else
		shaderstate.curtexnums = shader->defaulttextures;
	shaderstate.meshlist = meshlist;
	shaderstate.nummeshes = nummeshes;
	shaderstate.flags = beflags | shaderstate.forcebeflags;

	BE_DrawMeshChain_Internal();
}

void VKBE_DrawMesh_Single(shader_t *shader, mesh_t *meshchain, vbo_t *vbo, unsigned int beflags)
{
	shaderstate.curbatch = &shaderstate.dummybatch;
	shaderstate.batchvbo = vbo;
	shaderstate.curtime = realtime;
	shaderstate.curshader = shader->remapto;
	if (shader->numdefaulttextures)
		shaderstate.curtexnums = shader->defaulttextures + ((int)(shader->defaulttextures_fps * shaderstate.curtime) % shader->numdefaulttextures);
	else
		shaderstate.curtexnums = shader->defaulttextures;
	shaderstate.meshlist = &meshchain;
	shaderstate.nummeshes = 1;
	shaderstate.flags = beflags | shaderstate.forcebeflags;

	BE_DrawMeshChain_Internal();
}

void VKBE_RT_Destroy(struct vk_rendertarg *targ)
{
	if (targ->framebuffer)
	{
		vkDestroyFramebuffer(vk.device, targ->framebuffer, vkallocationcb);
		VK_DestroyVkTexture(&targ->depth);
		VK_DestroyVkTexture(&targ->colour);
	}
	memset(targ, 0, sizeof(*targ));
}


struct vkbe_rtpurge
{
	VkFramebuffer framebuffer;
	vk_image_t colour;
	vk_image_t mscolour;
	vk_image_t depth;
};
static void VKBE_RT_Purge(void *ptr)
{
	struct vkbe_rtpurge *ctx = ptr;
	vkDestroyFramebuffer(vk.device, ctx->framebuffer, vkallocationcb);
	VK_DestroyVkTexture(&ctx->depth);
	VK_DestroyVkTexture(&ctx->mscolour);
	VK_DestroyVkTexture(&ctx->colour);
}
void VKBE_RT_Gen(struct vk_rendertarg *targ, vk_image_t *colour, uint32_t width, uint32_t height, qboolean clear, unsigned int flags)
{
	//sooooo much work...
	VkImageCreateInfo colour_imginfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
	VkImageCreateInfo mscolour_imginfo;
	VkImageCreateInfo depth_imginfo;
	struct vkbe_rtpurge *purge;
	static VkClearValue clearvalues[3];

	if (colour)
	{	//override the width+height if we already have an image to draw to.
		width = colour->width;
		height = colour->height;
	}

	targ->restartinfo.clearValueCount = 3;
	targ->depthcleared = true;	//will be once its activated.

	if (targ->width == width && targ->height == height && targ->q_colour.flags == flags && (!(targ->rpassflags&RP_MULTISAMPLE))==(targ->mscolour.image==VK_NULL_HANDLE))
	{
		if ((colour && colour->image == targ->colour.image) || (!colour && !targ->externalimage))
		{
			if (width == 0 || height == 0)
				targ->restartinfo.renderPass = VK_NULL_HANDLE;	//illegal combination used for destruction.
			else if (clear || targ->firstuse)
				targ->restartinfo.renderPass = VK_GetRenderPass(RP_FULLCLEAR|targ->rpassflags);
			else
				targ->restartinfo.renderPass = VK_GetRenderPass(RP_DEPTHCLEAR|targ->rpassflags);	//don't care
			return;	//no work to do.
		}
	}

	if (targ->framebuffer || targ->externalimage)
	{	//schedule the old one to be destroyed at the end of the current frame. DIE OLD ONE, DIE!
		purge = VK_AtFrameEnd(VKBE_RT_Purge, NULL, sizeof(*purge));
		purge->framebuffer = targ->framebuffer; 
		purge->colour = targ->colour;
		if (targ->externalimage)
			purge->colour.image = VK_NULL_HANDLE;
		purge->mscolour = targ->mscolour;
		purge->depth = targ->depth;
		memset(&targ->colour, 0, sizeof(targ->colour));
		memset(&targ->mscolour, 0, sizeof(targ->mscolour));
		memset(&targ->depth, 0, sizeof(targ->depth));
		targ->framebuffer = VK_NULL_HANDLE;
	}

	targ->externalimage = !!colour;
	targ->q_colour.vkimage = &targ->colour;
	targ->q_depth.vkimage = &targ->depth;
	targ->q_colour.status = TEX_LOADED;
	targ->q_colour.width = width;
	targ->q_colour.height = height;
	targ->q_colour.flags = flags;

	targ->width = width;
	targ->height = height;

	if (width == 0 && height == 0)
	{
		targ->restartinfo.renderPass = VK_NULL_HANDLE;
		return;	//destroyed
	}
	if (targ->externalimage)
	{
		VkFormat old = vk.backbufformat;
		colour_imginfo.format = vk.backbufformat = colour->vkformat;
		targ->rpassflags |= RP_VR;
		targ->restartinfo.renderPass = VK_GetRenderPass(RP_FULLCLEAR|targ->rpassflags);

		vk.backbufformat = old;
	}
	else
	{
		targ->rpassflags &= ~RP_VR;
		targ->restartinfo.renderPass = VK_GetRenderPass(RP_FULLCLEAR|targ->rpassflags);

		colour_imginfo.format = (targ->rpassflags&RP_FP16)?VK_FORMAT_R16G16B16A16_SFLOAT:vk.backbufformat;
	}
	colour_imginfo.flags = 0;
	colour_imginfo.imageType = VK_IMAGE_TYPE_2D;
	colour_imginfo.extent.width = width;
	colour_imginfo.extent.height = height;
	colour_imginfo.extent.depth = 1;
	colour_imginfo.mipLevels = 1;
	colour_imginfo.arrayLayers = 1;
	//colour buffer is always 1 sample. if multisampling then we have a hidden 'mscolour' image that is paired with the depth, resolving to the 'colour' image.
	colour_imginfo.samples = VK_SAMPLE_COUNT_1_BIT;
	colour_imginfo.tiling = VK_IMAGE_TILING_OPTIMAL;
	colour_imginfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_SAMPLED_BIT;
	colour_imginfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	colour_imginfo.queueFamilyIndexCount = 0;
	colour_imginfo.pQueueFamilyIndices = NULL;
	colour_imginfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	if (targ->externalimage)
	{
		targ->colour.image = colour->image;
	}
	else
	{
		VkAssert(vkCreateImage(vk.device, &colour_imginfo, vkallocationcb, &targ->colour.image));
		DebugSetName(VK_OBJECT_TYPE_IMAGE, (uint64_t)targ->colour.image, "RT Colour");
	}

	depth_imginfo = colour_imginfo;
	depth_imginfo.format = vk.depthformat;
	depth_imginfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_SAMPLED_BIT;
	if (targ->rpassflags&RP_MULTISAMPLE)
	{
		mscolour_imginfo = colour_imginfo;
		depth_imginfo.samples = mscolour_imginfo.samples = vk.multisamplebits;
		VkAssert(vkCreateImage(vk.device, &mscolour_imginfo, vkallocationcb, &targ->mscolour.image));
		DebugSetName(VK_OBJECT_TYPE_IMAGE, (uint64_t)targ->mscolour.image, "RT MS Colour");
		VK_AllocateBindImageMemory(&targ->mscolour, true);
	}
	VkAssert(vkCreateImage(vk.device, &depth_imginfo, vkallocationcb, &targ->depth.image));
	DebugSetName(VK_OBJECT_TYPE_IMAGE, (uint64_t)targ->depth.image, "RT Depth");

	if (targ->externalimage)	//an external image is assumed to already have memory bound. don't allocate it elsewhere.
		memset(&targ->colour.mem, 0, sizeof(targ->colour.mem));
	else
		VK_AllocateBindImageMemory(&targ->colour, true);
	VK_AllocateBindImageMemory(&targ->depth, true);

	{
		VkImageViewCreateInfo ivci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
		ivci.components.r = VK_COMPONENT_SWIZZLE_R;
		ivci.components.g = VK_COMPONENT_SWIZZLE_G;
		ivci.components.b = VK_COMPONENT_SWIZZLE_B;
		ivci.components.a = VK_COMPONENT_SWIZZLE_A;
		ivci.subresourceRange.baseMipLevel = 0;
		ivci.subresourceRange.levelCount = 1;
		ivci.subresourceRange.baseArrayLayer = 0;
		ivci.subresourceRange.layerCount = 1;
		ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
		ivci.flags = 0;

		ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		ivci.format = colour_imginfo.format;
		ivci.image = targ->colour.image;
		VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->colour.view));

		if (targ->rpassflags&RP_MULTISAMPLE)
		{
			ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			ivci.format = mscolour_imginfo.format;
			ivci.image = targ->mscolour.image;
			VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->mscolour.view));
		}

		ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
		ivci.format = depth_imginfo.format;
		ivci.image = targ->depth.image;
		VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->depth.view));
	}

	{
		VkSamplerCreateInfo lmsampinfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
		lmsampinfo.minFilter = lmsampinfo.magFilter = (flags&IF_NEAREST)?VK_FILTER_NEAREST:VK_FILTER_LINEAR;
		lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
		lmsampinfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
		lmsampinfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
		lmsampinfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
		lmsampinfo.mipLodBias = 0.0;
		lmsampinfo.anisotropyEnable = VK_FALSE;
		lmsampinfo.maxAnisotropy = 1.0;
		lmsampinfo.compareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
		lmsampinfo.minLod = 0;
		lmsampinfo.maxLod = 0;
		lmsampinfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
		lmsampinfo.unnormalizedCoordinates = VK_FALSE;

		lmsampinfo.compareEnable = VK_FALSE;
		VK_CreateSamplerInfo(&lmsampinfo, &targ->colour);

		lmsampinfo.compareEnable = VK_TRUE;
		VK_CreateSamplerInfo(&lmsampinfo, &targ->depth);
	}

	targ->colour.layout = VK_IMAGE_LAYOUT_UNDEFINED;
	targ->mscolour.layout = VK_IMAGE_LAYOUT_UNDEFINED;
	targ->depth.layout = VK_IMAGE_LAYOUT_UNDEFINED;

	{
		VkFramebufferCreateInfo fbinfo = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
		VkImageView attachments[3] = {targ->colour.view, targ->depth.view, targ->mscolour.view};
		fbinfo.flags = 0;
		fbinfo.renderPass = targ->restartinfo.renderPass;
		fbinfo.attachmentCount = (targ->rpassflags&RP_MULTISAMPLE)?3:2;
		fbinfo.pAttachments = attachments;
		fbinfo.width = width;
		fbinfo.height = height;
		fbinfo.layers = 1;
		VkAssert(vkCreateFramebuffer(vk.device, &fbinfo, vkallocationcb, &targ->framebuffer));
	}

	targ->restartinfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
	targ->restartinfo.pNext = NULL;
	targ->restartinfo.framebuffer = targ->framebuffer;
	targ->restartinfo.renderArea.offset.x = 0;
	targ->restartinfo.renderArea.offset.y = 0;
	targ->restartinfo.renderArea.extent.width = width;
	targ->restartinfo.renderArea.extent.height = height;
	targ->restartinfo.pClearValues = clearvalues;
	clearvalues[1].depthStencil.depth = 1;
}

struct vkbe_rtpurge_cube
{
	vk_image_t colour;
	vk_image_t depth;
	struct
	{
		VkFramebuffer framebuffer;
		VkImageView iv[2];
	} face[6];
};
static void VKBE_RT_Purge_Cube(void *ptr)
{
	uint32_t f;
	struct vkbe_rtpurge_cube *ctx = ptr;
	for (f = 0; f < 6; f++)
	{
		vkDestroyFramebuffer(vk.device, ctx->face[f].framebuffer, vkallocationcb);
		vkDestroyImageView(vk.device, ctx->face[f].iv[0], vkallocationcb);
		vkDestroyImageView(vk.device, ctx->face[f].iv[1], vkallocationcb);
	}
	VK_DestroyVkTexture(&ctx->depth);
	VK_DestroyVkTexture(&ctx->colour);
}
//generate a cubemap-compatible 2d array, set up 6 render targets that render to their own views
void VKBE_RT_Gen_Cube(struct vk_rendertarg_cube *targ, uint32_t size, qboolean clear)
{
	VkImageCreateInfo colour_imginfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
	VkImageCreateInfo depth_imginfo;
	struct vkbe_rtpurge_cube *purge;
	uint32_t f;
	static VkClearValue clearvalues[2];

	if (targ->size == size && !clear)
		return;	//no work to do.

	for (f = 0; f < 6; f++)
	{
		if (clear)
			targ->face[f].restartinfo.renderPass = VK_GetRenderPass(RP_FULLCLEAR|targ->face[f].rpassflags);
		else
			targ->face[f].restartinfo.renderPass = VK_GetRenderPass(RP_DEPTHCLEAR|targ->face[f].rpassflags);	//don't care
		targ->face[f].restartinfo.clearValueCount = 2;
	}

	if (targ->size == size)
		return;	//no work to do.

	if (targ->size)
	{	//schedule the old one to be destroyed at the end of the current frame. DIE OLD ONE, DIE!
		purge = VK_AtFrameEnd(VKBE_RT_Purge_Cube, NULL, sizeof(*purge));
		for (f = 0; f < 6; f++)
		{
			purge->face[f].framebuffer = targ->face[f].framebuffer;
			targ->face[f].framebuffer = VK_NULL_HANDLE;
			purge->face[f].iv[0] = targ->face[f].colour.view;
			purge->face[f].iv[1] = targ->face[f].depth.view;
			targ->face[f].colour.view = VK_NULL_HANDLE;
			targ->face[f].depth.view = VK_NULL_HANDLE;
		}
		purge->colour = targ->colour;
		purge->depth = targ->depth;
		memset(&targ->colour, 0, sizeof(targ->colour));
		memset(&targ->depth, 0, sizeof(targ->depth));
	}

	targ->size = size;
	if (!size)
		return;

	targ->q_colour.vkimage = &targ->colour;
	targ->q_depth.vkimage = &targ->depth;

	colour_imginfo.format = VK_FORMAT_R8G8B8A8_UNORM;
	colour_imginfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
	colour_imginfo.imageType = VK_IMAGE_TYPE_2D;
	colour_imginfo.extent.width = size;
	colour_imginfo.extent.height = size;
	colour_imginfo.mipLevels = 1;
	colour_imginfo.arrayLayers = 6;
	colour_imginfo.samples = VK_SAMPLE_COUNT_1_BIT;
	colour_imginfo.tiling = VK_IMAGE_TILING_OPTIMAL;
	colour_imginfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_SAMPLED_BIT;
	colour_imginfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	colour_imginfo.queueFamilyIndexCount = 0;
	colour_imginfo.pQueueFamilyIndices = NULL;
	colour_imginfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	VkAssert(vkCreateImage(vk.device, &colour_imginfo, vkallocationcb, &targ->colour.image));
	DebugSetName(VK_OBJECT_TYPE_IMAGE, (uint64_t)targ->colour.image, "RT Cube Colour");

	depth_imginfo = colour_imginfo;
	depth_imginfo.format = vk.depthformat;
	depth_imginfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_SAMPLED_BIT;
	VkAssert(vkCreateImage(vk.device, &depth_imginfo, vkallocationcb, &targ->depth.image));
	DebugSetName(VK_OBJECT_TYPE_IMAGE, (uint64_t)targ->depth.image, "RT Cube Depth");

	VK_AllocateBindImageMemory(&targ->colour, true);
	VK_AllocateBindImageMemory(&targ->depth, true);

//		set_image_layout(vk.frame->cbuf, targ->colour.image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
//		set_image_layout(vk.frame->cbuf, targ->depth.image, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);

	//public sampler
	{
		VkSamplerCreateInfo lmsampinfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
		lmsampinfo.minFilter = lmsampinfo.magFilter = VK_FILTER_LINEAR;
		lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
		lmsampinfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
		lmsampinfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
		lmsampinfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
		lmsampinfo.mipLodBias = 0.0;
		lmsampinfo.anisotropyEnable = VK_FALSE;
		lmsampinfo.maxAnisotropy = 1.0;
		lmsampinfo.compareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
		lmsampinfo.minLod = 0;
		lmsampinfo.maxLod = 0;
		lmsampinfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
		lmsampinfo.unnormalizedCoordinates = VK_FALSE;

		lmsampinfo.compareEnable = VK_FALSE;
		VkAssert(vkCreateSampler(vk.device, &lmsampinfo, NULL, &targ->colour.sampler));

		lmsampinfo.compareEnable = VK_TRUE;
		VkAssert(vkCreateSampler(vk.device, &lmsampinfo, NULL, &targ->depth.sampler));
	}

	//public cubemap views
	{
		VkImageViewCreateInfo ivci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
		ivci.components.r = VK_COMPONENT_SWIZZLE_R;
		ivci.components.g = VK_COMPONENT_SWIZZLE_G;
		ivci.components.b = VK_COMPONENT_SWIZZLE_B;
		ivci.components.a = VK_COMPONENT_SWIZZLE_A;
		ivci.subresourceRange.baseMipLevel = 0;
		ivci.subresourceRange.levelCount = 1;
		ivci.subresourceRange.baseArrayLayer = 0;
		ivci.subresourceRange.layerCount = 6;
		ivci.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
		ivci.flags = 0;

		ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		ivci.format = colour_imginfo.format;
		ivci.image = targ->colour.image;
		VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->colour.view));

		ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
		ivci.format = depth_imginfo.format;
		ivci.image = targ->depth.image;
		VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->depth.view));
	}

	for (f = 0; f < 6; f++)
	{
		targ->face[f].width = targ->face[f].height = size;

		//per-face view for the framebuffer
		{
			VkImageViewCreateInfo ivci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
			ivci.components.r = VK_COMPONENT_SWIZZLE_R;
			ivci.components.g = VK_COMPONENT_SWIZZLE_G;
			ivci.components.b = VK_COMPONENT_SWIZZLE_B;
			ivci.components.a = VK_COMPONENT_SWIZZLE_A;
			ivci.subresourceRange.baseMipLevel = 0;
			ivci.subresourceRange.levelCount = 1;
			ivci.subresourceRange.baseArrayLayer = f;
			ivci.subresourceRange.layerCount = 1;
			ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
			ivci.flags = 0;

			ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			ivci.format = colour_imginfo.format;
			ivci.image = targ->colour.image;
			VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->face[f].colour.view));

			ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
			ivci.format = depth_imginfo.format;
			ivci.image = targ->depth.image;
			VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &targ->face[f].depth.view));
		}

		targ->colour.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
		targ->depth.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;

		{
			VkFramebufferCreateInfo fbinfo = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
			VkImageView attachments[2] = {targ->face[f].colour.view, targ->face[f].depth.view};
			fbinfo.flags = 0;
			fbinfo.renderPass = VK_GetRenderPass(RP_FULLCLEAR|targ->face[f].rpassflags);
			fbinfo.attachmentCount = countof(attachments);
			fbinfo.pAttachments = attachments;
			fbinfo.width = size;
			fbinfo.height = size;
			fbinfo.layers = 1;
			VkAssert(vkCreateFramebuffer(vk.device, &fbinfo, vkallocationcb, &targ->face[f].framebuffer));
		}

		targ->face[f].restartinfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
		targ->face[f].restartinfo.pNext = NULL;
		targ->face[f].restartinfo.framebuffer = targ->face[f].framebuffer;
		targ->face[f].restartinfo.renderArea.offset.x = 0;
		targ->face[f].restartinfo.renderArea.offset.y = 0;
		targ->face[f].restartinfo.renderArea.extent.width = size;
		targ->face[f].restartinfo.renderArea.extent.height = size;
		targ->face[f].restartinfo.pClearValues = clearvalues;
	}
	clearvalues[1].depthStencil.depth = 1;
}

void VKBE_RT_Begin(struct vk_rendertarg *targ)
{
	if (vk.rendertarg == targ)
		return;

	r_refdef.pxrect.x = 0;
	r_refdef.pxrect.y = 0;
	r_refdef.pxrect.width = targ->width;
	r_refdef.pxrect.height = targ->height;
	r_refdef.pxrect.maxheight = targ->height;

	vid.fbpwidth = targ->width;
	vid.fbpheight = targ->height;

#if 0
	targ->cbuf = vk.rendertarg->cbuf;
	if (vk.rendertarg)
		vkCmdEndRenderPass(vk.rendertarg->cbuf);
#else
	shaderstate.rc.activepipeline = VK_NULL_HANDLE;
	targ->cbuf = VK_AllocFrameCBuf();

	{
		VkCommandBufferBeginInfo begininf = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
		VkCommandBufferInheritanceInfo inh = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO};
		begininf.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
		begininf.pInheritanceInfo = &inh;
		inh.renderPass = VK_NULL_HANDLE;	//unused
		inh.subpass = 0;					//unused
		inh.framebuffer = VK_NULL_HANDLE;	//unused
		inh.occlusionQueryEnable = VK_FALSE;
		inh.queryFlags = 0;
		inh.pipelineStatistics = 0;
		vkBeginCommandBuffer(targ->cbuf, &begininf);
	}
#endif

	targ->prevtarg = vk.rendertarg;
	vk.rendertarg = targ;

	VKBE_SelectMode(shaderstate.mode);

	vkCmdBeginRenderPass(vk.rendertarg->cbuf, &targ->restartinfo, VK_SUBPASS_CONTENTS_INLINE);
	//future reuse shouldn't clear stuff
	if (targ->restartinfo.clearValueCount)
	{
		targ->depthcleared = true;
		targ->restartinfo.renderPass = VK_GetRenderPass(RP_RESUME|targ->rpassflags);
		targ->restartinfo.clearValueCount = 0;
	}

	{
		VkRect2D wrekt;
		VkViewport viewport;
		viewport.x = r_refdef.pxrect.x;
		viewport.y = r_refdef.pxrect.y;
		viewport.width = r_refdef.pxrect.width;
		viewport.height = r_refdef.pxrect.height;
		viewport.minDepth = 0;
		viewport.maxDepth = 1;
		vkCmdSetViewport(vk.rendertarg->cbuf, 0, 1, &viewport);
		wrekt.offset.x = viewport.x;
		wrekt.offset.y = viewport.y;
		wrekt.extent.width = viewport.width;
		wrekt.extent.height = viewport.height;
		vkCmdSetScissor(vk.rendertarg->cbuf, 0, 1, &wrekt);
	}
}

void VKBE_RT_End(struct vk_rendertarg *targ)
{
	if (R2D_Flush)
		R2D_Flush();

	vk.rendertarg = vk.rendertarg->prevtarg;

	vid.fbpwidth = vk.rendertarg->width;
	vid.fbpheight = vk.rendertarg->height;

#if 0
#else
	shaderstate.rc.activepipeline = VK_NULL_HANDLE;
	vkCmdEndRenderPass(targ->cbuf);
	vkEndCommandBuffer(targ->cbuf);

	VK_Submit_Work(targ->cbuf, VK_NULL_HANDLE, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, NULL);
	
//		VK_Submit_Work(VkCommandBuffer cmdbuf, VkSemaphore semwait, VkPipelineStageFlags semwaitstagemask, VkSemaphore semsignal, VkFence fencesignal, struct vkframe *presentframe, struct vk_fencework *fencedwork)
#endif

	VKBE_SelectMode(shaderstate.mode);
}

static qboolean BE_GenerateRefraction(batch_t *batch, shader_t *bs)
{
	float oldil;
	int oldbem;
//	struct vk_rendertarg *targ;
	//these flags require rendering some view as an fbo
	if (r_refdef.recurse)
		return false;
	if (r_refdef.recurse == r_portalrecursion.ival || r_refdef.recurse == R_MAX_RECURSE)
		return false;
	if (shaderstate.mode != BEM_STANDARD && shaderstate.mode != BEM_DEPTHDARK)
		return false;
	oldbem = shaderstate.mode;
	oldil = shaderstate.identitylighting;
//	targ = vk.rendertarg;

	if (bs->flags & SHADER_HASREFLECT)
	{
		vrect_t orect = r_refdef.vrect;
		pxrect_t oprect = r_refdef.pxrect;

		r_refdef.vrect.x = 0;
		r_refdef.vrect.y = 0;
		r_refdef.vrect.width = max(1, vid.fbvwidth*bs->portalfboscale);
		r_refdef.vrect.height = max(1, vid.fbvheight*bs->portalfboscale);
		VKBE_RT_Gen(&shaderstate.rt_reflection, NULL, r_refdef.vrect.width, r_refdef.vrect.height, false, RT_IMAGEFLAGS);
		VKBE_RT_Begin(&shaderstate.rt_reflection);
		R_DrawPortal(batch, cl.worldmodel->batches, NULL, 1);
		VKBE_RT_End(&shaderstate.rt_reflection);
		r_refdef.vrect = orect;
		r_refdef.pxrect = oprect;
	}
	if (bs->flags & (SHADER_HASREFRACT|SHADER_HASREFRACTDEPTH))
	{
		extern cvar_t r_refract_fbo;
		if (r_refract_fbo.ival || (bs->flags & SHADER_HASREFRACTDEPTH))
		{
			vrect_t ovrect = r_refdef.vrect;
			pxrect_t oprect = r_refdef.pxrect;

			r_refdef.vrect.x = 0;
			r_refdef.vrect.y = 0;
			r_refdef.vrect.width = vid.fbvwidth/2;
			r_refdef.vrect.height = vid.fbvheight/2;
			VKBE_RT_Gen(&shaderstate.rt_refraction, NULL, r_refdef.vrect.width, r_refdef.vrect.height, false, RT_IMAGEFLAGS);
			VKBE_RT_Begin(&shaderstate.rt_refraction);
			R_DrawPortal(batch, cl.worldmodel->batches, NULL, ((bs->flags & SHADER_HASREFRACTDEPTH)?3:2));	//fixme
			VKBE_RT_End(&shaderstate.rt_refraction);
			r_refdef.vrect = ovrect;
			r_refdef.pxrect = oprect;

			shaderstate.tex_refraction = &shaderstate.rt_refraction.q_colour;
		}
		else
		{
			R_DrawPortal(batch, cl.worldmodel->batches, NULL, 3);
			T_Gen_CurrentRender();
			shaderstate.tex_refraction = shaderstate.tex_currentrender;
		}
	}
	/*
	if (bs->flags & SHADER_HASRIPPLEMAP)
	{
		vrect_t orect = r_refdef.vrect;
		pxrect_t oprect = r_refdef.pxrect;
		r_refdef.vrect.x = 0;
		r_refdef.vrect.y = 0;
		r_refdef.vrect.width = vid.fbvwidth/2;
		r_refdef.vrect.height = vid.fbvheight/2;
		r_refdef.pxrect.x = 0;
		r_refdef.pxrect.y = 0;
		r_refdef.pxrect.width = vid.fbpwidth/2;
		r_refdef.pxrect.height = vid.fbpheight/2;

		if (!shaderstate.tex_ripplemap)
		{
			//FIXME: can we use RGB8 instead?
			shaderstate.tex_ripplemap = Image_CreateTexture("***tex_ripplemap***", NULL, 0);
			if (!shaderstate.tex_ripplemap->num)
				qglGenTextures(1, &shaderstate.tex_ripplemap->num);
		}
		if (shaderstate.tex_ripplemap->width != r_refdef.pxrect.width || shaderstate.tex_ripplemap->height != r_refdef.pxrect.height)
		{
			shaderstate.tex_ripplemap->width = r_refdef.pxrect.width;
			shaderstate.tex_ripplemap->height = r_refdef.pxrect.height;
			GL_MTBind(0, GL_TEXTURE_2D, shaderstate.tex_ripplemap);
			qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, r_refdef.pxrect.width, r_refdef.pxrect.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
			qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
			qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		}
		oldfbo = GLBE_FBO_Update(&shaderstate.fbo_reflectrefrac, 0, &shaderstate.tex_ripplemap, 1, r_nulltex, r_refdef.pxrect.width, r_refdef.pxrect.height, 0);
		r_refdef.pxrect.maxheight = shaderstate.fbo_reflectrefrac.rb_size[1];
		GL_ViewportUpdate();

		qglClearColor(0, 0, 0, 1);
		qglClear(GL_COLOR_BUFFER_BIT);

		r_refdef.vrect.x = 0;
		r_refdef.vrect.y = 0;
		r_refdef.vrect.width = vid.fbvwidth;
		r_refdef.vrect.height = vid.fbvheight;
		BE_RT_Begin(&shaderstate.rt_refraction, vid.fbpwidth, vid.fbpheight);

		r_refdef.recurse+=1; //paranoid, should stop potential infinite loops
		GLBE_SubmitMeshes(cl.worldmodel->batches, SHADER_SORT_RIPPLE, SHADER_SORT_RIPPLE);
		r_refdef.recurse-=1;

		r_refdef.vrect = orect;
		r_refdef.pxrect = oprect;
		BE_RT_End();
	}
	*/
	VKBE_SelectMode(oldbem);
	shaderstate.identitylighting = oldil;

	return true;
}

static void BE_SubmitMeshesSortList(batch_t *sortlist)
{
	batch_t *batch;
	for (batch = sortlist; batch; batch = batch->next)
	{
		if (batch->meshes == batch->firstmesh)
			continue;

		if (batch->buildmeshes)
			batch->buildmeshes(batch);

		if (batch->shader->flags & SHADER_NODLIGHT)
			if (shaderstate.mode == BEM_LIGHT)
				continue;

		if (batch->shader->flags & SHADER_SKY)
		{
			if (shaderstate.mode == BEM_STANDARD || shaderstate.mode == BEM_DEPTHDARK)
			{
				if (R_DrawSkyChain (batch))
					continue;
			}
			else if (shaderstate.mode != BEM_FOG && shaderstate.mode != BEM_CREPUSCULAR && shaderstate.mode != BEM_WIREFRAME)
				continue;
		}

		if ((batch->shader->flags & (SHADER_HASREFLECT | SHADER_HASREFRACT | SHADER_HASRIPPLEMAP)) && shaderstate.mode != BEM_WIREFRAME)
			if (!BE_GenerateRefraction(batch, batch->shader))
				continue;

		VKBE_SubmitBatch(batch);
	}
}


/*generates a new modelview matrix, as well as vpn vectors*/
static void R_MirrorMatrix(plane_t *plane)
{
	float mirror[16];
	float view[16];
	float result[16];

	vec3_t pnorm;
	VectorNegate(plane->normal, pnorm);

	mirror[0] = 1-2*pnorm[0]*pnorm[0];
	mirror[1] = -2*pnorm[0]*pnorm[1];
	mirror[2] = -2*pnorm[0]*pnorm[2];
	mirror[3] = 0;

	mirror[4] = -2*pnorm[1]*pnorm[0];
	mirror[5] = 1-2*pnorm[1]*pnorm[1];
	mirror[6] = -2*pnorm[1]*pnorm[2] ;
	mirror[7] = 0;

	mirror[8]  = -2*pnorm[2]*pnorm[0];
	mirror[9]  = -2*pnorm[2]*pnorm[1];
	mirror[10] = 1-2*pnorm[2]*pnorm[2];
	mirror[11] = 0;

	mirror[12] = -2*pnorm[0]*plane->dist;
	mirror[13] = -2*pnorm[1]*plane->dist;
	mirror[14] = -2*pnorm[2]*plane->dist;
	mirror[15] = 1;

	view[0] = vpn[0];
	view[1] = vpn[1];
	view[2] = vpn[2];
	view[3] = 0;

	view[4] = -vright[0];
	view[5] = -vright[1];
	view[6] = -vright[2];
	view[7] = 0;

	view[8]  = vup[0];
	view[9]  = vup[1];
	view[10] = vup[2];
	view[11] = 0;

	view[12] = r_refdef.vieworg[0];
	view[13] = r_refdef.vieworg[1];
	view[14] = r_refdef.vieworg[2];
	view[15] = 1;

	VectorMA(r_refdef.vieworg, 0.25, plane->normal, r_refdef.pvsorigin);

	Matrix4_Multiply(mirror, view, result);

	vpn[0] = result[0];
	vpn[1] = result[1];
	vpn[2] = result[2];

	vright[0] = -result[4];
	vright[1] = -result[5];
	vright[2] = -result[6];

	vup[0] = result[8];
	vup[1] = result[9];
	vup[2] = result[10];

	r_refdef.vieworg[0] = result[12];
	r_refdef.vieworg[1] = result[13];
	r_refdef.vieworg[2] = result[14];
}
static entity_t *R_NearestPortal(plane_t *plane)
{
	int i;
	entity_t *best = NULL;
	float dist, bestd = 0;
	//for q3-compat, portals on world scan for a visedict to use for their view.
	for (i = 0; i < cl_numvisedicts; i++)
	{
		if (cl_visedicts[i].rtype == RT_PORTALSURFACE)
		{
			dist = DotProduct(cl_visedicts[i].origin, plane->normal)-plane->dist;
			dist = fabs(dist);
			if (dist < 64 && (!best || dist < bestd))
				best = &cl_visedicts[i];
		}
	}
	return best;
}

static void TransformCoord(vec3_t in, vec3_t planea[3], vec3_t planeo, vec3_t viewa[3], vec3_t viewo, vec3_t result)
{
	int		i;
	vec3_t	local;
	vec3_t	transformed;
	float	d;

	local[0] = in[0] - planeo[0];
	local[1] = in[1] - planeo[1];
	local[2] = in[2] - planeo[2];

	VectorClear(transformed);
	for ( i = 0 ; i < 3 ; i++ )
	{
		d = DotProduct(local, planea[i]);
		VectorMA(transformed, d, viewa[i], transformed);
	}

	result[0] = transformed[0] + viewo[0];
	result[1] = transformed[1] + viewo[1];
	result[2] = transformed[2] + viewo[2];
}
static void TransformDir(vec3_t in, vec3_t planea[3], vec3_t viewa[3], vec3_t result)
{
	int		i;
	float	d;
	vec3_t tmp;

	VectorCopy(in, tmp);

	VectorClear(result);
	for ( i = 0 ; i < 3 ; i++ )
	{
		d = DotProduct(tmp, planea[i]);
		VectorMA(result, d, viewa[i], result);
	}
}

void R_ObliqueNearClip(float *viewmat, mplane_t *wplane);
void CL_DrawDebugPlane(float *normal, float dist, float r, float g, float b, qboolean enqueue);
static void R_DrawPortal(batch_t *batch, batch_t **blist, batch_t *depthmasklist[2], int portaltype)
{
	entity_t *view;
	plane_t plane, oplane;
	float vmat[16];
	refdef_t oldrefdef;
	vec3_t r;
	int i;
	mesh_t *mesh = batch->mesh[batch->firstmesh];
	pvsbuffer_t newvis;
	float ivmat[16], trmat[16];

	if (r_refdef.recurse >= R_MAX_RECURSE-1)
		return;

	if (!mesh->xyz_array)
		return;

	if (!mesh->normals_array)
	{
		VectorSet(plane.normal, 0, 0, 1);
	}
	else
	{
		VectorCopy(mesh->normals_array[0], plane.normal);
	}

	if (batch->ent == &r_worldentity)
	{
		plane.dist = DotProduct(mesh->xyz_array[0], plane.normal);
	}
	else
	{
		vec3_t point;
		VectorCopy(plane.normal, oplane.normal);
		//rotate the surface normal around its entity's matrix
		plane.normal[0] = oplane.normal[0]*batch->ent->axis[0][0] + oplane.normal[1]*batch->ent->axis[1][0] + oplane.normal[2]*batch->ent->axis[2][0];
		plane.normal[1] = oplane.normal[0]*batch->ent->axis[0][1] + oplane.normal[1]*batch->ent->axis[1][1] + oplane.normal[2]*batch->ent->axis[2][1];
		plane.normal[2] = oplane.normal[0]*batch->ent->axis[0][2] + oplane.normal[1]*batch->ent->axis[1][2] + oplane.normal[2]*batch->ent->axis[2][2];

		//rotate some point on the mesh around its entity's matrix
		point[0] = mesh->xyz_array[0][0]*batch->ent->axis[0][0] + mesh->xyz_array[0][1]*batch->ent->axis[1][0] + mesh->xyz_array[0][2]*batch->ent->axis[2][0] + batch->ent->origin[0];
		point[1] = mesh->xyz_array[0][0]*batch->ent->axis[0][1] + mesh->xyz_array[0][1]*batch->ent->axis[1][1] + mesh->xyz_array[0][2]*batch->ent->axis[2][1] + batch->ent->origin[1];
		point[2] = mesh->xyz_array[0][0]*batch->ent->axis[0][2] + mesh->xyz_array[0][1]*batch->ent->axis[1][2] + mesh->xyz_array[0][2]*batch->ent->axis[2][2] + batch->ent->origin[2];

		//now we can figure out the plane dist
		plane.dist = DotProduct(point, plane.normal);
	}

	//if we're too far away from the surface, don't draw anything
	if (batch->shader->flags & SHADER_AGEN_PORTAL)
	{
		/*there's a portal alpha blend on that surface, that fades out after this distance*/
		if (DotProduct(r_refdef.vieworg, plane.normal)-plane.dist > batch->shader->portaldist)
			return;
	}
	//if we're behind it, then also don't draw anything. for our purposes, behind is when the entire near clipplane is behind.
	if (DotProduct(r_refdef.vieworg, plane.normal)-plane.dist < -r_refdef.mindist)
		return;

	TRACE(("R_DrawPortal: portal type %i\n", portaltype));

	oldrefdef = r_refdef;
	r_refdef.recurse+=1;

	r_refdef.externalview = true;

	switch(portaltype)
	{
	case 1: /*fbo explicit mirror (fucked depth, working clip plane)*/
		//fixme: pvs is surely wrong?
//		r_refdef.flipcull ^= SHADER_CULL_FLIP;
		R_MirrorMatrix(&plane);
		Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);

		VectorCopy(mesh->xyz_array[0], r_refdef.pvsorigin);
		for (i = 1; i < mesh->numvertexes; i++)
			VectorAdd(r_refdef.pvsorigin, mesh->xyz_array[i], r_refdef.pvsorigin);
		VectorScale(r_refdef.pvsorigin, 1.0/mesh->numvertexes, r_refdef.pvsorigin);
		break;
	
	case 2:	/*fbo refraction (fucked depth, working clip plane)*/
	case 3:	/*screen copy refraction (screen depth, fucked clip planes)*/
		/*refraction image (same view, just with things culled*/
		r_refdef.externalview = oldrefdef.externalview;
		VectorNegate(plane.normal, plane.normal);
		plane.dist = -plane.dist;

		//use the player's origin for r_viewleaf, because there's not much we can do anyway*/
		VectorCopy(r_origin, r_refdef.pvsorigin);

		if (cl.worldmodel && cl.worldmodel->funcs.ClusterPVS && !r_novis.ival)
		{
			int clust, i, j;
			float d;
			vec3_t point;
			r_refdef.forcevis = true;
			r_refdef.forcedvis = NULL;
			newvis.buffer = alloca(newvis.buffersize=cl.worldmodel->pvsbytes);
			for (i = batch->firstmesh; i < batch->meshes; i++)
			{
				mesh = batch->mesh[i];
				VectorClear(point);
				for (j = 0; j < mesh->numvertexes; j++)
					VectorAdd(point, mesh->xyz_array[j], point);
				VectorScale(point, 1.0f/mesh->numvertexes, point);
				d = DotProduct(point, plane.normal) - plane.dist;
				d += 0.1;	//an epsilon on the far side
				VectorMA(point, d, plane.normal, point);

				clust = cl.worldmodel->funcs.ClusterForPoint(cl.worldmodel, point, NULL);
				if (i == batch->firstmesh)
					r_refdef.forcedvis = cl.worldmodel->funcs.ClusterPVS(cl.worldmodel, clust, &newvis, PVM_REPLACE);
				else
					r_refdef.forcedvis = cl.worldmodel->funcs.ClusterPVS(cl.worldmodel, clust, &newvis, PVM_MERGE);
			}
//			memset(newvis, 0xff, pvsbytes);
		}
		Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
		break;

	case 0:		/*q3 portal*/
	default:
#ifdef CSQC_DAT
		if (CSQC_SetupToRenderPortal(batch->ent->keynum))
		{
			oplane = plane;

			//transform the old surface plane into the new view matrix
			Matrix4_Invert(r_refdef.m_view, ivmat);
			Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
			Matrix4_Multiply(ivmat, vmat, trmat);
			plane.normal[0] = -(oplane.normal[0] * trmat[0] + oplane.normal[1] * trmat[1] + oplane.normal[2] * trmat[2]);
			plane.normal[1] = -(oplane.normal[0] * trmat[4] + oplane.normal[1] * trmat[5] + oplane.normal[2] * trmat[6]);
			plane.normal[2] = -(oplane.normal[0] * trmat[8] + oplane.normal[1] * trmat[9] + oplane.normal[2] * trmat[10]);
			plane.dist = -oplane.dist + trmat[12]*oplane.normal[0] + trmat[13]*oplane.normal[1] + trmat[14]*oplane.normal[2];

			if (Cvar_Get("temp_useplaneclip", "1", 0, "temp")->ival)
				portaltype = 1;	//make sure the near clipplane is used.
		}
		else
#endif
			if (!(view = R_NearestPortal(&plane)) || VectorCompare(view->origin, view->oldorigin))
		{
			//a portal with no portal entity, or a portal rentity with an origin equal to its oldorigin, is a mirror.
//			r_refdef.flipcull ^= SHADER_CULL_FLIP;
			R_MirrorMatrix(&plane);
			Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);

			VectorCopy(mesh->xyz_array[0], r_refdef.pvsorigin);
			for (i = 1; i < mesh->numvertexes; i++)
				VectorAdd(r_refdef.pvsorigin, mesh->xyz_array[i], r_refdef.pvsorigin);
			VectorScale(r_refdef.pvsorigin, 1.0/mesh->numvertexes, r_refdef.pvsorigin);

			portaltype = 1;
		}
		else
		{
			float d;
			vec3_t paxis[3], porigin, vaxis[3], vorg;
			void PerpendicularVector( vec3_t dst, const vec3_t src );

			oplane = plane;

			/*calculate where the surface is meant to be*/
			VectorCopy(mesh->normals_array[0], paxis[0]);
			PerpendicularVector(paxis[1], paxis[0]);
			CrossProduct(paxis[0], paxis[1], paxis[2]);
			d = DotProduct(view->origin, plane.normal) - plane.dist;
			VectorMA(view->origin, -d, paxis[0], porigin);

			/*grab the camera origin*/
			VectorNegate(view->axis[0], vaxis[0]);
			VectorNegate(view->axis[1], vaxis[1]);
			VectorCopy(view->axis[2], vaxis[2]);
			VectorCopy(view->oldorigin, vorg);

			VectorCopy(vorg, r_refdef.pvsorigin);

			/*rotate it a bit*/
			if (view->framestate.g[FS_REG].frame[1])	//oldframe
			{
				if (view->framestate.g[FS_REG].frame[0])	//newframe
					d = realtime * view->framestate.g[FS_REG].frame[0];	//newframe
				else
					d = view->skinnum + sin(realtime)*4;
			}
			else
				d = view->skinnum;

			if (d)
			{
				vec3_t rdir;
				VectorCopy(vaxis[1], rdir);
				RotatePointAroundVector(vaxis[1], vaxis[0], rdir, d);
				CrossProduct(vaxis[0], vaxis[1], vaxis[2]);
			}

			TransformCoord(oldrefdef.vieworg, paxis, porigin, vaxis, vorg, r_refdef.vieworg);
			TransformDir(vpn, paxis, vaxis, vpn);
			TransformDir(vright, paxis, vaxis, vright);
			TransformDir(vup, paxis, vaxis, vup);
			Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);

			//transform the old surface plane into the new view matrix
			if (Matrix4_Invert(r_refdef.m_view, ivmat))
			{
				Matrix4_Multiply(ivmat, vmat, trmat);
				plane.normal[0] = -(oplane.normal[0] * trmat[0] + oplane.normal[1] * trmat[1] + oplane.normal[2] * trmat[2]);
				plane.normal[1] = -(oplane.normal[0] * trmat[4] + oplane.normal[1] * trmat[5] + oplane.normal[2] * trmat[6]);
				plane.normal[2] = -(oplane.normal[0] * trmat[8] + oplane.normal[1] * trmat[9] + oplane.normal[2] * trmat[10]);
				plane.dist = -oplane.dist + trmat[12]*oplane.normal[0] + trmat[13]*oplane.normal[1] + trmat[14]*oplane.normal[2];
				portaltype = 1;
			}
		}
		break;
	}

	/*FIXME: can we get away with stenciling the screen?*/
	/*Add to frustum culling instead of clip planes?*/
/*	if (qglClipPlane && portaltype)
	{
		GLdouble glplane[4];
		glplane[0] = plane.normal[0];
		glplane[1] = plane.normal[1];
		glplane[2] = plane.normal[2];
		glplane[3] = plane.dist;
		qglClipPlane(GL_CLIP_PLANE0, glplane);
		qglEnable(GL_CLIP_PLANE0);
	}
*/	//fixme: we can probably scissor a smaller frusum
	R_SetFrustum (r_refdef.m_projection_std, vmat);
	if (r_refdef.frustum_numplanes < MAXFRUSTUMPLANES)
	{
		extern int SignbitsForPlane (mplane_t *out);
		mplane_t fp;
		VectorCopy(plane.normal, fp.normal);
		fp.dist = plane.dist;

//		if (DotProduct(fp.normal, vpn) < 0)
//		{
//			VectorNegate(fp.normal, fp.normal);
//			fp.dist *= -1;
//		}

		fp.type = PLANE_ANYZ;
		fp.signbits = SignbitsForPlane (&fp);

		if (portaltype == 1 || portaltype == 2)
			R_ObliqueNearClip(vmat, &fp);

		//our own culling should be an epsilon forwards so we don't still draw things behind the line due to precision issues.
		fp.dist += 0.01;
		r_refdef.frustum[r_refdef.frustum_numplanes++] = fp;
	}

	//force culling to update to match the new front face.
//	memcpy(r_refdef.m_view, vmat, sizeof(float)*16);
#if 0
	if (depthmasklist)
	{
		/*draw already-drawn portals as depth-only, to ensure that their contents are not harmed*/
		/*we can only do this AFTER the oblique perspective matrix is calculated, to avoid depth inconsistancies, while we still have the old view matrix*/
		int i;
		batch_t *dmask = NULL;
		//portals to mask are relative to the old view still.
		GLBE_SelectEntity(&r_worldentity);
		currententity = NULL;
		if (gl_config.arb_depth_clamp)
			qglEnable(GL_DEPTH_CLAMP_ARB);	//ignore the near clip plane(ish), this means nearer portals can still mask further ones.
		GL_ForceDepthWritable();
		GLBE_SelectMode(BEM_DEPTHONLY);
		for (i = 0; i < 2; i++)
		{
			for (dmask = depthmasklist[i]; dmask; dmask = dmask->next)
			{
				if (dmask == batch)
					continue;
				if (dmask->meshes == dmask->firstmesh)
					continue;
				GLBE_SubmitBatch(dmask);
			}
		}
		GLBE_SelectMode(BEM_STANDARD);
		if (gl_config.arb_depth_clamp)
			qglDisable(GL_DEPTH_CLAMP_ARB);

		currententity = NULL;
	}
#endif

	currententity = NULL;

	//now determine the stuff the backend will use.
	memcpy(r_refdef.m_view, vmat, sizeof(float)*16);
	VectorAngles(vpn, vup, r_refdef.viewangles, false);
	VectorCopy(r_refdef.vieworg, r_origin);

	//determine r_refdef.flipcull & SHADER_CULL_FLIP based upon whether right is right or not.
	CrossProduct(vpn, vup, r);
	if (DotProduct(r, vright) < 0)
		r_refdef.flipcull |= SHADER_CULL_FLIP;
	else
		r_refdef.flipcull &= ~SHADER_CULL_FLIP;
	if (r_refdef.m_projection_std[5]<0)
		r_refdef.flipcull ^= SHADER_CULL_FLIP;

	VKBE_SelectEntity(&r_worldentity);

	Surf_SetupFrame();
	Surf_DrawWorld();
	//FIXME: just call Surf_DrawWorld instead?
//	R_RenderScene();

#if 0
	if (r_portaldrawplanes.ival)
	{
		//the front of the plane should generally point away from the camera, and will be drawn in bright green. woo
		CL_DrawDebugPlane(plane.normal, plane.dist+0.01, 0.0, 0.5, 0.0, false);
		CL_DrawDebugPlane(plane.normal, plane.dist-0.01, 0.0, 0.5, 0.0, false);
		//the back of the plane points towards the camera, and will be drawn in blue, for the luls
		VectorNegate(plane.normal, plane.normal);
		plane.dist *= -1;
		CL_DrawDebugPlane(plane.normal, plane.dist+0.01, 0.0, 0.0, 0.2, false);
		CL_DrawDebugPlane(plane.normal, plane.dist-0.01, 0.0, 0.0, 0.2, false);
	}
#endif


	r_refdef = oldrefdef;

	/*broken stuff*/
	AngleVectors (r_refdef.viewangles, vpn, vright, vup);
	VectorCopy (r_refdef.vieworg, r_origin);

	VKBE_SelectEntity(&r_worldentity);

	TRACE(("GLR_DrawPortal: portal drawn\n"));

	currententity = NULL;
}

static void BE_SubmitMeshesPortals(batch_t **worldlist, batch_t *dynamiclist)
{
	batch_t *batch, *old;
	int i;
	/*attempt to draw portal shaders*/
	if (shaderstate.mode == BEM_STANDARD)
	{
		for (i = 0; i < 2; i++)
		{
			for (batch = i?dynamiclist:worldlist[SHADER_SORT_PORTAL]; batch; batch = batch->next)
			{
				if (batch->meshes == batch->firstmesh)
					continue;

				if (batch->buildmeshes)
					batch->buildmeshes(batch);

				/*draw already-drawn portals as depth-only, to ensure that their contents are not harmed*/
				VKBE_SelectMode(BEM_DEPTHONLY);
				for (old = worldlist[SHADER_SORT_PORTAL]; old && old != batch; old = old->next)
				{
					if (old->meshes == old->firstmesh)
						continue;
					VKBE_SubmitBatch(old);
				}
				if (!old)
				{
					for (old = dynamiclist; old != batch; old = old->next)
					{
						if (old->meshes == old->firstmesh)
							continue;
						VKBE_SubmitBatch(old);
					}
				}
				VKBE_SelectMode(BEM_STANDARD);

				R_DrawPortal(batch, worldlist, NULL, 0);

				{
					VkClearAttachment clr;
					VkClearRect rect;
					clr.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
					clr.clearValue.depthStencil.depth = 1;
					clr.clearValue.depthStencil.stencil = 0;
					clr.colorAttachment = 1;
					rect.rect.offset.x = r_refdef.pxrect.x;
					rect.rect.offset.y = r_refdef.pxrect.y;
					rect.rect.extent.width = r_refdef.pxrect.width;
					rect.rect.extent.height = r_refdef.pxrect.height;
					rect.layerCount = 1;
					rect.baseArrayLayer = 0;
					vkCmdClearAttachments(vk.rendertarg->cbuf, 1, &clr, 1, &rect);
				}
				VKBE_SelectMode(BEM_DEPTHONLY);
				VKBE_SubmitBatch(batch);
				VKBE_SelectMode(BEM_STANDARD);
			}
		}
	}
}

void VKBE_SubmitMeshes (batch_t **worldbatches, batch_t **blist, int first, int stop)
{
	int i;

	for (i = first; i < stop; i++)
	{
		if (worldbatches)
		{
			if (i == SHADER_SORT_PORTAL  && !r_refdef.recurse)
				BE_SubmitMeshesPortals(worldbatches, blist[i]);

			BE_SubmitMeshesSortList(worldbatches[i]);
		}
		BE_SubmitMeshesSortList(blist[i]);
	}
}

#ifdef RTLIGHTS
//FIXME: needs context for threading
void VKBE_BaseEntTextures(const qbyte *scenepvs, const int *sceneareas)
{
	batch_t *batches[SHADER_SORT_COUNT];
	BE_GenModelBatches(batches, shaderstate.curdlight, shaderstate.mode, scenepvs, sceneareas);
	VKBE_SubmitMeshes(NULL, batches, SHADER_SORT_PORTAL, SHADER_SORT_SEETHROUGH+1);
	VKBE_SelectEntity(&r_worldentity);
}

struct vk_shadowbuffer
{
	qboolean isstatic;

	VkBuffer vbuffer;
	VkDeviceSize voffset;
	vk_poolmem_t vmemory;
	unsigned int numverts;

	VkBuffer ibuffer;
	VkDeviceSize ioffset;
	vk_poolmem_t imemory;
	unsigned int numindicies;
};
//FIXME: needs context for threading
struct vk_shadowbuffer *VKBE_GenerateShadowBuffer(vecV_t *verts, int numverts, index_t *indicies, int numindicies, qboolean istemp)
{
	static struct vk_shadowbuffer tempbuf;
	if (!numverts || !numindicies)
		return NULL;
	if (istemp)
	{
		struct vk_shadowbuffer *buf = &tempbuf;
		void *fte_restrict map;

		map = VKBE_AllocateBufferSpace(DB_VBO, sizeof(*verts)*numverts, &buf->vbuffer, &buf->voffset);
		memcpy(map, verts, sizeof(*verts)*numverts);
		buf->numverts = numverts;

		map = VKBE_AllocateBufferSpace(DB_EBO, sizeof(*indicies)*numindicies, &buf->ibuffer, &buf->ioffset);
		memcpy(map, indicies, sizeof(*indicies)*numindicies);
		buf->numindicies = numindicies;
		return buf;
	}
	else
	{
		//FIXME: these buffers should really be some subsection of a larger buffer
		struct vk_shadowbuffer *buf = BZ_Malloc(sizeof(*buf));
		struct stagingbuf vbuf;
		void *fte_restrict map;
		buf->isstatic = true;

		map = VKBE_CreateStagingBuffer(&vbuf, sizeof(*verts) * numverts, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
		memcpy(map, verts, sizeof(*verts) * numverts);
		buf->vbuffer = VKBE_FinishStaging(&vbuf, &buf->vmemory);
		buf->voffset = 0;
		buf->numverts = numverts;

		map = VKBE_CreateStagingBuffer(&vbuf, sizeof(*indicies) * numindicies, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
		memcpy(map, indicies, sizeof(*indicies) * numindicies);
		buf->ibuffer = VKBE_FinishStaging(&vbuf, &buf->imemory);
		buf->ioffset = 0;
		buf->numindicies = numindicies;
		return buf;
	}
}
static void VKBE_DestroyShadowBuffer_Delayed(void *ctx)
{
	struct vk_shadowbuffer *buf = ctx;
	vkDestroyBuffer(vk.device, buf->vbuffer, vkallocationcb);
	vkDestroyBuffer(vk.device, buf->ibuffer, vkallocationcb);
	VK_ReleasePoolMemory(&buf->vmemory);
	VK_ReleasePoolMemory(&buf->imemory);
}
void VKBE_DestroyShadowBuffer(struct vk_shadowbuffer *buf)
{
	if (buf && buf->isstatic)
	{
		VK_AtFrameEnd(VKBE_DestroyShadowBuffer_Delayed, buf, sizeof(*buf));
		Z_Free(buf);
	}
}

//draws all depth-only surfaces from the perspective of the light.
//FIXME: needs context for threading
void VKBE_RenderShadowBuffer(struct vk_shadowbuffer *buf)
{
	shader_t *depthonlyshader;
	if (!buf)
		return;

	depthonlyshader = R_RegisterShader("depthonly", SUF_NONE,
				"{\n"
					"program depthonly\n"
					"{\n"
						"depthwrite\n"
						"maskcolor\n"
					"}\n"
				"}\n"
			);

	vkCmdBindVertexBuffers(vk.rendertarg->cbuf, 0, 1, &buf->vbuffer, &buf->voffset);
	vkCmdBindIndexBuffer(vk.rendertarg->cbuf, buf->ibuffer, buf->ioffset, VK_INDEX_TYPE);
	if (BE_SetupMeshProgram(depthonlyshader->prog, depthonlyshader->passes, 0, buf->numindicies))
		vkCmdDrawIndexed(vk.rendertarg->cbuf, buf->numindicies, 1, 0, 0, 0);
}


static void VK_TerminateShadowMap(void)
{
	struct shadowmaps_s *shad;
	unsigned int sbuf, i;

	for (sbuf = 0; sbuf < countof(shaderstate.shadow); sbuf++)
	{
		shad = &shaderstate.shadow[sbuf];
		if (!shad->image)
			continue;

		for (i = 0; i < countof(shad->buf); i++)
		{
			vkDestroyImageView(vk.device, shad->buf[i].vimage.view, vkallocationcb);
			vkDestroySampler(vk.device, shad->buf[i].vimage.sampler, vkallocationcb);
			vkDestroyFramebuffer(vk.device, shad->buf[i].framebuffer, vkallocationcb);
		}
		vkDestroyImage(vk.device, shad->image, vkallocationcb);
		vkFreeMemory(vk.device, shad->memory, vkallocationcb);

		shad->width = 0;
		shad->height = 0;
	}
}

qboolean VKBE_BeginShadowmap(qboolean isspot, uint32_t width, uint32_t height)
{
	struct shadowmaps_s *shad = &shaderstate.shadow[isspot];
	unsigned int sbuf;

//	const qboolean altqueue = false;

//	if (!altqueue)
		vkCmdEndRenderPass(vk.rendertarg->cbuf);

	if (shad->width != width || shad->height != height)
	{
		//actually, this will really only happen once per.
		//so we can be lazy and not free here... check out validation/leak warnings if this changes...

		unsigned int i;
		VkFramebufferCreateInfo fbinfo = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
		VkImageCreateInfo imginfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
		imginfo.format = vk.depthformat;
		imginfo.flags = 0;
		imginfo.imageType = VK_IMAGE_TYPE_2D;
		imginfo.extent.width = width;
		imginfo.extent.height = height;
		imginfo.extent.depth = 1;
		imginfo.mipLevels = 1;
		imginfo.arrayLayers = countof(shad->buf);
		imginfo.samples = VK_SAMPLE_COUNT_1_BIT;
		imginfo.tiling = VK_IMAGE_TILING_OPTIMAL;
		imginfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_SAMPLED_BIT;
		imginfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
		imginfo.queueFamilyIndexCount = 0;
		imginfo.pQueueFamilyIndices = NULL;
		imginfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
		VkAssert(vkCreateImage(vk.device, &imginfo, vkallocationcb, &shad->image));
		DebugSetName(VK_OBJECT_TYPE_IMAGE, (uint64_t)shad->image, "Shadowmap");

		{
			VkMemoryRequirements mem_reqs;
			VkMemoryAllocateInfo memAllocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
			vkGetImageMemoryRequirements(vk.device, shad->image, &mem_reqs);
			memAllocInfo.allocationSize = mem_reqs.size;
			memAllocInfo.memoryTypeIndex = vk_find_memory_try(mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
			if (memAllocInfo.memoryTypeIndex == ~0)
				memAllocInfo.memoryTypeIndex = vk_find_memory_require(mem_reqs.memoryTypeBits, 0);
			VkAssert(vkAllocateMemory(vk.device, &memAllocInfo, vkallocationcb, &shad->memory));
			VkAssert(vkBindImageMemory(vk.device, shad->image, shad->memory, 0));
		}

		fbinfo.flags = 0;
		fbinfo.renderPass = VK_GetRenderPass(RP_DEPTHONLY);
		fbinfo.attachmentCount = 1;
		fbinfo.width = width;
		fbinfo.height = height;
		fbinfo.layers = 1;
		for (i = 0; i < countof(shad->buf); i++)
		{
			VkImageViewCreateInfo ivci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
			ivci.format = imginfo.format;
			ivci.components.r = VK_COMPONENT_SWIZZLE_R;
			ivci.components.g = VK_COMPONENT_SWIZZLE_G;
			ivci.components.b = VK_COMPONENT_SWIZZLE_B;
			ivci.components.a = VK_COMPONENT_SWIZZLE_A;
			ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
			ivci.subresourceRange.baseMipLevel = 0;
			ivci.subresourceRange.levelCount = 1;
			ivci.subresourceRange.baseArrayLayer = i;
			ivci.subresourceRange.layerCount = 1;
			ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
			ivci.flags = 0;
			ivci.image = shad->image;
			shad->buf[i].vimage.image = shad->image;
			VkAssert(vkCreateImageView(vk.device, &ivci, vkallocationcb, &shad->buf[i].vimage.view));

			{
				VkSamplerCreateInfo lmsampinfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
				lmsampinfo.minFilter = lmsampinfo.magFilter = VK_FILTER_LINEAR;
				lmsampinfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
				lmsampinfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
				lmsampinfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
				lmsampinfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
				lmsampinfo.mipLodBias = 0.0;
				lmsampinfo.anisotropyEnable = VK_FALSE;
				lmsampinfo.maxAnisotropy = 1.0;
				lmsampinfo.compareEnable = VK_TRUE;
				lmsampinfo.compareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
				lmsampinfo.minLod = 0;
				lmsampinfo.maxLod = 0;
				lmsampinfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
				lmsampinfo.unnormalizedCoordinates = VK_FALSE;
				VkAssert(vkCreateSampler(vk.device, &lmsampinfo, NULL, &shad->buf[i].vimage.sampler));
			}

			shad->buf[i].qimage.vkimage = &shad->buf[i].vimage;
			shad->buf[i].vimage.layout = VK_IMAGE_LAYOUT_UNDEFINED;

			fbinfo.pAttachments = &shad->buf[i].vimage.view;
			VkAssert(vkCreateFramebuffer(vk.device, &fbinfo, vkallocationcb, &shad->buf[i].framebuffer));
		}

		shad->width = width;
		shad->height = height;
	}

	sbuf = shad->seq++%countof(shad->buf);
	shaderstate.currentshadowmap = &shad->buf[sbuf].qimage;
/*
	{
		VkImageMemoryBarrier imgbarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
		imgbarrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
		imgbarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
		imgbarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;	//we don't actually care because we'll be clearing it anyway, making this more of a no-op than anything else.
		imgbarrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
		imgbarrier.image = shad->buf[sbuf].vimage.image;
		imgbarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
		imgbarrier.subresourceRange.baseMipLevel = 0;
		imgbarrier.subresourceRange.levelCount = 1;
		imgbarrier.subresourceRange.baseArrayLayer = sbuf;
		imgbarrier.subresourceRange.layerCount = 1;
		imgbarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		imgbarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		vkCmdPipelineBarrier(vk.rendertarg->cbuf, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0, NULL, 1, &imgbarrier);
	}
*/
	{
		VkClearValue clearval;
		VkRenderPassBeginInfo rpass = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO};
		clearval.depthStencil.depth = 1;
		clearval.depthStencil.stencil = 0;
		rpass.renderPass = VK_GetRenderPass(RP_DEPTHONLY);
		rpass.framebuffer = shad->buf[sbuf].framebuffer;
		rpass.renderArea.offset.x = 0;
		rpass.renderArea.offset.y = 0;
		rpass.renderArea.extent.width = width;
		rpass.renderArea.extent.height = height;
		rpass.clearValueCount = 1;
		rpass.pClearValues = &clearval;
		vkCmdBeginRenderPass(vk.rendertarg->cbuf, &rpass, VK_SUBPASS_CONTENTS_INLINE);
	}
	shaderstate.currentshadowmap->vkimage->layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

	//viewport+scissor will be done elsewhere
	//that wasn't too painful, was it?...
	return true;
}

void VKBE_DoneShadows(void)
{
//	struct shadowmaps_s *shad = &shaderstate.shadow[isspot];
	VkViewport viewport;

//	const qboolean altqueue = false;

	//we've rendered the shadowmap, but now we need to blit it to the screen
	//so set stuff back to the main view. FIXME: do these in batches to ease the load on tilers.
	vkCmdEndRenderPass(vk.rendertarg->cbuf);

	/*if (altqueue)
	{
		vkCmdSetEvent(alt, shadowcompleteevent);
		VKBE_FlushDynamicBuffers();
		VK_Submit_Work();
		vkCmdWaitEvents(main, 1, &shadowcompleteevent, barrierstuff);
		vkCmdResetEvent(main, shadowcompleteevent);
	}
	else*/
	{
		/*
		set_image_layout(vk.frame->cbuf, shad->image, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_ACCESS_SHADER_READ_BIT);

		{
			VkImageMemoryBarrier imgbarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
			imgbarrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
			imgbarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
			imgbarrier.oldLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
			imgbarrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
			imgbarrier.image = image;
			imgbarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
			imgbarrier.subresourceRange.baseMipLevel = 0;
			imgbarrier.subresourceRange.levelCount = 1;
			imgbarrier.subresourceRange.baseArrayLayer = 0;
			imgbarrier.subresourceRange.layerCount = 1;
			imgbarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
			imgbarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
			vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &imgbarrier);
		}
		*/

		vkCmdBeginRenderPass(vk.rendertarg->cbuf, &vk.rendertarg->restartinfo, VK_SUBPASS_CONTENTS_INLINE);

		viewport.x = r_refdef.pxrect.x;
		viewport.y = r_refdef.pxrect.y;//r_refdef.pxrect.maxheight - (r_refdef.pxrect.y+r_refdef.pxrect.height);	//silly GL...
		viewport.width = r_refdef.pxrect.width;
		viewport.height = r_refdef.pxrect.height;
		viewport.minDepth = 0;
		viewport.maxDepth = 1;
		vkCmdSetViewport(vk.rendertarg->cbuf, 0, 1, &viewport);
	}
	shaderstate.currentshadowmap->vkimage->layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

	VKBE_SelectEntity(&r_worldentity);
}

void VKBE_SetupForShadowMap(dlight_t *dl, int texwidth, int texheight, float shadowscale)
{
#define SHADOWMAP_SIZE 512
	extern cvar_t r_shadow_shadowmapping_nearclip, r_shadow_shadowmapping_bias;
	float nc = dl->nearclip?dl->nearclip:r_shadow_shadowmapping_nearclip.value;
	float bias = r_shadow_shadowmapping_bias.value;

	//much of the projection matrix cancels out due to symmetry and stuff
	//we need to scale between -0.5,0.5 within the sub-image. the fragment shader will center on the subimage based upon the major axis.
	//in d3d, the depth value is scaled between 0 and 1 (gl is -1 to 1).
	//d3d's framebuffer is upside down or something annoying like that.
	shaderstate.lightshadowmapproj[0] = shadowscale * (1.0-(1.0/texwidth)) * 0.5/3.0;	//pinch x inwards
	shaderstate.lightshadowmapproj[1] = -shadowscale * (1.0-(1.0/texheight)) * 0.5/2.0;	//pinch y inwards
	shaderstate.lightshadowmapproj[2] = 0.5*(dl->radius+nc)/(nc-dl->radius);	//proj matrix 10
	shaderstate.lightshadowmapproj[3] = (dl->radius*nc)/(nc-dl->radius) - bias*nc*(1024/texheight);	//proj matrix 14	

	shaderstate.lightshadowmapscale[0] = 1.0/(SHADOWMAP_SIZE*3);
	shaderstate.lightshadowmapscale[1] = -1.0/(SHADOWMAP_SIZE*2);
}

//FIXME: needs context for threading
void VKBE_BeginShadowmapFace(void)
{
	VkRect2D wrekt;
	VkViewport viewport;

	viewport.x = r_refdef.pxrect.x;
	viewport.y = r_refdef.pxrect.maxheight - (r_refdef.pxrect.y+r_refdef.pxrect.height);	//silly GL...
	viewport.width = r_refdef.pxrect.width;
	viewport.height = r_refdef.pxrect.height;
	viewport.minDepth = 0;
	viewport.maxDepth = 1;
	vkCmdSetViewport(vk.rendertarg->cbuf, 0, 1, &viewport);

	wrekt.offset.x = viewport.x;
	wrekt.offset.y = viewport.y;
	wrekt.extent.width = viewport.width;
	wrekt.extent.height = viewport.height;
	vkCmdSetScissor(vk.rendertarg->cbuf, 0, 1, &wrekt);

	//shadowmaps never multisample...
	shaderstate.modepermutation &= ~(PERMUTATION_BEM_MULTISAMPLE|PERMUTATION_BEM_FP16|PERMUTATION_BEM_VR);
}
#endif

void VKBE_DrawWorld (batch_t **worldbatches)
{
	batch_t *batches[SHADER_SORT_COUNT];
	RSpeedLocals();

	shaderstate.curentity = NULL;

	{
		VkViewport viewport;

		viewport.x = r_refdef.pxrect.x;
		viewport.y = r_refdef.pxrect.y;
		viewport.width = r_refdef.pxrect.width;
		viewport.height = r_refdef.pxrect.height;
		viewport.minDepth = 0;
		viewport.maxDepth = 1;
		vkCmdSetViewport(vk.rendertarg->cbuf, 0, 1, &viewport);
	}

	if (!r_refdef.recurse)
	{
		if (shaderstate.wbatch > shaderstate.maxwbatches)
		{
			int newm = shaderstate.wbatch;
			Z_Free(shaderstate.wbatches);
			shaderstate.wbatches = Z_Malloc(newm * sizeof(*shaderstate.wbatches));
			memset(shaderstate.wbatches + shaderstate.maxwbatches, 0, (newm - shaderstate.maxwbatches) * sizeof(*shaderstate.wbatches));
			shaderstate.maxwbatches = newm;
		}
		shaderstate.wbatch = 0;
	}

	RSpeedRemark();

	shaderstate.curdlight = NULL;
	//fixme: figure out some way to safely orphan this data so that we can throw the rest to a worker.
	BE_GenModelBatches(batches, shaderstate.curdlight, BEM_STANDARD, r_refdef.scenevis, r_refdef.sceneareas);

	BE_UploadLightmaps(false);
	if (r_refdef.scenevis)
	{
		//make sure the world draws correctly
		r_worldentity.shaderRGBAf[0] = 1;
		r_worldentity.shaderRGBAf[1] = 1;
		r_worldentity.shaderRGBAf[2] = 1;
		r_worldentity.shaderRGBAf[3] = 1;
		r_worldentity.axis[0][0] = 1;
		r_worldentity.axis[1][1] = 1;
		r_worldentity.axis[2][2] = 1;

#ifdef RTLIGHTS
		if (r_refdef.scenevis && r_shadow_realtime_world.ival)
			shaderstate.identitylighting = r_shadow_realtime_world_lightmaps.value;
		else
#endif
			shaderstate.identitylighting = r_lightmap_scale.value;
		shaderstate.identitylighting *= r_refdef.hdr_value;
		shaderstate.identitylightmap = shaderstate.identitylighting / (1<<gl_overbright.ival);

		if (r_lightprepass)
		{
			//set up render target for gbuffer
			//draw opaque gbuffers
			//switch render targets to lighting (renderpasses?)
			//draw lpp lights
			//revert to screen
			//draw opaques again.
		}
		else
		{
			VKBE_SelectMode(BEM_STANDARD);

			
			VKBE_SubmitMeshes(worldbatches, batches, SHADER_SORT_PORTAL, SHADER_SORT_SEETHROUGH+1);
			RSpeedEnd(RSPEED_OPAQUE);

#ifdef RTLIGHTS
			RSpeedRemark();
			VKBE_SelectEntity(&r_worldentity);
			Sh_DrawLights(r_refdef.scenevis);
			RSpeedEnd(RSPEED_RTLIGHTS);
#endif
		}

		RSpeedRemark();
		VKBE_SubmitMeshes(worldbatches, batches, SHADER_SORT_SEETHROUGH+1, SHADER_SORT_COUNT);
		RSpeedEnd(RSPEED_TRANSPARENTS);

		if (r_wireframe.ival)
		{
			VKBE_SelectMode(BEM_WIREFRAME);
			VKBE_SubmitMeshes(worldbatches, batches, SHADER_SORT_PORTAL, SHADER_SORT_NEAREST);
			VKBE_SelectMode(BEM_STANDARD);
		}
	}
	else
	{
		shaderstate.identitylighting = 1;
		shaderstate.identitylightmap = 1;
		VKBE_SubmitMeshes(NULL, batches, SHADER_SORT_PORTAL, SHADER_SORT_COUNT);
		RSpeedEnd(RSPEED_TRANSPARENTS);
	}

	R_RenderDlights ();

	shaderstate.identitylighting = 1;
	BE_RotateForEntity(&r_worldentity, NULL);

	if (r_refdef.recurse)
		RQ_RenderBatch();
	else
		RQ_RenderBatchClear();
}

void VKBE_VBO_Begin(vbobctx_t *ctx, size_t maxsize)
{
	struct stagingbuf *n = Z_Malloc(sizeof(*n));
	ctx->vboptr[0] = n;
	ctx->maxsize = maxsize;
	ctx->pos = 0;

	ctx->fallback = VKBE_CreateStagingBuffer(n, maxsize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

	//preallocate the target buffer, so we can prematurely refer to it.
	{
		VkBufferCreateInfo bufinf = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};

		bufinf.flags = 0;
		bufinf.size = n->size;
		bufinf.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT;
		bufinf.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
		bufinf.queueFamilyIndexCount = 0;
		bufinf.pQueueFamilyIndices = NULL;
		vkCreateBuffer(vk.device, &bufinf, vkallocationcb, &n->retbuf);
	}
}
void VKBE_VBO_Data(vbobctx_t *ctx, void *data, size_t size, vboarray_t *varray)
{
	struct stagingbuf *n = ctx->vboptr[0];
	varray->vk.offs = ctx->pos;
	varray->vk.buff = n->retbuf;
	ctx->pos += size;

	memcpy((char*)ctx->fallback + varray->vk.offs, data, size);
}
void VKBE_VBO_Finish(vbobctx_t *ctx, void *edata, size_t esize, vboarray_t *earray, void **vbomem, void **ebomem)
{
	struct stagingbuf *n;
	struct stagingbuf ebo;
	vk_poolmem_t *poolmem;
	index_t *map = VKBE_CreateStagingBuffer(&ebo, esize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
	memcpy(map, edata, esize);
	*ebomem = poolmem = Z_Malloc(sizeof(*poolmem));
	earray->vk.buff = VKBE_FinishStaging(&ebo, poolmem);
	earray->vk.offs = 0;

	if (ctx)
	{
		n = ctx->vboptr[0];
		*vbomem = poolmem = Z_Malloc(sizeof(*poolmem));
		/*buffer was pre-created*/VKBE_FinishStaging(n, poolmem);
		Z_Free(n);
	}
}
void VKBE_VBO_Destroy(vboarray_t *vearray, void *mem)
{
	vk_poolmem_t *poolmem = mem;
	struct fencedbufferwork *fence;
	if (!vearray->vk.buff)
		return;	//not actually allocated...

	fence = VK_AtFrameEnd(VKBE_DoneBufferStaging, NULL, sizeof(*fence));
	fence->buf = vearray->vk.buff;
	fence->mem = *poolmem;

	Z_Free(poolmem);
}

void VKBE_Scissor(srect_t *rect)
{
	VkRect2D wrekt;
	if (rect)
	{
		wrekt.offset.x = rect->x * vid.fbpwidth;
		wrekt.offset.y = (1 - (rect->height + rect->y))*vid.fbpheight;  //our api was made for gl. :(
		wrekt.extent.width = rect->width * vid.fbpwidth;
		wrekt.extent.height = rect->height * vid.fbpheight;

		if (wrekt.offset.x+wrekt.extent.width > vid.fbpwidth)
			wrekt.extent.width = vid.fbpwidth - wrekt.offset.x;
		if (wrekt.offset.y+wrekt.extent.height > vid.fbpheight)
			wrekt.extent.height = vid.fbpheight - wrekt.offset.y;
		if (wrekt.offset.x < 0)
		{
			wrekt.extent.width += wrekt.offset.x;
			wrekt.offset.x = 0;
		}
		if (wrekt.offset.y < 0)
		{
			wrekt.extent.height += wrekt.offset.x;
			wrekt.offset.y = 0;
		}
	}
	else
	{
		wrekt.offset.x = 0;
		wrekt.offset.y = 0;
		wrekt.extent.width = vid.fbpwidth;
		wrekt.extent.height = vid.fbpheight;
	}

	vkCmdSetScissor(vk.rendertarg->cbuf, 0, 1, &wrekt);
}

#endif