cnq3/code/renderer/tr_backend_gl3.cpp

/*
===========================================================================
Copyright (C) 2019 Gian 'myT' Schellenbaum

This file is part of Challenge Quake 3 (CNQ3).

Challenge Quake 3 is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Challenge Quake 3 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Challenge Quake 3. If not, see <https://www.gnu.org/licenses/>.
===========================================================================
*/
// OpenGL 3.2+ rendering back-end

#include "tr_local.h"
#include "GL/glew.h"

#if defined(_WIN32)
#include <Windows.h>
#else
#include <sys/mman.h>
#include <unistd.h>
#endif


/*
Current info:
- OpenGL 3.2 minimum
- GLSL 1.40 minimum
- fancy mip-map generations requires:
	- OpenGL 4.3 (or equivalent extensions)
	- GLSL 4.30

Vertex and index data streaming notes:
- everyone: persistent coherent buffer mapping is the best option whenever available
- nVidia  : unsynchronized mapping is very slow, even without threaded driver optimization
- Intel   : glBufferSubData is painfully slow, even with immutable storage guarantees and full-range updates
- AMD     : if persistent coherent buffer mapping isn't available, AMD_pinned_memory is the best option
- AMD     : if neither persistent coherent buffer mapping nor AMD_pinned_memory, then pick glBufferSubData to be safe
- AMD     : glBufferSubData is slower than unsynchronized mapping with modern drivers
- AMD     : unsynchronized mapping drops off the performance cliff with old drivers

Known issues:
- nVidia GeForce GTX 1070 - Windows 7 - drivers 430.64
	once the GL2 back-end is used, performance crashes when switching to the GL3 back-end
- AMD Radeon HD 6950 - Windows 10 Pro version 10.0.16299 build 16299 - drivers 15.201.1151.1008
	with r_gpuMipGen 1, performance collapses big time (confirmed: whenever glTexStorage2D is called)
- AMD Radeon R7 360 - Windows 7 - drivers 14.502.0.0
	with r_gpuMipGen 1, the GPU-generated mips are corrupted (not confirmed: broken barrier implementation?)
*/


// @NOTE: MAX_VERTEXES and MAX_INDEXES are *per frame*
#define LARGEBUFFER_MAX_FRAMES      4
#define LARGEBUFFER_MAX_VERTEXES    131072
#define LARGEBUFFER_MAX_INDEXES     (LARGEBUFFER_MAX_VERTEXES * 8)

// this is the highest maximum we'll ever report
#define MAX_GPU_TEXTURE_SIZE        2048


enum PipelineId
{
	PID_GENERIC,
	PID_DYNAMIC_LIGHT,
	PID_SOFT_SPRITE,
	PID_POST_PROCESS,
	PID_COUNT
};

enum ErrorMode
{
	EM_FATAL,
	EM_PRINT,
	EM_SILENT
};

enum VertexBufferId
{
	VB_POSITION,
	VB_NORMAL,
	VB_TEXCOORD,
	VB_TEXCOORD2,
	VB_COLOR,
	VB_COUNT
};

enum AlphaTest
{
	AT_ALWAYS,
	AT_GREATER_THAN_0,
	AT_LESS_THAN_HALF,
	AT_GREATER_OR_EQUAL_TO_HALF
};

struct Program
{
	GLuint vertexShader;
	GLuint fragmentShader;
	GLuint computeShader;
	GLuint program;
};

struct ArrayBuffer
{
	GLuint buffer;
	GLint componentCount;
	GLenum dataType;
	GLboolean normalized;
	int capacity;
	int itemSize;
	int writeIndex;
	int readIndex;
	qbool indexBuffer;
	// persistent mapping:
	byte* mappedData;
	int pinnedByteCount; // when using AMD_pinned_memory
	GLsync fences[LARGEBUFFER_MAX_FRAMES]; // NULL means uninitialized / invalid
	int writeRangeIndex;
};

struct PipelineArrayBuffer
{
	const char* attribName;
	qbool enabled;
};

struct FrameBuffer
{
	GLuint fbo;
	GLuint color;			// texture if MS, buffer if SS
	GLuint depthStencil;	// texture if MS, buffer if SS
	qbool multiSampled;
	qbool hasDepthStencil;
	qbool hasColor;
};

enum GenericUniform
{
	GU_MODELVIEW,
	GU_PROJECTION,
	GU_CLIP_PLANE,
	GU_ALPHA_TEX,
	GU_GAMMA_BRIGHT_NOISE_SEED,
	GU_COUNT
};

enum DynamicLightUniform
{
	DU_MODELVIEW,
	DU_PROJECTION,
	DU_CLIP_PLANE,
	DU_LIGHT_POS,
	DU_EYE_POS,
	DU_LIGHT_COLOR_RADIUS,
	DU_OPAQUE,
	DU_INTENSITY,
	DU_COUNT
};

enum SoftSpriteUniform
{
	SU_MODELVIEW,
	SU_PROJECTION,
	SU_CLIP_PLANE,
	SU_ALPHA_TEST,
	SU_PROJ22_32,
	SU_ADD_DIST_OFFSET,
	SU_COUNT
};

enum PostUniform
{
	PU_BRIGHT_GAMMA_GREY,
	PU_COUNT
};

// yes, one could use some template meta-programming horror for this...
#define MAX_UNIFORM_COUNT DU_COUNT
static const char UniformCountLargeEnoughG[(int)MAX_UNIFORM_COUNT >= (int)GU_COUNT ? 1 : -1] = { '\0' };
static const char UniformCountLargeEnoughD[(int)MAX_UNIFORM_COUNT >= (int)DU_COUNT ? 1 : -1] = { '\0' };
static const char UniformCountLargeEnoughS[(int)MAX_UNIFORM_COUNT >= (int)SU_COUNT ? 1 : -1] = { '\0' };
static const char UniformCountLargeEnoughU[(int)MAX_UNIFORM_COUNT >= (int)PU_COUNT ? 1 : -1] = { '\0' };

struct Pipeline
{
	Program program;
	const char* uniformNames[MAX_UNIFORM_COUNT];
	GLint uniformLocations[MAX_UNIFORM_COUNT];
	qbool uniformsDirty[MAX_UNIFORM_COUNT];
	GLint textureLocations[2];
	PipelineArrayBuffer arrayBuffers[VB_COUNT];
};

enum ComputePipelineId
{
	CPID_GAMMA_TO_LINEAR,
	CPID_LINEAR_TO_GAMMA,
	CPID_DOWN_SAMPLE,
	CPID_COUNT
};

struct MipMapGenerator
{
	Program programs[CPID_COUNT];
	GLuint textures[3]; // 0,1=float16 2=uint8
};

enum MappingType
{
	MT_SUBDATA,		// glBufferSubData
	MT_UNSYNC,		// glMapBufferRange with GL_MAP_UNSYNCHRONIZED_BIT
	MT_PERSISTENT,	// glMapBufferRange with GL_MAP_PERSISTENT_BIT and GL_MAP_COHERENT_BIT
	MT_AMDPIN		// glBufferData with GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD
};

struct OpenGL3
{
	char log[8192];

	int maxTextureSize;

	float modelViewMatrix[16];
	float projectionMatrix[16];
	float clipPlane[4];
	qbool enableClipPlane;
	qbool prevEnableClipPlane;
	AlphaTest alphaTest;
	qbool dlOpaque;
	float dlIntensity;

	ArrayBuffer arrayBuffers[VB_COUNT];
	ArrayBuffer indexBuffer;

	GLuint boundTextures[2];
	cullType_t cullType;
	unsigned int srcBlendBits;
	unsigned int dstBlendBits;
	qbool enableDepthTest;
	GLenum depthFunc;
	GLboolean enableDepthWrite;
	GLenum polygonMode;
	qbool enablePolygonOffset;
	texEnv_t texEnv;
	qbool enableAlphaToCoverage;

	FrameBuffer fbMS;
	FrameBuffer fbSSDepth; // resolved depth/stencil from fbMS
	FrameBuffer fbSS[2];
	unsigned int fbReadIndex; // indexes fbSS
	qbool fbMSEnabled;

	Pipeline pipelines[PID_COUNT];
	PipelineId pipelineId;

	MappingType mappingType;

	ErrorMode errorMode;

	MipMapGenerator mipGen;

	GLuint timerQueries[8];
	qbool queryStarted[8];
	int queryWriteIndex;
	int queryReadIndex;
};

static OpenGL3 gl;


static const char* generic_vs =
"uniform mat4 modelView;\n"
"uniform mat4 projection;\n"
"uniform vec4 clipPlane;\n"
"\n"
"in vec4 position;\n"
"in vec2 texCoords1;\n"
"in vec2 texCoords2;\n"
"in vec4 color;\n"
"\n"
"out vec2 texCoords1FS;\n"
"out vec2 texCoords2FS;\n"
"out vec4 colorFS;\n"
"\n"
"void main()\n"
"{\n"
"	vec4 positionVS = modelView * vec4(position.xyz, 1);\n"
"	gl_Position = projection * positionVS;\n"
"	gl_ClipDistance[0] = dot(positionVS, clipPlane);\n"
"	texCoords1FS = texCoords1;\n"
"	texCoords2FS = texCoords2;\n"
"	colorFS = color;\n"
"}\n";

static const char* generic_fs =
"uniform sampler2D texture1;\n"
"uniform sampler2D texture2;\n"
"\n"
"uniform uvec2 alphaTex;\n"
"#define alphaTest alphaTex.x\n"
"#define texEnv alphaTex.y\n"
"#if CNQ3_DITHER\n"
"uniform vec4 gammaBrightNoiseSeed;\n"
"#define invGamma gammaBrightNoiseSeed.x\n"
"#define invBrightness gammaBrightNoiseSeed.y\n"
"#define noiseScale gammaBrightNoiseSeed.z\n"
"#define seed gammaBrightNoiseSeed.w\n"
"#endif\n"
"\n"
"centroid in vec2 texCoords1FS;\n"
"centroid in vec2 texCoords2FS;\n"
"centroid in vec4 colorFS;\n"
"\n"
"out vec4 fragColor;\n"
"\n"
"#if CNQ3_DITHER\n"
"float Hash(vec2 v)\n"
"{\n"
"	// this is from Morgan McGuire's 'Hashed Alpha Testing' paper\n"
"	return fract(1.0e4 * sin(17.0 * v.x + 0.1 * v.y) + (0.1 + abs(sin(13.0 * v.y + v.x))));\n"
"}\n"
"\n"
"float Linearize(float color)\n"
"{\n"
"	return pow(abs(color * invBrightness), invGamma) * sign(color);\n"
"}\n"
"\n"
"vec4 Dither(vec4 color, vec3 position)\n"
"{\n"
"	vec2 newSeed = position.xy + vec2(0.6849, 0.6849) * seed + vec2(position.z, position.z);\n"
"	float noise = (noiseScale / 255.0) * Linearize(Hash(newSeed) - 0.5);\n"
"\n"
"	return color + vec4(noise, noise, noise, 0.0);\n"
"}\n"
"#endif\n"
"\n"
"#if CNQ3_A2C\n"
"float CorrectAlpha(float threshold, float alpha, vec2 tc)\n"
"{\n"
"	vec2 size = vec2(textureSize(texture1, 0));\n"
"	float dx = max(abs(dFdx(tc.x * size.x)), 0.001);\n"
"	float dy = max(abs(dFdy(tc.y * size.y)), 0.001);\n"
"	float dxy = max(dx, dy); // apply the smallest boost\n"
"	float scale = max(1.0 / dxy, 1.0);\n"
"	float ac = threshold + (alpha - threshold) * scale;\n"
"\n"
"	return ac;\n"
"}\n"
"#endif\n"
"\n"
"void main()\n"
"{\n"
"	vec4 p = texture(texture1, texCoords1FS);\n"
"	vec4 s = texture(texture2, texCoords2FS);\n"
"	vec4 r;\n"
"	if(texEnv == uint(1))\n"
"		r = colorFS * s * p;\n"
"	else if(texEnv == uint(2))\n"
"		r = s; // use input.color or not?\n"
"	else if(texEnv == uint(3))\n"
"		r = colorFS * vec4(p.rgb * (1 - s.a) + s.rgb * s.a, p.a);\n"
"	else if(texEnv == uint(4))\n"
"		r = colorFS * vec4(p.rgb + s.rgb, p.a * s.a);\n"
"	else // texEnv == 0\n"
"		r = colorFS * p;\n"
"\n"
"#if CNQ3_DITHER\n"
"	r = Dither(r, gl_FragCoord.xyz);\n"
"#endif\n"
"\n"
"#if CNQ3_A2C\n"
"	if(alphaTest == uint(1))\n"
"		r.a = CorrectAlpha(0.0, r.a, texCoords1FS);\n"
"	if(alphaTest == uint(2))\n"
"		r.a = CorrectAlpha(0.5, 1.0 - r.a, texCoords1FS);\n"
"	else if(alphaTest == uint(3))\n"
"		r.a = CorrectAlpha(0.5, r.a, texCoords1FS);\n"
"#else\n"
"	if(	(alphaTest == uint(1) && r.a == 0.0) ||\n"
"		(alphaTest == uint(2) && r.a >= 0.5) ||\n"
"		(alphaTest == uint(3) && r.a <  0.5))\n"
"		discard;\n"
"#endif\n"
"\n"
"	fragColor = r;\n"
"}\n";

static const char* dl_vs =
"uniform mat4 modelView;\n"
"uniform mat4 projection;\n"
"uniform vec4 clipPlane;\n"
"uniform vec3 osLightPos;\n"
"uniform vec3 osEyePos;\n"
"\n"
"in vec4 position;\n"
"in vec4 normal;\n"
"in vec2 texCoords1;\n"
"\n"
"out vec3 normalFS;\n"
"out vec2 texCoords1FS;\n"
"out vec3 L;\n"
"out vec3 V;\n"
"\n"
"void main()\n"
"{\n"
"	vec4 positionVS = modelView * vec4(position.xyz, 1);\n"
"	gl_Position = projection * positionVS;\n"
"	gl_ClipDistance[0] = dot(positionVS, clipPlane);\n"
"	normalFS = normal.xyz;\n"
"	texCoords1FS = texCoords1;\n"
"	L = osLightPos - position.xyz;\n"
"	V = osEyePos - position.xyz;\n"
"}\n";

static const char* dl_fs =
"uniform sampler2D texture1;\n"
"\n"
"uniform vec4 lightColorRadius;\n"
"uniform float opaque;\n"
"uniform float intensity;\n"
"\n"
"in vec3 normalFS;\n"
"in vec2 texCoords1FS;\n"
"in vec3 L;\n"
"in vec3 V;\n"
"\n"
"out vec4 fragColor;\n"
"\n"
"float BezierEase(float t)\n"
"{\n"
"	return t * t * (3.0 - 2.0 * t);\n"
"}\n"
"\n"
"void main()\n"
"{\n"
"	vec4 base = texture2D(texture1, texCoords1FS);\n"
"	vec3 nL = normalize(L);\n"
"	vec3 nV = normalize(V);\n"
"\n"
"	// light intensity\n"
"	float intensFactor = min(dot(L, L) * lightColorRadius.w, 1.0);\n"
"	vec3 intens = lightColorRadius.rgb * BezierEase(1.0 - sqrt(intensFactor));\n"
"\n"
"	// specular reflection term (N.H)\n"
"	float specFactor = min(abs(dot(normalFS, normalize(nL + nV))), 1.0);\n"
"	float spec = pow(specFactor, 16.0) * 0.25;\n"
"\n"
"	// Lambertian diffuse reflection term (N.L)\n"
"	float diffuse = min(abs(dot(normalFS, nL)), 1.0);\n"
"	vec3 color = (base.rgb * vec3(diffuse) + vec3(spec)) * intens * intensity;\n"
"	float alpha = mix(opaque, 1.0, base.a);\n"
"\n"
"	fragColor = vec4(color.rgb * alpha, alpha);\n"
"}\n";

static const char* sprite_vs =
"uniform mat4 modelView;\n"
"uniform mat4 projection;\n"
"uniform vec4 clipPlane;\n"
"\n"
"in vec4 position;\n"
"in vec2 texCoords1;\n"
"in vec4 color;\n"
"\n"
"out vec2 texCoords1FS;\n"
"out vec4 colorFS;\n"
"out float depthVS;\n"
"\n"
"void main()\n"
"{\n"
"	vec4 positionVS = modelView * vec4(position.xyz, 1);\n"
"	gl_Position = projection * positionVS;\n"
"	gl_ClipDistance[0] = dot(positionVS, clipPlane);\n"
"	texCoords1FS = texCoords1;\n"
"	colorFS = color;\n"
"	depthVS = -positionVS.z;\n"
"}\n";

static const char* sprite_fs =
"uniform sampler2D texture1; // diffuse texture\n"
"uniform sampler2D texture2; // depth texture\n"
"\n"
"uniform uint alphaTest;\n"
"uniform vec2 proj22_32;\n"
"uniform vec3 addDistOffset;\n"
"#define proj22 proj22_32.x\n"
"#define proj32 proj22_32.y\n"
"#define additive addDistOffset.x\n"
"#define distance addDistOffset.y\n"
"#define offset addDistOffset.z\n"
"\n"
"in vec2 texCoords1FS;\n"
"in vec4 colorFS;\n"
"in float depthVS;\n"
"\n"
"out vec4 fragColor;\n"
"\n"
"float LinearDepth(float zwDepth)\n"
"{\n"
"	return proj32 / (zwDepth - proj22);\n"
"}\n"
"\n"
"float Contrast(float d, float power)\n"
"{\n"
"	bool aboveHalf = d > 0.5;\n"
"	float base = clamp(2.0 * (aboveHalf ? (1.0 - d) : d), 0.0, 1.0);\n"
"	float r = 0.5 * pow(base, power);\n"
"\n"
"	return aboveHalf ? (1.0 - r) : r;\n"
"}\n"
"\n"
"void main()\n"
"{\n"
"	vec4 r = colorFS * texture(texture1, texCoords1FS);\n"
"	if(	(alphaTest == uint(1) && r.a == 0.0) ||\n"
"		(alphaTest == uint(2) && r.a >= 0.5) ||\n"
"		(alphaTest == uint(3) && r.a <  0.5))\n"
"		discard;\n"
"\n"
"	float depthSRaw = texelFetch(texture2, ivec2(gl_FragCoord.xy), 0).r;\n"
"	float depthS = LinearDepth(depthSRaw * 2.0 - 1.0);\n"
"	float depthP = depthVS - offset * 0.5;\n"
"	float scale = Contrast((depthS - depthP) * distance, 2.0);\n"
"	float scaleColor = max(scale, 1.0 - additive);\n"
"	float scaleAlpha = max(scale, additive);\n"
"	vec4 r2 = vec4(r.rgb * scaleColor, r.a * scaleAlpha);\n"
"	fragColor = r2;\n"
"}\n";

static const char* post_vs =
"out vec2 texCoords1FS;\n"
"\n"
"void main()\n"
"{\n"
"	gl_Position = vec4(\n"
"		float(gl_VertexID / 2) * 4.0 - 1.0,\n"
"		float(gl_VertexID % 2) * 4.0 - 1.0,\n"
"		0.0,\n"
"		1.0);\n"
"	texCoords1FS = vec2(\n"
"		float(gl_VertexID / 2) * 2.0,\n"
"		float(gl_VertexID % 2) * 2.0);\n"
"}\n";

static const char* post_fs =
"uniform sampler2D texture1;\n"
"\n"
"uniform vec3 brightGammaGrey;\n"
"#define brightness brightGammaGrey.x\n"
"#define gamma brightGammaGrey.y\n"
"#define greyscale brightGammaGrey.z\n"
"\n"
"in vec2 texCoords1FS;\n"
"\n"
"out vec4 fragColor;\n"
"\n"
"void main()\n"
"{\n"
"	vec3 base = texture(texture1, texCoords1FS).rgb;\n"
"	vec3 gc = pow(base, vec3(gamma)) * brightness;\n"
"	float grey = 0.299 * gc.r + 0.587 * gc.g + 0.114 * gc.b;\n"
"	vec3 result = mix(gc, vec3(grey, grey, grey), greyscale);\n"
"	fragColor = vec4(result.rgb, 1.0);\n"
"}\n";

static const char* gammaToLinear_cs =
"layout (binding = 0, rgba8)   readonly  uniform image2D srcTex;\n"
"layout (binding = 1, rgba16f) writeonly uniform image2D dstTex;\n"
"\n"
"layout (location = 0) uniform float gamma;\n"
"\n"
"layout (local_size_x = 8, local_size_y = 8) in;\n"
"\n"
"void main()\n"
"{\n"
"	ivec2 coords = ivec2(gl_GlobalInvocationID);\n"
"	vec4 inV = imageLoad(srcTex, coords);\n"
"	vec4 outV = vec4(pow(inV.x, gamma), pow(inV.y, gamma), pow(inV.z, gamma), inV.a);\n"
"	imageStore(dstTex, coords, outV);\n"
"}\n";

static const char* linearToGamma_cs =
// yes, intensity *should* be done in light-linear space
// but we keep the old behavior for consistency...
"layout (binding = 0, rgba16f) readonly  uniform image2D srcTex;\n"
"layout (binding = 1, rgba8)   writeonly uniform image2D dstTex;\n"
"\n"
"layout (location = 0) uniform float intensity;\n"
"layout (location = 1) uniform vec4  blendColor;\n"
"layout (location = 2) uniform float invGamma;\n"
"\n"
"layout (local_size_x = 8, local_size_y = 8) in;\n"
"\n"
"void main()\n"
"{\n"
"	ivec2 coords = ivec2(gl_GlobalInvocationID);\n"
"	vec4 in0 = imageLoad(srcTex, coords);\n"
"	vec3 in1 = 0.5 * (in0.rgb + blendColor.rgb);\n"
"	vec3 inV = mix(in0.rgb, in1.rgb, blendColor.a);\n"
"	vec3 out0 = vec3(pow(inV.r, invGamma), pow(inV.g, invGamma), pow(inV.b, invGamma));\n"
"	vec3 out1 = out0 * intensity;\n"
"	vec4 outV = vec4(out1, in0.a);\n"
"	imageStore(dstTex, coords, outV);\n"
"}\n";

static const char* downSample_cs =
"layout (binding = 0, rgba16f) readonly  uniform image2D srcTex;\n"
"layout (binding = 1, rgba16f) writeonly uniform image2D dstTex;\n"
"\n"
"layout (location = 0) uniform vec4  weights;\n"
"layout (location = 1) uniform ivec2 maxSize;\n"
"layout (location = 2) uniform ivec2 scale;\n"
"layout (location = 3) uniform ivec2 offset;\n"
"layout (location = 4) uniform uint  clampMode; // 0 = repeat\n"
"\n"
"layout (local_size_x = 8, local_size_y = 8) in;\n"
"\n"
"ivec2 FixCoords(ivec2 c)\n"
"{\n"
	"if(clampMode > 0)\n"
"	{\n"
"		// clamp\n"
"		return clamp(c, ivec2(0, 0), maxSize);\n"
"	}\n"
"\n"
"	// repeat\n"
"	return c & maxSize;\n"
"}\n"
"\n"
"void main()\n"
"{\n"
	"ivec2 dstTC = ivec2(gl_GlobalInvocationID);\n"
"	ivec2 base  = ivec2(gl_GlobalInvocationID) * scale;\n"
"	vec4 r = vec4(0, 0, 0, 0);\n"
"	r += imageLoad(srcTex, FixCoords(base - offset * 3)) * weights.x;\n"
"	r += imageLoad(srcTex, FixCoords(base - offset * 2)) * weights.y;\n"
"	r += imageLoad(srcTex, FixCoords(base - offset    )) * weights.z;\n"
"	r += imageLoad(srcTex,           base              ) * weights.w;\n"
"	r += imageLoad(srcTex,           base + offset     ) * weights.w;\n"
"	r += imageLoad(srcTex, FixCoords(base + offset * 2)) * weights.z;\n"
"	r += imageLoad(srcTex, FixCoords(base + offset * 3)) * weights.y;\n"
"	r += imageLoad(srcTex, FixCoords(base + offset * 4)) * weights.x;\n"
"	imageStore(dstTex, dstTC, r);\n"
"}\n";


void GL_GetRenderTargetFormat(GLenum* internalFormat, GLenum* format, GLenum* type, int cnq3Format)
{
	switch(cnq3Format)
	{
		case RTCF_R10G10B10A2:
			*internalFormat = GL_RGB10_A2;
			*format = GL_BGRA;
			*type = GL_UNSIGNED_INT_2_10_10_10_REV;
			break;

		case RTCF_R16G16B16A16:
			*internalFormat = GL_RGBA16;
			*format = GL_BGRA;
			*type = GL_UNSIGNED_SHORT;
			break;

		case RTCF_R8G8B8A8:
		default:
			*internalFormat = GL_RGBA8;
			*format = GL_BGRA;
			*type = GL_UNSIGNED_BYTE;
			break;
	}
}

void GL_CreateColorRenderBufferStorageMS(int* samples)
{
	GLenum internalFormat, format, type;
	GL_GetRenderTargetFormat(&internalFormat, &format, &type, r_rtColorFormat->integer);

	int sampleCount = r_msaa->integer;
	while(glGetError() != GL_NO_ERROR) {} // clear the error queue

	if(GLEW_VERSION_4_2 || GLEW_ARB_internalformat_query)
	{
		GLint maxSampleCount = 0;
		glGetInternalformativ(GL_RENDERBUFFER, internalFormat, GL_SAMPLES, 1, &maxSampleCount);
		if(glGetError() == GL_NO_ERROR)
		{
			sampleCount = min(sampleCount, (int)maxSampleCount);
		}
	}

	GLenum errorCode = GL_NO_ERROR;
	for(;;)
	{
		// @NOTE: when the sample count is invalid, the error code is GL_INVALID_OPERATION
		glRenderbufferStorageMultisample(GL_RENDERBUFFER, sampleCount, internalFormat, glConfig.vidWidth, glConfig.vidHeight);
		errorCode = glGetError();
		if(errorCode == GL_NO_ERROR || sampleCount == 0)
		{
			break;
		}

		--sampleCount;
	}

	if(errorCode != GL_NO_ERROR)
	{
		ri.Error(ERR_FATAL, "Failed to create multi-sampled render buffer storage (error 0x%X)\n", (unsigned int)errorCode);
	}

	*samples = sampleCount;
}

#if defined(_WIN32)

static void AllocatePinnedMemory(ArrayBuffer* buffer)
{
	const int byteCount = PAD(buffer->capacity * buffer->itemSize, 4096);
	buffer->mappedData = (byte*)VirtualAlloc(NULL, byteCount, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
	buffer->pinnedByteCount = byteCount;
}

static void FreePinnedMemory(ArrayBuffer* buffer)
{
	VirtualFree(buffer->mappedData, 0, MEM_RELEASE);
	buffer->mappedData = NULL;
	buffer->pinnedByteCount = 0;
}

#else

static void AllocatePinnedMemory(ArrayBuffer* buffer)
{
	const int pageSizeSC = (int)sysconf(_SC_PAGE_SIZE);
	const int pageSize = pageSizeSC > 0 ? pageSizeSC : 4096;
	const int byteCount = PAD(buffer->capacity * buffer->itemSize, pageSize);
	buffer->mappedData = (byte*)mmap(NULL, byteCount, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	buffer->pinnedByteCount = byteCount;
}

static void FreePinnedMemory(ArrayBuffer* buffer)
{
	munmap(buffer->mappedData, buffer->pinnedByteCount);
	buffer->mappedData = NULL;
	buffer->pinnedByteCount = 0;
}

#endif

static void HandleError(const char* message)
{
	if(gl.errorMode == EM_FATAL)
	{
		ri.Error(ERR_FATAL, message);
	}
	else if(gl.errorMode == EM_PRINT)
	{
		ri.Printf(PRINT_ERROR, message);
	}
}

// identifier must be one of:
// GL_BUFFER, GL_SHADER, GL_PROGRAM, GL_VERTEX_ARRAY, GL_QUERY, GL_SAMPLER, GL_TEXTURE,
// GL_RENDERBUFFER, GL_FRAMEBUFFER, GL_PROGRAM_PIPELINE, GL_TRANSFORM_FEEDBACK
static void SetDebugName(GLenum identifier, GLuint name, const char* string)
{
	if(GLEW_VERSION_4_3 || GLEW_KHR_debug)
	{
		glObjectLabel(identifier, name, -1, string);
	}
}

static const char* GetShaderTypeName(GLenum shaderType)
{
	switch(shaderType)
	{
		case GL_VERTEX_SHADER: return "vertex";
		case GL_FRAGMENT_SHADER: return "fragment";
		case GL_COMPUTE_SHADER: return "compute";
		default: return "???";
	}
}

static qbool CreateShader(GLuint* shaderPtr, PipelineId pipelineId, GLenum shaderType, const char* shaderSource, const char* debugName)
{
	const char* sourceArray[] =
	{
		shaderType == GL_COMPUTE_SHADER ? "#version 430\n" : "#version 140\n",
		"\n",
		pipelineId == PID_GENERIC && glInfo.alphaToCoverageSupport && shaderType == GL_FRAGMENT_SHADER ? "#define CNQ3_A2C 1\n" : "#define CNQ3_A2C 0\n",
		pipelineId == PID_GENERIC && r_dither->integer && shaderType == GL_FRAGMENT_SHADER ? "#define CNQ3_DITHER 1\n" : "#define CNQ3_DITHER 0\n",
		shaderSource
	};

	GLuint shader = glCreateShader(shaderType);
	glShaderSource(shader, ARRAY_LEN(sourceArray), sourceArray, NULL);
	glCompileShader(shader);

	GLint result = GL_FALSE;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
	if(result == GL_TRUE)
	{
		*shaderPtr = shader;
		SetDebugName(GL_SHADER, shader, va("%s %s shader", debugName, GetShaderTypeName(shaderType)));
		return qtrue;
	}

	GLint logLength = 0;
	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);

	glGetShaderInfoLog(shader, sizeof(gl.log), NULL, gl.log);
	HandleError(va("'%s' %s shader compilation failed: %s\n", debugName, GetShaderTypeName(shaderType), gl.log));

	return qfalse;
}

static qbool CreateGraphicsProgram(PipelineId pipelineId, const char* vs, const char* fs, const char* debugName)
{
	Pipeline* const pipeline = &gl.pipelines[pipelineId];
	Program* const prog = &pipeline->program;
	if(!CreateShader(&prog->vertexShader, pipelineId, GL_VERTEX_SHADER, vs, debugName) ||
	   !CreateShader(&prog->fragmentShader, pipelineId, GL_FRAGMENT_SHADER, fs, debugName))
	{
		return qfalse;
	}

	prog->program = glCreateProgram();
	glAttachShader(prog->program, prog->vertexShader);
	glAttachShader(prog->program, prog->fragmentShader);

	// glBindAttribLocation must be called before the program gets linked
	for(int i = 0; i < VB_COUNT; ++i)
	{
		if(pipeline->arrayBuffers[i].enabled)
		{
			glBindAttribLocation(pipeline->program.program, i, pipeline->arrayBuffers[i].attribName);
		}
	}

	glLinkProgram(prog->program);

	GLint result = GL_FALSE;
	glGetProgramiv(prog->program, GL_LINK_STATUS, &result);
	if(result == GL_TRUE)
	{
		SetDebugName(GL_PROGRAM, prog->program, va("%s program", debugName));
		return qtrue;
	}

	GLint logLength = 0;
	glGetProgramiv(prog->program, GL_INFO_LOG_LENGTH, &logLength);

	glGetProgramInfoLog(prog->program, sizeof(gl.log), NULL, gl.log);
	HandleError(va("'%s' program link failed: %s\n", debugName, gl.log));

	return qfalse;
}

static qbool CreateComputeProgram(Program* prog, const char* cs, const char* debugName)
{
	if(!CreateShader(&prog->computeShader, PID_COUNT, GL_COMPUTE_SHADER, cs, debugName))
	{
		return qfalse;
	}

	prog->program = glCreateProgram();
	glAttachShader(prog->program, prog->computeShader);
	glLinkProgram(prog->program);

	GLint result = GL_FALSE;
	glGetProgramiv(prog->program, GL_LINK_STATUS, &result);
	if(result == GL_TRUE)
	{
		SetDebugName(GL_PROGRAM, prog->program, va("%s program", debugName));
		return qtrue;
	}

	GLint logLength = 0;
	glGetProgramiv(prog->program, GL_INFO_LOG_LENGTH, &logLength);

	glGetProgramInfoLog(prog->program, sizeof(gl.log), NULL, gl.log);
	HandleError(va("'%s' program link failed: %s\n", debugName, gl.log));

	return qfalse;
}

extern void GL_GetRenderTargetFormat(GLenum* internalFormat, GLenum* format, GLenum* type, int cnq3Format);

static void FBO_CreateSS(FrameBuffer* fb, qbool color, qbool depthStencil, const char* name)
{
	if(depthStencil)
	{
		glGenTextures(1, &fb->depthStencil);
		glBindTexture(GL_TEXTURE_2D, fb->depthStencil);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, glConfig.vidWidth, glConfig.vidHeight, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, NULL);
		SetDebugName(GL_TEXTURE, fb->depthStencil, va("%s depth/stencil attachment", name));
	}

	if(color)
	{
		GLenum internalFormat, format, type;
		GL_GetRenderTargetFormat(&internalFormat, &format, &type, r_rtColorFormat->integer);
		glGenTextures(1, &fb->color);
		glBindTexture(GL_TEXTURE_2D, fb->color);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, glConfig.vidWidth, glConfig.vidHeight, 0, format, type, NULL);
		SetDebugName(GL_TEXTURE, fb->color, va("%s color attachment 0", name));
	}
	
	glGenFramebuffers(1, &fb->fbo);
	glBindFramebuffer(GL_FRAMEBUFFER, fb->fbo);
	if(color)
	{
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fb->color, 0);
	}
	if(depthStencil)
	{
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, fb->depthStencil, 0);
	}	

	const GLenum fboStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
	if(fboStatus != GL_FRAMEBUFFER_COMPLETE)
	{
		ri.Error(ERR_FATAL, "Failed to create FBO (status 0x%X, error 0x%X)\n", (unsigned int)fboStatus, (unsigned int)glGetError());
	}

	SetDebugName(GL_FRAMEBUFFER, fb->fbo, va("%s frame buffer", name));

	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	fb->multiSampled = qfalse;
	fb->hasDepthStencil = depthStencil;
	fb->hasColor = color;
}

static void FBO_CreateMS(int* sampleCount, FrameBuffer* fb, const char* name)
{
	glGenFramebuffers(1, &fb->fbo);
	glBindFramebuffer(GL_FRAMEBUFFER, fb->fbo);

	glGenRenderbuffers(1, &fb->color);
	glBindRenderbuffer(GL_RENDERBUFFER, fb->color);
	GL_CreateColorRenderBufferStorageMS(sampleCount);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, fb->color);
	SetDebugName(GL_RENDERBUFFER, fb->color, va("%s color attachment 0", name));

	glGenRenderbuffers(1, &fb->depthStencil);
	glBindRenderbuffer(GL_RENDERBUFFER, fb->depthStencil);
	glRenderbufferStorageMultisample(GL_RENDERBUFFER, *sampleCount, GL_DEPTH24_STENCIL8, glConfig.vidWidth, glConfig.vidHeight);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fb->depthStencil);
	SetDebugName(GL_RENDERBUFFER, fb->depthStencil, va("%s depth/stencil attachment", name));

	const GLenum fboStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
	if(fboStatus != GL_FRAMEBUFFER_COMPLETE)
	{
		ri.Error(ERR_FATAL, "Failed to create FBO (status 0x%X, error 0x%X)\n", (unsigned int)fboStatus, (unsigned int)glGetError());
	}

	SetDebugName(GL_FRAMEBUFFER, fb->fbo, va("%s frame buffer", name));

	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	fb->multiSampled = qtrue;
	fb->hasDepthStencil = qtrue;
	fb->hasColor = qtrue;
}

static void FBO_Init()
{
	gl.fbMSEnabled = r_msaa->integer >= 2 && r_colorMipLevels->integer == 0;
	int finalSampleCount = 1;

	if(gl.fbMSEnabled)
	{
		FBO_CreateMS(&finalSampleCount, &gl.fbMS, "main");
		FBO_CreateSS(&gl.fbSSDepth, qfalse, qtrue, "depth resolve");
		FBO_CreateSS(&gl.fbSS[0], qtrue, qfalse, "post-process #1");
		FBO_CreateSS(&gl.fbSS[1], qtrue, qfalse, "post-process #2");
	}
	else
	{
		FBO_CreateSS(&gl.fbSS[0], qtrue, qtrue, "post-process #1");
		FBO_CreateSS(&gl.fbSS[1], qtrue, qtrue, "post-process #2");
	}

	ri.Printf(PRINT_ALL, "MSAA: %d samples requested, %d selected\n", r_msaa->integer, finalSampleCount);
}

static void FBO_Bind(const FrameBuffer* fb)
{
	glBindFramebuffer(GL_FRAMEBUFFER, fb->fbo);
	glReadBuffer(GL_COLOR_ATTACHMENT0);
	glDrawBuffer(GL_COLOR_ATTACHMENT0);
}

static void FBO_Bind()
{
	if(gl.fbMSEnabled)
	{
		FBO_Bind(&gl.fbMS);
	}
	else
	{
		FBO_Bind(&gl.fbSS[gl.fbReadIndex]);
	}
}

static void FBO_BlitToBackBuffer()
{
	// fixing up the blit mode here to avoid unnecessary glClear calls
	int blitMode = r_blitMode->integer;
	if(r_mode->integer != VIDEOMODE_UPSCALE)
	{
		blitMode = BLITMODE_STRETCHED;
	}

	if(blitMode != BLITMODE_STRETCHED)
	{
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
		glClear(GL_COLOR_BUFFER_BIT);
	}

	const FrameBuffer& fbo = gl.fbSS[gl.fbReadIndex];
	glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo.fbo);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
	glReadBuffer(GL_COLOR_ATTACHMENT0);
	glDrawBuffer(GL_BACK);

	const int sw = glConfig.vidWidth;
	const int sh = glConfig.vidHeight;
	const int dw = glInfo.winWidth;
	const int dh = glInfo.winHeight;
	if(blitMode == BLITMODE_STRETCHED)
	{
		glBlitFramebuffer(0, 0, sw, sh, 0, 0, dw, dh, GL_COLOR_BUFFER_BIT, GL_LINEAR);
	}
	else if(blitMode == BLITMODE_CENTERED)
	{
		const int dx = (dw - sw) / 2;
		const int dy = (dh - sh) / 2;
		glBlitFramebuffer(0, 0, sw, sh, dx, dy, dx + sw, dy + sh, GL_COLOR_BUFFER_BIT, GL_LINEAR);
	}
	else // blitMode == BLITMODE_ASPECT
	{
		const float rx = (float)dw / (float)sw;
		const float ry = (float)dh / (float)sh;
		const float ar = min(rx, ry);
		const int w = (int)(sw * ar);
		const int h = (int)(sh * ar);
		const int x = (dw - w) / 2;
		const int y = (dh - h) / 2;
		glBlitFramebuffer(0, 0, sw, sh, x, y, x + w, y + h, GL_COLOR_BUFFER_BIT, GL_LINEAR);
	}
}

static void FBO_ResolveColor()
{
	const FrameBuffer& r = gl.fbMS;
	const FrameBuffer& d = gl.fbSS[gl.fbReadIndex];
	glBindFramebuffer(GL_READ_FRAMEBUFFER, r.fbo);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, d.fbo);
	glReadBuffer(GL_COLOR_ATTACHMENT0);
	glDrawBuffer(GL_COLOR_ATTACHMENT0);

	const int w = glConfig.vidWidth;
	const int h = glConfig.vidHeight;
	glBlitFramebuffer(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_LINEAR);
}

static void FBO_ResolveDepth()
{
	const FrameBuffer& r = gl.fbMS;
	const FrameBuffer& d = gl.fbSSDepth;
	glBindFramebuffer(GL_READ_FRAMEBUFFER, r.fbo);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, d.fbo);

	const int w = glConfig.vidWidth;
	const int h = glConfig.vidHeight;
	glBlitFramebuffer(0, 0, w, h, 0, 0, w, h, GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_NEAREST);
}

static void ApplyPipeline(PipelineId pipelineId)
{
	if(pipelineId == gl.pipelineId)
	{
		return;
	}

	gl.pipelineId = pipelineId;

	Pipeline* const pipeline = &gl.pipelines[pipelineId];
	glUseProgram(pipeline->program.program);

	for(int i = 0; i < VB_COUNT; ++i)
	{
		if(pipeline->arrayBuffers[i].enabled)
		{
			ArrayBuffer* const buffer = &gl.arrayBuffers[i];
			glEnableVertexAttribArray(i);
			glBindBuffer(GL_ARRAY_BUFFER, buffer->buffer);
			glVertexAttribPointer(i, buffer->componentCount, buffer->dataType, buffer->normalized, buffer->itemSize, (const void*)0);
		}
		else
		{
			glDisableVertexAttribArray(i);
		}
	}

	if(pipelineId == PID_SOFT_SPRITE && gl.fbMSEnabled)
	{
		FBO_ResolveDepth();
		FBO_Bind();
	}

	glUniform1i(pipeline->textureLocations[0], 0);
	glActiveTexture(GL_TEXTURE1);
	glUniform1i(pipeline->textureLocations[1], 1);
	glActiveTexture(GL_TEXTURE0);

	memset(pipeline->uniformsDirty, 0xFF, sizeof(pipeline->uniformsDirty));
}

static GLint GetTextureWrapMode(textureWrap_t w)
{
	switch(w)
	{
		case TW_REPEAT: return GL_REPEAT;
		case TW_CLAMP_TO_EDGE: return GL_CLAMP_TO_EDGE;
		default: return GL_REPEAT;
	}
}

static GLint GetTextureInternalFormat(textureFormat_t f)
{
	switch(f)
	{
		case TF_RGBA8:
		default: return GL_RGBA8;
	}
}

static GLenum GetTextureFormat(textureFormat_t f)
{
	switch(f)
	{
		case TF_RGBA8:
		default: return GL_RGBA;
	}
}

static void BindTexture(int slot, GLuint texture)
{
	if(texture == gl.boundTextures[slot])
	{
		return;
	}

	glBindTexture(GL_TEXTURE_2D, texture);
	gl.boundTextures[slot] = texture;
}

static void BindImage(int slot, const image_t* image)
{
	const GLuint texture = (GLuint)image->texnum;
	BindTexture(slot, texture);
}

static void UpdateAnimatedImage(image_t* image, int w, int h, const byte* data, qbool dirty)
{
	glBindTexture(GL_TEXTURE_2D, (GLuint)image->texnum);
	if(w != image->width || h != image->height)
	{
		// if the scratchImage isn't in the format we want, specify it as a new texture
		image->width = w;
		image->height = h;
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	}
	else if(dirty)
	{
		// otherwise, just update it
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
	}
}

static const image_t* GetBundleImage(const textureBundle_t* bundle)
{
	return R_UpdateAndGetBundleImage(bundle, &UpdateAnimatedImage);
}

static void BindBundle(int slot, const textureBundle_t* bundle)
{
	BindImage(slot, GetBundleImage(bundle));
}

static void ApplyViewportAndScissor(int x, int y, int w, int h)
{
	glViewport(x, y, w, h);
	glScissor(x, y, w, h);
}

static GLenum GetSourceBlend(unsigned int bits)
{
	switch(bits)
	{
		case GLS_SRCBLEND_ZERO: return GL_ZERO;
		case GLS_SRCBLEND_ONE: return GL_ONE;
		case GLS_SRCBLEND_DST_COLOR: return GL_DST_COLOR;
		case GLS_SRCBLEND_ONE_MINUS_DST_COLOR: return GL_ONE_MINUS_DST_COLOR;
		case GLS_SRCBLEND_SRC_ALPHA: return GL_SRC_ALPHA;
		case GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA: return GL_ONE_MINUS_SRC_ALPHA;
		case GLS_SRCBLEND_DST_ALPHA: return GL_DST_ALPHA;
		case GLS_SRCBLEND_ONE_MINUS_DST_ALPHA: return GL_ONE_MINUS_DST_ALPHA;
		case GLS_SRCBLEND_ALPHA_SATURATE: return GL_SRC_ALPHA_SATURATE;
		default: return GL_ONE;
	}
}

static GLenum GetDestinationBlend(unsigned int bits)
{
	switch(bits)
	{
		case GLS_DSTBLEND_ZERO: return GL_ZERO;
		case GLS_DSTBLEND_ONE: return GL_ONE;
		case GLS_DSTBLEND_SRC_COLOR: return GL_SRC_COLOR;
		case GLS_DSTBLEND_ONE_MINUS_SRC_COLOR: return GL_ONE_MINUS_SRC_COLOR;
		case GLS_DSTBLEND_SRC_ALPHA: return GL_SRC_ALPHA;
		case GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA: return GL_ONE_MINUS_SRC_ALPHA;
		case GLS_DSTBLEND_DST_ALPHA: return GL_DST_ALPHA;
		case GLS_DSTBLEND_ONE_MINUS_DST_ALPHA: return GL_ONE_MINUS_DST_ALPHA;
		default: return GL_ONE;
	}
}

static AlphaTest GetAlphaTest(unsigned int bits)
{
	switch(bits)
	{
		case 0: return AT_ALWAYS;
		case GLS_ATEST_GT_0: return AT_GREATER_THAN_0;
		case GLS_ATEST_LT_80: return AT_LESS_THAN_HALF;
		case GLS_ATEST_GE_80: return AT_GREATER_OR_EQUAL_TO_HALF;
		default: return AT_ALWAYS;
	}
}

static void ApplyCullType(cullType_t cullType)
{
	if(cullType == gl.cullType)
	{
		return;
	}

	gl.cullType = cullType;
	if(cullType == CT_TWO_SIDED)
	{
		glDisable(GL_CULL_FACE);
	}
	else
	{
		glEnable(GL_CULL_FACE);
		glCullFace(cullType == CT_FRONT_SIDED ? GL_FRONT : GL_BACK);
	}
}

static void ApplyBlendFunc(unsigned int srcBlendBits, unsigned int dstBlendBits)
{
	if(srcBlendBits == gl.srcBlendBits && dstBlendBits == gl.dstBlendBits)
	{
		return;
	}

	if((srcBlendBits | dstBlendBits) == 0 &&
	   (gl.srcBlendBits | gl.dstBlendBits) == 0)
	{
		return;
	}

	gl.srcBlendBits = srcBlendBits;
	gl.dstBlendBits = dstBlendBits;
	if((srcBlendBits | dstBlendBits) == 0)
	{
		glDisable(GL_BLEND);
	}
	else
	{
		glEnable(GL_BLEND);
		glBlendFunc(GetSourceBlend(srcBlendBits), GetDestinationBlend(dstBlendBits));
	}
}

static void ApplyDepthTest(qbool enableDepthTest)
{
	if(enableDepthTest == gl.enableDepthTest)
	{
		return;
	}

	gl.enableDepthTest = enableDepthTest;
	if(enableDepthTest)
	{
		glEnable(GL_DEPTH_TEST);
	}
	else
	{
		glDisable(GL_DEPTH_TEST);
	}
}

static void ApplyDepthFunc(GLenum depthFunc)
{
	if(depthFunc == gl.depthFunc)
	{
		return;
	}

	gl.depthFunc = depthFunc;
	glDepthFunc(depthFunc);
}

static void ApplyDepthMask(GLboolean enableDepthWrite)
{
	if(enableDepthWrite == gl.enableDepthWrite)
	{
		return;
	}

	gl.enableDepthWrite = enableDepthWrite;
	glDepthMask(enableDepthWrite ? GL_TRUE : GL_FALSE);
}

static void ApplyPolygonMode(GLenum polygonMode)
{
	if(polygonMode == gl.polygonMode)
	{
		return;
	}

	gl.polygonMode = polygonMode;
	glPolygonMode(GL_FRONT_AND_BACK, polygonMode);
}

static void ApplyPolygonOffset(qbool enablePolygonOffset)
{
	if(enablePolygonOffset == gl.enablePolygonOffset)
	{
		return;
	}

	gl.enablePolygonOffset = enablePolygonOffset;
	if(enablePolygonOffset)
	{
		glEnable(GL_POLYGON_OFFSET_FILL);
	}
	else
	{
		glDisable(GL_POLYGON_OFFSET_FILL);
	}
}

static void ApplyClipPlane(qbool enableClipPlane)
{
	if(enableClipPlane == gl.enableClipPlane)
	{
		return;
	}

	gl.enableClipPlane = enableClipPlane;
	if(enableClipPlane)
	{
		glEnable(GL_CLIP_DISTANCE0);
	}
	else
	{
		glDisable(GL_CLIP_DISTANCE0);
	}
}

static void ApplyAlphaTest(AlphaTest alphaTest)
{
	const qbool enableA2C = glInfo.alphaToCoverageSupport && gl.pipelineId == PID_GENERIC && alphaTest != AT_ALWAYS;
	if(enableA2C != gl.enableAlphaToCoverage)
	{
		gl.enableAlphaToCoverage = enableA2C;
		if(enableA2C)
		{
			glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
		}
		else
		{
			glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
		}
	}

	if(alphaTest == gl.alphaTest)
	{
		return;
	}
	gl.alphaTest = alphaTest;

	if(gl.pipelineId == PID_GENERIC)
	{
		gl.pipelines[PID_GENERIC].uniformsDirty[GU_ALPHA_TEX] = qtrue;
	}
	else if(gl.pipelineId == PID_SOFT_SPRITE)
	{
		gl.pipelines[PID_SOFT_SPRITE].uniformsDirty[SU_ALPHA_TEST] = qtrue;
	}
}

static void ApplyState(unsigned int stateBits, cullType_t cullType, qbool polygonOffset)
{
	// fix up the cull mode for mirrors
	if(backEnd.viewParms.isMirror)
	{
		if(cullType == CT_BACK_SIDED)
		{
			cullType = CT_FRONT_SIDED;
		}
		else if(cullType == CT_FRONT_SIDED)
		{
			cullType = CT_BACK_SIDED;
		}
	}
	ApplyCullType(cullType);

	const unsigned int srcBlendBits = stateBits & GLS_SRCBLEND_BITS;
	const unsigned int dstBlendBits = stateBits & GLS_DSTBLEND_BITS;
	ApplyBlendFunc(srcBlendBits, dstBlendBits);

	const qbool disableDepthTest = ((stateBits & GLS_DEPTHTEST_DISABLE) != 0) || backEnd.projection2D;
	ApplyDepthTest(!disableDepthTest);

	const qbool depthFuncEqual = (stateBits & GLS_DEPTHFUNC_EQUAL) != 0;
	ApplyDepthFunc(depthFuncEqual ? GL_EQUAL : GL_LEQUAL);

	const qbool enableDepthWrite = (stateBits & GLS_DEPTHMASK_TRUE) != 0 && gl.pipelineId != PID_SOFT_SPRITE;
	ApplyDepthMask(enableDepthWrite ? GL_TRUE : GL_FALSE);

	const qbool wireFrame = (stateBits & GLS_POLYMODE_LINE) ? 1 : 0;
	ApplyPolygonMode(wireFrame ? GL_LINE : GL_FILL);

	ApplyPolygonOffset(polygonOffset);

	ApplyAlphaTest(GetAlphaTest(stateBits & GLS_ATEST_BITS));
}

static void ApplyTexEnv(texEnv_t texEnv)
{
	if(gl.pipelineId == PID_GENERIC && texEnv != gl.texEnv)
	{
		gl.pipelines[PID_GENERIC].uniformsDirty[GU_ALPHA_TEX] = qtrue;
	}
	gl.texEnv = texEnv;
}

static void BindVertexArray(VertexBufferId)
{
}

static void Buffer_WaitForRange(ArrayBuffer* buffer)
{
	buffer->writeIndex = buffer->writeRangeIndex * (buffer->capacity / LARGEBUFFER_MAX_FRAMES);

	GLsync& fence = buffer->fences[buffer->writeRangeIndex];
	if(fence == NULL)
	{
		return;
	}

	GLbitfield waitFlags = 0;
	GLuint64 waitDurationNS = 0;
	for(;;)
	{
		GLenum waitRet = glClientWaitSync(fence, waitFlags, waitDurationNS);
		if(waitRet == GL_ALREADY_SIGNALED || waitRet == GL_CONDITION_SATISFIED)
		{
			glDeleteSync(fence);
			fence = NULL;
			return;
		}

		if(waitRet == GL_WAIT_FAILED)
		{
			ri.Error(ERR_FATAL, "glClientWaitSync failed with GL_WAIT_FAILED\n");
		}

		// after the first time, we need to start flushing and wait as long as necessary
		waitFlags = GL_SYNC_FLUSH_COMMANDS_BIT;
		waitDurationNS = 1e9;
	}
}

static void Buffer_LockRange(ArrayBuffer* buffer)
{
	GLsync& fence = buffer->fences[buffer->writeRangeIndex];
	assert(fence == NULL);
	if(fence == NULL)
	{
		fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
		assert(fence != NULL);
	}

	buffer->writeRangeIndex = (buffer->writeRangeIndex + 1) % LARGEBUFFER_MAX_FRAMES;
	buffer->writeIndex = buffer->writeRangeIndex * (buffer->capacity / LARGEBUFFER_MAX_FRAMES);
}

static void Buffers_Wait()
{
	for(int i = 0; i < VB_COUNT; ++i)
	{
		Buffer_WaitForRange(&gl.arrayBuffers[i]);
	}

	Buffer_WaitForRange(&gl.indexBuffer);
}

static void Buffers_Lock()
{
	for(int i = 0; i < VB_COUNT; ++i)
	{
		Buffer_LockRange(&gl.arrayBuffers[i]);
	}

	Buffer_LockRange(&gl.indexBuffer);
}

// if qtrue, we have a large buffer for multiple frames and use fences for synchronization
static qbool MappingType_UsesLargeBuffers()
{
	return gl.mappingType == MT_PERSISTENT || gl.mappingType == MT_UNSYNC || gl.mappingType == MT_AMDPIN;
}

static void UploadGeometry(ArrayBuffer* buffer, const void* data, int itemCount)
{
	const GLenum target = buffer->indexBuffer ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER;
	if(MappingType_UsesLargeBuffers())
	{
		const int rangeLength = buffer->capacity / LARGEBUFFER_MAX_FRAMES;
		const int endRangeIndex = (buffer->writeIndex + itemCount - 1) / rangeLength;
#if defined(_DEBUG)
		assert(endRangeIndex == buffer->writeRangeIndex ||
			   endRangeIndex == buffer->writeRangeIndex + 1 ||
			   (endRangeIndex == 0 && buffer->writeRangeIndex == LARGEBUFFER_MAX_FRAMES - 1));
		const int startRangeIndex = buffer->writeIndex == 0 ? 0 : ((buffer->writeIndex - 1) / rangeLength);
		assert(startRangeIndex == buffer->writeRangeIndex ||
			   startRangeIndex == (buffer->writeRangeIndex + LARGEBUFFER_MAX_FRAMES - 1) % LARGEBUFFER_MAX_FRAMES);
#endif
		if(endRangeIndex == buffer->writeRangeIndex + 1)
		{
			Buffer_LockRange(buffer);
			Buffer_WaitForRange(buffer);
		}

		void* mappedData = NULL;
		if(gl.mappingType == MT_UNSYNC)
		{
			mappedData = glMapBufferRange(target, buffer->writeIndex * buffer->itemSize, itemCount * buffer->itemSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
			if(mappedData == NULL)
			{
				ri.Error(ERR_FATAL, "Couldn't map buffer\n");
			}
		}
		else
		{
			mappedData = buffer->mappedData + buffer->writeIndex * buffer->itemSize;
		}
		memcpy(mappedData, data, itemCount * buffer->itemSize);
		if(gl.mappingType == MT_UNSYNC)
		{
			glUnmapBuffer(target);
		}

		buffer->readIndex = buffer->writeIndex;
		buffer->writeIndex += itemCount;
	}
	else
	{
		glBufferSubData(target, (GLintptr)0, itemCount * buffer->itemSize, data);
		buffer->readIndex = 0;
	}
}

static void UploadVertexArray(VertexBufferId vbid, const void* data)
{
	ArrayBuffer* buffer = &gl.arrayBuffers[vbid];

	glBindBuffer(GL_ARRAY_BUFFER, buffer->buffer);
	UploadGeometry(buffer, data, tess.numVertexes);
	if(MappingType_UsesLargeBuffers())
	{
		glVertexAttribPointer(vbid, buffer->componentCount, buffer->dataType, buffer->normalized, buffer->itemSize, (const GLvoid*)(GLintptr)(buffer->readIndex * buffer->itemSize));
	}
}

static void UploadIndices(const void* data, int indexCount)
{
	ArrayBuffer* buffer = &gl.indexBuffer;

	// @NOTE: we only have 1 index buffer and it's already bound
	//glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer->buffer);
	UploadGeometry(buffer, data, indexCount);
}

static void CreateGeometryBufferStorage(ArrayBuffer* buffer)
{
	const GLenum target = buffer->indexBuffer ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER;
	if(gl.mappingType == MT_PERSISTENT)
	{
		glGenBuffers(1, &buffer->buffer);
		glBindBuffer(target, buffer->buffer);
		const GLbitfield flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
		glBufferStorage(target, buffer->capacity * buffer->itemSize, NULL, flags);
		buffer->mappedData = (byte*)glMapBufferRange(target, 0, buffer->capacity * buffer->itemSize, flags);
		if(buffer->mappedData == NULL)
		{
			ri.Error(ERR_FATAL, "Couldn't map buffer storage\n");
		}
	}
	else if(gl.mappingType == MT_AMDPIN)
	{
		while(glGetError() != GL_NO_ERROR) {} // clear the error queue
		GLenum errorCode = GL_NO_ERROR;

		AllocatePinnedMemory(buffer);
		if(buffer->mappedData == NULL)
		{
			ri.Error(ERR_FATAL, "Couldn't allocate buffer storage\n");
		}
		glGenBuffers(1, &buffer->buffer);
		glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, buffer->buffer);
		if((errorCode = glGetError()) != GL_NO_ERROR)
		{
			ri.Error(ERR_FATAL, "glBindBuffer GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD failed with error code: 0x%08X\n", (unsigned int)errorCode);
		}
		glBufferData(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, buffer->pinnedByteCount, buffer->mappedData, GL_DYNAMIC_DRAW);
		if((errorCode = glGetError()) != GL_NO_ERROR)
		{
			ri.Error(ERR_FATAL, "glBufferData GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD failed with error code: 0x%08X\n", (unsigned int)errorCode);
		}
		glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0);
		glBindBuffer(target, buffer->buffer);
	}
	else
	{
		glGenBuffers(1, &buffer->buffer);
		glBindBuffer(target, buffer->buffer);
		glBufferData(target, buffer->capacity * buffer->itemSize, NULL, GL_DYNAMIC_DRAW);
	}
}

static void DrawElements(int indexCount)
{
	glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, (const GLvoid*)(GLintptr)(gl.indexBuffer.readIndex * gl.indexBuffer.itemSize));
}

static void SetDefaultState()
{
	glViewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
	glScissor(0, 0, glConfig.vidWidth, glConfig.vidHeight);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_SCISSOR_TEST);
	glEnable(GL_BLEND);
	glDisable(GL_CULL_FACE);
	glDisable(GL_POLYGON_OFFSET_FILL);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);
	glDepthFunc(GL_LEQUAL);
	glDepthMask(GL_FALSE);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glCullFace(GL_FRONT);
	glPolygonOffset(-1.0f, -1.0f);
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClearDepth(1.0f);
	glActiveTexture(GL_TEXTURE0);
	glDisable(GL_CLIP_DISTANCE0);
	glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);

	gl.boundTextures[0] = GLuint(-1);
	gl.boundTextures[1] = GLuint(-1);
	gl.cullType = CT_TWO_SIDED;
	gl.srcBlendBits = GLS_SRCBLEND_SRC_ALPHA;
	gl.dstBlendBits = GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
	gl.enableDepthTest = qtrue;
	gl.depthFunc = GL_LEQUAL;
	gl.enableDepthWrite = GL_FALSE;
	gl.polygonMode = GL_FILL;
	gl.enablePolygonOffset = qfalse;
	gl.enableClipPlane = qfalse;
	gl.enableAlphaToCoverage = qfalse;
}

static qbool InitCompute()
{
	while(glGetError() != GL_NO_ERROR) {} // clear the error queue

	glGenTextures(ARRAY_LEN(gl.mipGen.textures), gl.mipGen.textures);
	glBindTexture(GL_TEXTURE_2D, gl.mipGen.textures[0]);
	SetDebugName(GL_TEXTURE, gl.mipGen.textures[0], "mip-gen float16 texture #1");
	glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, gl.maxTextureSize, gl.maxTextureSize);
	glBindTexture(GL_TEXTURE_2D, gl.mipGen.textures[1]);
	SetDebugName(GL_TEXTURE, gl.mipGen.textures[1], "mip-gen float16 texture #2");
	glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, gl.maxTextureSize, gl.maxTextureSize);
	glBindTexture(GL_TEXTURE_2D, gl.mipGen.textures[2]);
	SetDebugName(GL_TEXTURE, gl.mipGen.textures[2], "mip-gen uint8 texture");
	glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, gl.maxTextureSize, gl.maxTextureSize);

	if(glGetError() != GL_NO_ERROR)
	{
		HandleError("Failed to allocate storage for the mip-map generation textures\n");
		return qfalse;
	}

	if(!CreateComputeProgram(&gl.mipGen.programs[CPID_GAMMA_TO_LINEAR], gammaToLinear_cs, "gamma to linear") ||
	   !CreateComputeProgram(&gl.mipGen.programs[CPID_LINEAR_TO_GAMMA], linearToGamma_cs, "linear to gamma") ||
	   !CreateComputeProgram(&gl.mipGen.programs[CPID_DOWN_SAMPLE], downSample_cs, "down sample"))
	{
		HandleError("Failed to compile compute shaders for GPU-side mip-map generation\n");
		return qfalse;
	}

	return qtrue;
}

static MappingType GetMappingTypeFromCvar()
{
	const int mode = r_gl3_geoStream->integer;
	if(mode == GL3MAP_SUBDATA)
	{
		return MT_SUBDATA;
	}

	if(mode == GL3MAP_MAPUNSYNC)
	{
		return MT_UNSYNC;
	}

	if(mode == GL3MAP_AMDPIN && GLEW_AMD_pinned_memory)
	{
		return MT_AMDPIN;
	}

	if((mode == GL3MAP_AUTO || mode == GL3MAP_MAPPERS) && (GLEW_VERSION_4_4 || GLEW_ARB_buffer_storage))
	{
		return MT_PERSISTENT;
	}

	if(GLEW_AMD_pinned_memory)
	{
		return MT_AMDPIN;
	}

	if(strstr((const char*)glGetString(GL_RENDERER), "Intel") != NULL)
	{
		return MT_UNSYNC;
	}

	return MT_SUBDATA;
}

static void InitQueries()
{
	glGenQueries(ARRAY_LEN(gl.timerQueries), &gl.timerQueries[0]);
}

static void BeginQueries()
{
	glBeginQuery(GL_TIME_ELAPSED, gl.timerQueries[gl.queryWriteIndex]);
	gl.queryStarted[gl.queryWriteIndex] = qtrue;
}

static void EndQueries()
{
	// finish this frame
	glEndQuery(GL_TIME_ELAPSED);
	gl.queryWriteIndex = (gl.queryWriteIndex + 1) % ARRAY_LEN(gl.timerQueries);

	// try to grab a previous frame's result
	if(gl.queryStarted[gl.queryReadIndex])
	{
		const GLuint query = gl.timerQueries[gl.queryReadIndex];
		backEnd.pc3D[RB_USEC_GPU] = 0;
		GLint done = GL_FALSE;
		glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &done);
		if(done != GL_FALSE)
		{
			GLint durationNS = 0;
			glGetQueryObjectiv(query, GL_QUERY_RESULT, &durationNS);
			if(durationNS > 0)
			{
				backEnd.pc3D[RB_USEC_GPU] = durationNS / 1000;
			}
			gl.queryReadIndex = (gl.queryReadIndex + 1) % ARRAY_LEN(gl.timerQueries);
		}
	}
}

static void Init()
{
	memset(&gl, 0, sizeof(gl));

	GLint maxTextureSize = 0;
	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
	gl.maxTextureSize = maxTextureSize > 0 ? min((int)maxTextureSize, MAX_GPU_TEXTURE_SIZE) : MAX_GPU_TEXTURE_SIZE;
	glConfig.unused_maxTextureSize = gl.maxTextureSize;
	glInfo.maxTextureSize = gl.maxTextureSize;

	FBO_Init();
	if(gl.fbMSEnabled && r_alphaToCoverage->integer)
	{
		glInfo.alphaToCoverageSupport = qtrue;
	}

	int maxVertexCount = SHADER_MAX_VERTEXES;
	int maxIndexCount = SHADER_MAX_INDEXES;
	gl.mappingType = GetMappingTypeFromCvar();
	if(MappingType_UsesLargeBuffers())
	{
		maxVertexCount = LARGEBUFFER_MAX_VERTEXES * LARGEBUFFER_MAX_FRAMES;
		maxIndexCount = LARGEBUFFER_MAX_INDEXES * LARGEBUFFER_MAX_FRAMES;
	}

	gl.arrayBuffers[VB_POSITION].capacity = maxVertexCount;
	gl.arrayBuffers[VB_POSITION].itemSize = sizeof(tess.xyz[0]);
	gl.arrayBuffers[VB_POSITION].componentCount = 4;
	gl.arrayBuffers[VB_POSITION].dataType = GL_FLOAT;
	gl.arrayBuffers[VB_POSITION].normalized = GL_FALSE;
	gl.arrayBuffers[VB_NORMAL].capacity = maxVertexCount;
	gl.arrayBuffers[VB_NORMAL].itemSize = sizeof(tess.normal[0]);
	gl.arrayBuffers[VB_NORMAL].componentCount = 4;
	gl.arrayBuffers[VB_NORMAL].dataType = GL_FLOAT;
	gl.arrayBuffers[VB_NORMAL].normalized = GL_FALSE;
	gl.arrayBuffers[VB_TEXCOORD].capacity = maxVertexCount;
	gl.arrayBuffers[VB_TEXCOORD].itemSize = sizeof(tess.svars[0].texcoords[0]);
	gl.arrayBuffers[VB_TEXCOORD].componentCount = 2;
	gl.arrayBuffers[VB_TEXCOORD].dataType = GL_FLOAT;
	gl.arrayBuffers[VB_TEXCOORD].normalized = GL_FALSE;
	gl.arrayBuffers[VB_TEXCOORD2].capacity = maxVertexCount;
	gl.arrayBuffers[VB_TEXCOORD2].itemSize = sizeof(tess.svars[0].texcoords[0]);
	gl.arrayBuffers[VB_TEXCOORD2].componentCount = 2;
	gl.arrayBuffers[VB_TEXCOORD2].dataType = GL_FLOAT;
	gl.arrayBuffers[VB_TEXCOORD2].normalized = GL_FALSE;
	gl.arrayBuffers[VB_COLOR].capacity = maxVertexCount;
	gl.arrayBuffers[VB_COLOR].itemSize = sizeof(tess.svars[0].colors[0]);
	gl.arrayBuffers[VB_COLOR].componentCount = 4;
	gl.arrayBuffers[VB_COLOR].dataType = GL_UNSIGNED_BYTE;
	gl.arrayBuffers[VB_COLOR].normalized = GL_TRUE;
	gl.indexBuffer.capacity = maxIndexCount;
	gl.indexBuffer.itemSize = sizeof(tess.indexes[0]);
	gl.indexBuffer.indexBuffer = qtrue;

	gl.pipelines[PID_GENERIC].arrayBuffers[VB_POSITION].enabled = qtrue;
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_POSITION].attribName = "position";
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_TEXCOORD].enabled = qtrue;
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_TEXCOORD].attribName = "texCoords1";
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_TEXCOORD2].enabled = qtrue;
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_TEXCOORD2].attribName = "texCoords2";
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_COLOR].enabled = qtrue;
	gl.pipelines[PID_GENERIC].arrayBuffers[VB_COLOR].attribName = "color";
	gl.pipelines[PID_GENERIC].uniformNames[GU_MODELVIEW] = "modelView";
	gl.pipelines[PID_GENERIC].uniformNames[GU_PROJECTION] = "projection";
	gl.pipelines[PID_GENERIC].uniformNames[GU_CLIP_PLANE] = "clipPlane";
	gl.pipelines[PID_GENERIC].uniformNames[GU_ALPHA_TEX] = "alphaTex";
	gl.pipelines[PID_GENERIC].uniformNames[GU_GAMMA_BRIGHT_NOISE_SEED] = "gammaBrightNoiseSeed";

	gl.pipelines[PID_DYNAMIC_LIGHT].arrayBuffers[VB_POSITION].enabled = qtrue;
	gl.pipelines[PID_DYNAMIC_LIGHT].arrayBuffers[VB_POSITION].attribName = "position";
	gl.pipelines[PID_DYNAMIC_LIGHT].arrayBuffers[VB_NORMAL].enabled = qtrue;
	gl.pipelines[PID_DYNAMIC_LIGHT].arrayBuffers[VB_NORMAL].attribName = "normal";
	gl.pipelines[PID_DYNAMIC_LIGHT].arrayBuffers[VB_TEXCOORD].enabled = qtrue;
	gl.pipelines[PID_DYNAMIC_LIGHT].arrayBuffers[VB_TEXCOORD].attribName = "texCoords1";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_MODELVIEW] = "modelView";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_PROJECTION] = "projection";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_CLIP_PLANE] = "clipPlane";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_LIGHT_POS] = "osLightPos";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_EYE_POS] = "osEyePos";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_LIGHT_COLOR_RADIUS] = "lightColorRadius";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_OPAQUE] = "opaque";
	gl.pipelines[PID_DYNAMIC_LIGHT].uniformNames[DU_INTENSITY] = "intensity";

	gl.pipelines[PID_SOFT_SPRITE].arrayBuffers[VB_POSITION].enabled = qtrue;
	gl.pipelines[PID_SOFT_SPRITE].arrayBuffers[VB_POSITION].attribName = "position";
	gl.pipelines[PID_SOFT_SPRITE].arrayBuffers[VB_TEXCOORD].enabled = qtrue;
	gl.pipelines[PID_SOFT_SPRITE].arrayBuffers[VB_TEXCOORD].attribName = "texCoords1";
	gl.pipelines[PID_SOFT_SPRITE].arrayBuffers[VB_COLOR].enabled = qtrue;
	gl.pipelines[PID_SOFT_SPRITE].arrayBuffers[VB_COLOR].attribName = "color";
	gl.pipelines[PID_SOFT_SPRITE].uniformNames[SU_MODELVIEW] = "modelView";
	gl.pipelines[PID_SOFT_SPRITE].uniformNames[SU_PROJECTION] = "projection";
	gl.pipelines[PID_SOFT_SPRITE].uniformNames[SU_CLIP_PLANE] = "clipPlane";
	gl.pipelines[PID_SOFT_SPRITE].uniformNames[SU_ALPHA_TEST] = "alphaTest";
	gl.pipelines[PID_SOFT_SPRITE].uniformNames[SU_PROJ22_32] = "proj22_32";
	gl.pipelines[PID_SOFT_SPRITE].uniformNames[SU_ADD_DIST_OFFSET] = "addDistOffset";

	gl.pipelines[PID_POST_PROCESS].uniformNames[PU_BRIGHT_GAMMA_GREY] = "brightGammaGrey";

	CreateGraphicsProgram(PID_GENERIC, generic_vs, generic_fs, "generic");
	CreateGraphicsProgram(PID_DYNAMIC_LIGHT, dl_vs, dl_fs, "dynamic light");
	CreateGraphicsProgram(PID_SOFT_SPRITE, sprite_vs, sprite_fs, "soft sprite");
	CreateGraphicsProgram(PID_POST_PROCESS, post_vs, post_fs, "post-process");

	GLuint vertexArray;
	glGenVertexArrays(1, &vertexArray);
	glBindVertexArray(vertexArray);

	CreateGeometryBufferStorage(&gl.indexBuffer);
	for(int i = 0; i < VB_COUNT; ++i)
	{
		CreateGeometryBufferStorage(&gl.arrayBuffers[i]);
	}

	for(int p = 0; p < PID_COUNT; ++p)
	{
		Pipeline* pipeline = &gl.pipelines[p];

		pipeline->textureLocations[0] = glGetUniformLocation(pipeline->program.program, "texture1");
		pipeline->textureLocations[1] = glGetUniformLocation(pipeline->program.program, "texture2");

		for(int i = 0; i < ARRAY_LEN(pipeline->uniformLocations); ++i)
		{
			if(pipeline->uniformNames[i] != NULL)
			{
				pipeline->uniformLocations[i] = glGetUniformLocation(pipeline->program.program, pipeline->uniformNames[i]);
#if defined(_DEBUG)
				if(!(r_dither->integer == 0 && p == PID_GENERIC && i == GU_GAMMA_BRIGHT_NOISE_SEED))
				{
					assert(pipeline->uniformLocations[i] != -1);
				}
#endif
			}
		}
	}

	if(r_gpuMipGen->integer && (GLEW_VERSION_4_3 || (GLEW_ARB_compute_shader && GLEW_ARB_texture_storage && GLEW_ARB_shader_image_load_store && GLEW_ARB_copy_image)))
	{
		gl.errorMode = EM_PRINT;
		glInfo.mipGenSupport = InitCompute();
		gl.errorMode = EM_FATAL;
	}

	gl.pipelineId = PID_COUNT;
	ApplyPipeline(PID_GENERIC);

	InitQueries();
}

static void InitGLConfig()
{
	// @NOTE: could use glGetStringi in a loop to grab the extension list, but it's useless either way
	Q_strncpyz(glConfig.vendor_string, (const char*)glGetString(GL_VENDOR), sizeof(glConfig.vendor_string));
	Q_strncpyz(glConfig.renderer_string, (const char*)glGetString(GL_RENDERER), sizeof(glConfig.renderer_string));
	Q_strncpyz(glConfig.version_string, (const char*)glGetString(GL_VERSION), sizeof(glConfig.version_string));
	Q_strncpyz(glConfig.extensions_string, "", sizeof(glConfig.extensions_string));
	glConfig.unused_maxTextureSize = MAX_GPU_TEXTURE_SIZE;
	glConfig.unused_maxActiveTextures = 0;
	glConfig.unused_driverType = 0;		// ICD
	glConfig.unused_hardwareType = 0;	// generic
	glConfig.unused_deviceSupportsGamma = qtrue;
	glConfig.unused_textureCompression = 0;	// no compression
	glConfig.unused_textureEnvAddAvailable = qtrue;
	glConfig.unused_displayFrequency = 0;
	glConfig.unused_isFullscreen = !!r_fullscreen->integer;
	glConfig.unused_stereoEnabled = qfalse;
	glConfig.unused_smpActive = qfalse;
}

static void InitGLInfo()
{
	glInfo.maxTextureSize = MAX_GPU_TEXTURE_SIZE;

	if(GLEW_EXT_texture_filter_anisotropic)
	{
		glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glInfo.maxAnisotropy);
	}
	else
	{
		glInfo.maxAnisotropy = 0;
	}

	glInfo.softSpriteSupport = qtrue;
	glInfo.mipGenSupport = qfalse;
	glInfo.alphaToCoverageSupport = qfalse;
}

static qbool GAL_Init()
{
	if(glConfig.vidWidth == 0)
	{
		// the order of these calls can not be changed
		Sys_V_Init(GAL_GL3);
		if(!GLEW_VERSION_3_2)
		{
			ri.Error(ERR_FATAL, "OpenGL 3.2 is required by the selected back-end!\n");
		}
		InitGLConfig();
		InitGLInfo();
		Init();

		// apply the current V-Sync option after the first rendered frame
		r_swapInterval->modified = qtrue;
	}

	SetDefaultState();

	const int err = glGetError();
	if(err != GL_NO_ERROR)
	{
		ri.Printf(PRINT_ALL, "glGetError() = 0x%x\n", err);
	}

	return qtrue;
}

static void GAL_ShutDown(qbool fullShutDown)
{
	for(int i = 0; i < tr.numImages; ++i)
	{
		const GLuint texture = (GLuint)tr.images[i]->texnum;
		glDeleteTextures(1, &texture);
	}

	tr.numImages = 0;
	memset(tr.images, 0, sizeof(tr.images));

	gl.boundTextures[0] = GLuint(-1);
	gl.boundTextures[1] = GLuint(-1);

	if(fullShutDown && gl.mappingType == MT_AMDPIN)
	{
		// We flush the command queue and wait for all commands to be done executing
		// to make sure the GPU is done accessing our own memory buffers.
		// We could also have used a fence instead.
		glFlush();
		glFinish();

		// Now that it's safe to do so, free our memory buffers.
		for(int i = 0; i < ARRAY_LEN(gl.arrayBuffers); ++i)
		{
			FreePinnedMemory(&gl.arrayBuffers[i]);
		}
		FreePinnedMemory(&gl.indexBuffer);
	}
}

static void GAL_BeginFrame()
{
	BeginQueries();

	FBO_Bind();

	ApplyViewportAndScissor(0, 0, glConfig.vidWidth, glConfig.vidHeight);

	if(r_clear->integer)
	{
		glClearColor(1.0f, 0.0f, 0.5f, 1.0f);
	}
	else
	{
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	}
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	if(MappingType_UsesLargeBuffers())
	{
		Buffers_Wait();
	}
}

static void GAL_EndFrame()
{
	if(MappingType_UsesLargeBuffers())
	{
		Buffers_Lock();
	}

	if(gl.fbMSEnabled)
	{
		FBO_ResolveColor();
	}

	ApplyPipeline(PID_POST_PROCESS);
	ApplyState(GLS_DEPTHTEST_DISABLE, CT_TWO_SIDED, qfalse);
	ApplyViewportAndScissor(0, 0, glConfig.vidWidth, glConfig.vidHeight);
	BindTexture(0, gl.fbSS[gl.fbReadIndex].color);
	Pipeline* const pipeline = &gl.pipelines[PID_POST_PROCESS];
	glUniform3f(pipeline->uniformLocations[PU_BRIGHT_GAMMA_GREY], r_brightness->value, 1.0f / r_gamma->value, r_greyscale->value);
	gl.fbReadIndex ^= 1;
	FBO_Bind(&gl.fbSS[gl.fbReadIndex]);
	glDrawArrays(GL_TRIANGLES, 0, 3);

	ApplyViewportAndScissor(0, 0, glInfo.winWidth, glInfo.winHeight);
	FBO_BlitToBackBuffer();

	EndQueries();
}

static void DrawGeneric()
{
	Pipeline* const pipeline = &gl.pipelines[PID_GENERIC];

	if(pipeline->uniformsDirty[GU_MODELVIEW])
	{
		glUniformMatrix4fv(pipeline->uniformLocations[GU_MODELVIEW], 1, GL_FALSE, gl.modelViewMatrix);
	}
	if(pipeline->uniformsDirty[GU_PROJECTION])
	{
		glUniformMatrix4fv(pipeline->uniformLocations[GU_PROJECTION], 1, GL_FALSE, gl.projectionMatrix);
	}
	if(pipeline->uniformsDirty[GU_CLIP_PLANE])
	{
		glUniform4fv(pipeline->uniformLocations[GU_CLIP_PLANE], 1, gl.clipPlane);
	}
	if(pipeline->uniformsDirty[GU_GAMMA_BRIGHT_NOISE_SEED])
	{
		glUniform4f(
			pipeline->uniformLocations[GU_GAMMA_BRIGHT_NOISE_SEED],
			1.0f / r_gamma->value,
			1.0f / r_brightness->value,
			backEnd.projection2D ? 0.0f : r_noiseScale->value,
			(float)rand() / (float)RAND_MAX);
	}

	UploadVertexArray(VB_POSITION, tess.xyz);
	UploadIndices(tess.indexes, tess.numIndexes);

	for(int i = 0; i < tess.shader->numStages; ++i)
	{
		const shaderStage_t* const stage = tess.xstages[i];
		ApplyState(stage->stateBits, tess.shader->cullType, tess.shader->polygonOffset);

		UploadVertexArray(VB_TEXCOORD, tess.svars[i].texcoordsptr);
		UploadVertexArray(VB_COLOR, tess.svars[i].colors);

		BindBundle(0, &stage->bundle);
		glActiveTexture(GL_TEXTURE1);

		if(stage->mtStages == 0)
		{
			BindImage(1, tr.whiteImage);
			BindVertexArray(VB_TEXCOORD2);
			ApplyTexEnv(TE_DISABLED);
		}
		else
		{
			const shaderStage_t* const stage2 = tess.xstages[i + 1];
			BindBundle(1, &stage2->bundle);
			UploadVertexArray(VB_TEXCOORD2, tess.svars[i + 1].texcoordsptr);
			ApplyTexEnv(stage2->mtEnv);
			++i;
		}

		glActiveTexture(GL_TEXTURE0);

		if(pipeline->uniformsDirty[GU_ALPHA_TEX])
		{
			glUniform2ui(pipeline->uniformLocations[GU_ALPHA_TEX], gl.alphaTest, gl.texEnv);
		}

		DrawElements(tess.numIndexes);
	}

	if(tess.drawFog)
	{
		ApplyState(tess.fogStateBits, tess.shader->cullType, tess.shader->polygonOffset);

		UploadVertexArray(VB_TEXCOORD, tess.svarsFog.texcoordsptr);
		BindVertexArray(VB_TEXCOORD2);
		UploadVertexArray(VB_COLOR, tess.svarsFog.colors);

		BindImage(0, tr.fogImage);
		glActiveTexture(GL_TEXTURE1);
		BindImage(1, tr.whiteImage);
		glActiveTexture(GL_TEXTURE0);

		ApplyTexEnv(TE_DISABLED);
		if(pipeline->uniformsDirty[GU_ALPHA_TEX])
		{
			glUniform2ui(pipeline->uniformLocations[GU_ALPHA_TEX], gl.alphaTest, gl.texEnv);
		}

		DrawElements(tess.numIndexes);
	}

	memset(pipeline->uniformsDirty, 0, sizeof(pipeline->uniformsDirty));
}

static void DrawDynamicLight()
{
	Pipeline* const pipeline = &gl.pipelines[PID_DYNAMIC_LIGHT];

	const int stageIndex = tess.shader->lightingStages[ST_DIFFUSE];
	const shaderStage_t* stage = tess.xstages[stageIndex];

	UploadVertexArray(VB_POSITION, tess.xyz);
	UploadVertexArray(VB_NORMAL, tess.normal);
	UploadVertexArray(VB_TEXCOORD, tess.svars[stageIndex].texcoordsptr);
	UploadIndices(tess.dlIndexes, tess.dlNumIndexes);

	ApplyState(backEnd.dlStateBits, tess.shader->cullType, tess.shader->polygonOffset);
	BindBundle(0, &stage->bundle);

	if(backEnd.dlOpaque != gl.dlOpaque)
	{
		gl.dlOpaque = backEnd.dlOpaque;
		pipeline->uniformsDirty[DU_OPAQUE] = qtrue;
	}

	if(backEnd.dlIntensity != gl.dlIntensity)
	{
		gl.dlIntensity = backEnd.dlIntensity;
		pipeline->uniformsDirty[DU_INTENSITY] = qtrue;
	}

	if(pipeline->uniformsDirty[DU_MODELVIEW])
	{
		glUniformMatrix4fv(pipeline->uniformLocations[DU_MODELVIEW], 1, GL_FALSE, gl.modelViewMatrix);
	}
	if(pipeline->uniformsDirty[DU_PROJECTION])
	{
		glUniformMatrix4fv(pipeline->uniformLocations[DU_PROJECTION], 1, GL_FALSE, gl.projectionMatrix);
	}
	if(pipeline->uniformsDirty[DU_CLIP_PLANE])
	{
		glUniform4fv(pipeline->uniformLocations[DU_CLIP_PLANE], 1, gl.clipPlane);
	}
	if(pipeline->uniformsDirty[DU_OPAQUE])
	{
		glUniform1f(pipeline->uniformLocations[DU_OPAQUE], gl.dlOpaque ? 1.0f : 0.0f);
	}
	if(pipeline->uniformsDirty[DU_INTENSITY])
	{
		glUniform1f(pipeline->uniformLocations[DU_INTENSITY], gl.dlIntensity);
	}

	memset(pipeline->uniformsDirty, 0, sizeof(pipeline->uniformsDirty));

	DrawElements(tess.dlNumIndexes);
}

static void DrawSoftSprite()
{
	Pipeline* const pipeline = &gl.pipelines[PID_SOFT_SPRITE];

	if(pipeline->uniformsDirty[SU_PROJECTION])
	{
		glUniformMatrix4fv(pipeline->uniformLocations[SU_PROJECTION], 1, GL_FALSE, gl.projectionMatrix);
		glUniform2f(pipeline->uniformLocations[SU_PROJ22_32], -gl.projectionMatrix[2 * 4 + 2], gl.projectionMatrix[3 * 4 + 2]);
	}
	if(pipeline->uniformsDirty[SU_MODELVIEW])
	{
		glUniformMatrix4fv(pipeline->uniformLocations[SU_MODELVIEW], 1, GL_FALSE, gl.modelViewMatrix);
	}
	if(pipeline->uniformsDirty[SU_CLIP_PLANE])
	{
		glUniform4fv(pipeline->uniformLocations[SU_CLIP_PLANE], 1, gl.clipPlane);
	}
	glUniform3f(pipeline->uniformLocations[SU_ADD_DIST_OFFSET],
				tess.shader->softSprite == SST_ADDITIVE ? 1.0f : 0.0f,
				tess.shader->softSpriteDistance,
				tess.shader->softSpriteOffset);

	UploadVertexArray(VB_POSITION, tess.xyz);

	for(int i = 0; i < tess.shader->numStages; ++i)
	{
		const shaderStage_t* stage = tess.xstages[i];

		ApplyState(stage->stateBits, tess.shader->cullType, tess.shader->polygonOffset);

		UploadVertexArray(VB_TEXCOORD, tess.svars[i].texcoordsptr);
		UploadVertexArray(VB_COLOR, tess.svars[i].colors);
		UploadIndices(tess.indexes, tess.numIndexes);

		if(pipeline->uniformsDirty[SU_ALPHA_TEST])
		{
			glUniform1ui(pipeline->uniformLocations[SU_ALPHA_TEST], gl.alphaTest);
		}

		BindBundle(0, &stage->bundle);
		glActiveTexture(GL_TEXTURE1);
		BindTexture(1, gl.fbMSEnabled ? gl.fbSSDepth.depthStencil : gl.fbSS[gl.fbReadIndex].depthStencil);
		glActiveTexture(GL_TEXTURE0);

		DrawElements(tess.numIndexes);
	}

	memset(pipeline->uniformsDirty, 0, sizeof(pipeline->uniformsDirty));
}

static void GAL_Draw(drawType_t type)
{
	if(type == DT_GENERIC)
	{
		ApplyPipeline(PID_GENERIC);
		DrawGeneric();
	}
	else if(type == DT_DYNAMIC_LIGHT)
	{
		ApplyPipeline(PID_DYNAMIC_LIGHT);
		DrawDynamicLight();
	}
	else if(type == DT_SOFT_SPRITE)
	{
		ApplyPipeline(PID_SOFT_SPRITE);
		DrawSoftSprite();
	}
}

static void GAL_Begin3D()
{
	ApplyPipeline(PID_GENERIC);
	R_MakeIdentityMatrix(gl.modelViewMatrix);
	memcpy(gl.projectionMatrix, backEnd.viewParms.projectionMatrix, sizeof(gl.projectionMatrix));
	ApplyViewportAndScissor(backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight);

	if(backEnd.viewParms.isPortal)
	{
		float plane[4];
		plane[0] = backEnd.viewParms.portalPlane.normal[0];
		plane[1] = backEnd.viewParms.portalPlane.normal[1];
		plane[2] = backEnd.viewParms.portalPlane.normal[2];
		plane[3] = backEnd.viewParms.portalPlane.dist;

		float plane2[4];
		plane2[0] = DotProduct(backEnd.viewParms.orient.axis[0], plane);
		plane2[1] = DotProduct(backEnd.viewParms.orient.axis[1], plane);
		plane2[2] = DotProduct(backEnd.viewParms.orient.axis[2], plane);
		plane2[3] = DotProduct(plane, backEnd.viewParms.orient.origin) - plane[3];

		float* o = plane;
		const float* m = s_flipMatrix;
		const float* v = plane2;
		o[0] = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12] * v[3];
		o[1] = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13] * v[3];
		o[2] = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14] * v[3];
		o[3] = m[3] * v[0] + m[7] * v[1] + m[11] * v[2] + m[15] * v[3];

		memcpy(gl.clipPlane, plane, sizeof(gl.clipPlane));
		ApplyClipPlane(qtrue);
	}
	else
	{
		memset(gl.clipPlane, 0, sizeof(gl.clipPlane));
		ApplyClipPlane(qfalse);
	}

	ApplyState(GLS_DEFAULT, CT_TWO_SIDED, qfalse);

	GLbitfield clearBits = GL_DEPTH_BUFFER_BIT;
	if(backEnd.refdef.rdflags & RDF_HYPERSPACE)
	{
		clearBits |= GL_COLOR_BUFFER_BIT;
		const float c = RB_HyperspaceColor();
		glClearColor(c, c, c, 1.0f);
	}
	else if(r_fastsky->integer && !(backEnd.refdef.rdflags & RDF_NOWORLDMODEL))
	{
		clearBits |= GL_COLOR_BUFFER_BIT;
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	}
	glClear(clearBits);

	// in case the generic pipeline was already active before calling this function
	gl.pipelines[PID_GENERIC].uniformsDirty[GU_PROJECTION] = qtrue;
	gl.pipelines[PID_GENERIC].uniformsDirty[GU_MODELVIEW] = qtrue;
	gl.pipelines[PID_GENERIC].uniformsDirty[GU_CLIP_PLANE] = qtrue;
}

static void GAL_BeginSkyAndClouds()
{
	gl.prevEnableClipPlane = gl.enableClipPlane;
	ApplyClipPlane(qfalse);
	glDepthRange(1.0, 1.0);
	ApplyState(0, CT_TWO_SIDED, qfalse);
	gl.alphaTest = AT_ALWAYS;
}

static void GAL_EndSkyAndClouds()
{
	glDepthRange(0.0, 1.0);
	ApplyClipPlane(gl.prevEnableClipPlane);
}

static int GetMaxAnisotropy(image_t* image)
{
	if((image->flags & IMG_NOAF) == 0 && glInfo.maxAnisotropy >= 2 && r_ext_max_anisotropy->integer >= 2)
	{
		return min(r_ext_max_anisotropy->integer, glInfo.maxAnisotropy);
	}

	return 1;
}

static void GAL_CreateTexture(image_t* image, int mipCount, int w, int h)
{
	GLuint id;
	glGenTextures(1, &id);
	image->texnum = (textureHandle_t)id;

	BindImage(0, image);
	SetDebugName(GL_TEXTURE, id, image->name);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, GetMaxAnisotropy(image));

	if(image->flags & IMG_LMATLAS)
	{
		glTexImage2D(GL_TEXTURE_2D, 0, GetTextureInternalFormat(image->format), w, h, 0, GetTextureFormat(image->format), GL_UNSIGNED_BYTE, NULL);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		return;
	}

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GetTextureWrapMode(image->wrapClampMode));
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GetTextureWrapMode(image->wrapClampMode));

	if(Q_stricmp(r_textureMode->string, "GL_NEAREST") == 0 &&
	   (image->flags & (IMG_EXTLMATLAS | IMG_NOPICMIP)) == 0)
	{
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}
	else if(image->flags & IMG_NOMIPMAP)
	{
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}
	else
	{
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}
}

static void GAL_UpdateTexture(image_t* image, int mip, int x, int y, int w, int h, const void* data)
{
	BindImage(0, image);
	if(image->flags & IMG_LMATLAS)
	{
		glTexSubImage2D(GL_TEXTURE_2D, (GLint)mip, x, y, w, h, GetTextureFormat(image->format), GL_UNSIGNED_BYTE, data);
	}
	else
	{
		glTexImage2D(GL_TEXTURE_2D, (GLint)mip, GetTextureInternalFormat(image->format), w, h, 0, GetTextureFormat(image->format), GL_UNSIGNED_BYTE, data);
	}
}

static void GAL_UpdateScratch(image_t* image, int w, int h, const void* data, qbool dirty)
{
	BindImage(0, image);

	// if the scratchImage isn't in the format we want, specify it as a new texture
	if(w != image->width || h != image->height)
	{
		image->width = w;
		image->height = h;
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	}
	else if(dirty)
	{
		// otherwise, just subimage upload it so that drivers can tell we are going to be changing
		// it and don't try and do a texture compression
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
	}
}

static void GAL_CreateTextureEx(image_t* image, int mipCount, int mipOffset, int w, int h, const void* mip0)
{
	enum { GroupSize = 8, GroupMask = GroupSize - 1 };

	assert(image->format == TF_RGBA8);
	assert(GetTextureInternalFormat(image->format) == GL_RGBA8);

	// remember what program we had bound before...
	GLint previousProgram = 0;
	glGetIntegerv(GL_CURRENT_PROGRAM, &previousProgram);

	// create the texture with all mip levels
	GLuint id;
	glGenTextures(1, &id);
	image->texnum = (textureHandle_t)id;
	BindTexture(0, id);
	glTexStorage2D(GL_TEXTURE_2D, mipCount - mipOffset, GL_RGBA8, image->width, image->height);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GetTextureWrapMode(image->wrapClampMode));
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GetTextureWrapMode(image->wrapClampMode));
	if(Q_stricmp(r_textureMode->string, "GL_NEAREST") == 0 &&
	   (image->flags & (IMG_LMATLAS | IMG_EXTLMATLAS | IMG_NOPICMIP)) == 0)
	{
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}
	else
	{
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, GetMaxAnisotropy(image));
	SetDebugName(GL_TEXTURE, id, image->name);

	// upload source mip level 0
	BindTexture(0, gl.mipGen.textures[2]);
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, mip0);

	// create a linear color space copy of source mip 0
	glUseProgram(gl.mipGen.programs[CPID_GAMMA_TO_LINEAR].program);
	glUniform1f(0, r_mipGenGamma->value);
	glBindImageTexture(0, gl.mipGen.textures[2], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
	glBindImageTexture(1, gl.mipGen.textures[0], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA16F);
	glDispatchCompute((w + GroupMask) / GroupSize, (h + GroupMask) / GroupSize, 1);

	// copy to destination mip 0 now if needed
	if(mipOffset == 0)
	{
		glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
		glUseProgram(gl.mipGen.programs[CPID_LINEAR_TO_GAMMA].program);
		glUniform1f(0, r_intensity->value);
		glUniform4fv(1, 1, r_mipBlendColors[0]);
		glUniform1f(2, 1.0f / r_mipGenGamma->value);
		glBindImageTexture(0, gl.mipGen.textures[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA16F);
		glBindImageTexture(1, id, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
		glDispatchCompute((w + GroupMask) / GroupSize, (h + GroupMask) / GroupSize, 1);
	}

	for(int i = 1; i < mipCount; ++i)
	{
		const int w1 = w;
		const int h1 = h;
		w = max(w / 2, 1);
		h = max(h / 2, 1);

		// down-sample on the X-axis
		glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
		glUseProgram(gl.mipGen.programs[CPID_DOWN_SAMPLE].program);
		glUniform4fv(0, 1, tr.mipFilter);
		glUniform2i(1, w1 - 1, h1 - 1); // maxSize
		glUniform2i(2, w1 / w, 1); // scale
		glUniform2i(3, 1, 0); // offset
		glUniform1ui(4, image->wrapClampMode == TW_CLAMP_TO_EDGE ? 1 : 0);
		glBindImageTexture(0, gl.mipGen.textures[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA16F);
		glBindImageTexture(1, gl.mipGen.textures[1], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA16F);
		glDispatchCompute((w + GroupMask) / GroupSize, (h1 + GroupMask) / GroupSize, 1);

		// down-sample on the Y-axis
		glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
		glUseProgram(gl.mipGen.programs[CPID_DOWN_SAMPLE].program);
		glUniform4fv(0, 1, tr.mipFilter);
		glUniform2i(1, w - 1, h1 - 1); // maxSize
		glUniform2i(2, 1, h1 / h); // scale
		glUniform2i(3, 0, 1); // offset
		glUniform1ui(4, image->wrapClampMode == TW_CLAMP_TO_EDGE ? 1 : 0);
		glBindImageTexture(0, gl.mipGen.textures[1], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA16F);
		glBindImageTexture(1, gl.mipGen.textures[0], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA16F);
		glDispatchCompute((w + GroupMask) / GroupSize, (h + GroupMask) / GroupSize, 1);

		const int destMip = i - mipOffset;
		if(destMip >= 0)
		{
			// copy the gamma-corrected result to the desired mip slice
			glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
			glUseProgram(gl.mipGen.programs[CPID_LINEAR_TO_GAMMA].program);
			glUniform1f(0, r_intensity->value);
			glUniform4fv(1, 1, r_mipBlendColors[r_colorMipLevels->integer ? destMip : 0]);
			glUniform1f(2, 1.0f / r_mipGenGamma->value);
			glBindImageTexture(0, gl.mipGen.textures[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA16F);
			glBindImageTexture(1, id, i - mipOffset, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
			glDispatchCompute((w + GroupMask) / GroupSize, (h + GroupMask) / GroupSize, 1);
		}
	}

	// restore program
	glUseProgram(previousProgram);
}

static void GAL_BeginDynamicLight()
{
	Pipeline* const pipeline = &gl.pipelines[PID_DYNAMIC_LIGHT];
	const dlight_t* const dl = tess.light;

	ApplyPipeline(PID_DYNAMIC_LIGHT);

	glUniform3fv(pipeline->uniformLocations[DU_EYE_POS], 1, backEnd.orient.viewOrigin);
	glUniform3fv(pipeline->uniformLocations[DU_LIGHT_POS], 1, dl->transformed);
	glUniform4f(pipeline->uniformLocations[DU_LIGHT_COLOR_RADIUS], dl->color[0], dl->color[1], dl->color[2], 1.0f / Square(dl->radius));
}

static void GAL_ReadPixels(int x, int y, int w, int h, int alignment, colorSpace_t colorSpace, void* out)
{
	const GLenum format = colorSpace == CS_BGR ? GL_BGR : GL_RGBA;
	glPixelStorei(GL_PACK_ALIGNMENT, alignment);
	glReadPixels(x, y, w, h, format, GL_UNSIGNED_BYTE, out);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);
}

static void GAL_Begin2D()
{
	ApplyPipeline(PID_GENERIC);
	R_MakeIdentityMatrix(gl.modelViewMatrix);
	R_MakeOrthoProjectionMatrix(gl.projectionMatrix, glConfig.vidWidth, glConfig.vidHeight);
	ApplyViewportAndScissor(0, 0, glConfig.vidWidth, glConfig.vidHeight);
	ApplyClipPlane(qfalse);
	ApplyState(GLS_DEFAULT_2D, CT_TWO_SIDED, qfalse);

	// in case the generic pipeline was already active before calling this function
	gl.pipelines[PID_GENERIC].uniformsDirty[GU_MODELVIEW] = qtrue;
	gl.pipelines[PID_GENERIC].uniformsDirty[GU_PROJECTION] = qtrue;
	gl.pipelines[PID_GENERIC].uniformsDirty[GU_CLIP_PLANE] = qfalse; // not used
}

static void GAL_SetModelViewMatrix(const float* matrix)
{
	memcpy(gl.modelViewMatrix, matrix, sizeof(gl.modelViewMatrix));
	if(gl.pipelineId == PID_GENERIC)
	{
		gl.pipelines[PID_GENERIC].uniformsDirty[GU_MODELVIEW] = qtrue;
	}
	else if(gl.pipelineId == PID_DYNAMIC_LIGHT)
	{
		gl.pipelines[PID_DYNAMIC_LIGHT].uniformsDirty[DU_MODELVIEW] = qtrue;
	}
	else if(gl.pipelineId == PID_SOFT_SPRITE)
	{
		gl.pipelines[PID_SOFT_SPRITE].uniformsDirty[SU_MODELVIEW] = qtrue;
	}
}

static void GAL_SetDepthRange(double zNear, double zFar)
{
	glDepthRange(zNear, zFar);
}

static const char* GetMappingTypeName(MappingType type)
{
	switch(type)
	{
		case MT_SUBDATA: return "glBufferSubData";
		case MT_PERSISTENT: return "glMapBufferRange + GL_MAP_PERSISTENT_BIT";
		case MT_UNSYNC: return "glMapBufferRange + GL_MAP_UNSYNCHRONIZED_BIT";
		case MT_AMDPIN: return "glBufferData + GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD";
		default: return "?";
	}
}

static void GAL_PrintInfo()
{
	ri.Printf(PRINT_ALL, "Geometry upload strategy: %s\n", GetMappingTypeName(gl.mappingType));
}

qbool GAL_GetGL3(graphicsAPILayer_t* rb)
{
	rb->Init = &GAL_Init;
	rb->ShutDown = &GAL_ShutDown;
	rb->BeginSkyAndClouds = &GAL_BeginSkyAndClouds;
	rb->EndSkyAndClouds = &GAL_EndSkyAndClouds;
	rb->ReadPixels = &GAL_ReadPixels;
	rb->BeginFrame = &GAL_BeginFrame;
	rb->EndFrame = &GAL_EndFrame;
	rb->CreateTexture = &GAL_CreateTexture;
	rb->UpdateTexture = &GAL_UpdateTexture;
	rb->UpdateScratch = &GAL_UpdateScratch;
	rb->CreateTextureEx = &GAL_CreateTextureEx;
	rb->Draw = &GAL_Draw;
	rb->Begin2D = &GAL_Begin2D;
	rb->Begin3D = &GAL_Begin3D;
	rb->SetModelViewMatrix = &GAL_SetModelViewMatrix;
	rb->SetDepthRange = &GAL_SetDepthRange;
	rb->BeginDynamicLight = &GAL_BeginDynamicLight;
	rb->PrintInfo = &GAL_PrintInfo;

	return qtrue;
}