Add Vulkan rendering backend

Implement a Vulkan 1.1 renderer that replaces the previous stub with a
fully functional backend, mostly matching the OpenGL backend's rendering
capabilities.

Core rendering infrastructure:

- `VulkanMemory`: Custom allocator with sub-allocation from device-local and
  host-visible memory pools
- `VulkanBuffer`: Per-frame bump allocator for streaming uniform/vertex/index
  data (persistently mapped, double-buffered, auto-growing)
- `VulkanTexture`: Full texture management including 2D, 2D-array, 3D, and
  cubemap types with automatic mipmap generation and sampler caching
- `VulkanPipeline`: Lazy pipeline creation from hashed render state, with
  persistent VkPipelineCache for cross-session reuse
- `VulkanShader`: SPIR-V shader loading (main, deferred,
  effects, post-processing, shadows, decals, fog, MSAA resolve, etc.)
- `VulkanDescriptorManager`: 3-set descriptor layout (Global/Material/PerDraw)
  with per-frame pool allocation, auto-grow, and batched updates
- `VulkanDeletionQueue`: Deferred resource destruction synchronized to
  frame-in-flight fences

Design choices:

- Two frames in flight with fence-based synchronization
- Asynchronous texture upload, no `waitIdle` in hot path
- Single command buffer per frame; render passes begun/ended as needed
  for the multi-pass deferred pipeline
- Per-frame descriptor pools
- All descriptor bindings pre-initialized with fallback resources (zero
  UBO + 1x1 white texture) so partial updates never leave undefined state
- Streaming data uses a bump allocator (one large VkBuffer per frame)
- Pipeline cache persisted to disk for fast startup on subsequent runs

Some notable Vulkan vs OpenGL differences are:

- Depth range is [0,1] not [-1,1]: shadow projection matrices adjusted,
  shaders that linearize depth need isinf/zero guards at depth boundaries
  where OpenGL gives finite values
- gl_ClipDistance is always evaluated: must write 1.0 when clipping is
  disabled (OpenGL allows leaving it uninitialized)
- Swap chain is B8G8R8A8: screenshot/save_screen paths swizzle to RGBA
- Vulkan render target is "upside down", y-flip for render target is
  handled through negative viewport height, as is common
- Texture addressing for AABITMAP/INTERFACE/CUBEMAP forced to clamp
  (OpenGL's sampler state happens to do this implicitly)
- Render pass architecture requires explicit transitions between G-buffer,
  shadow, decal, light accumulation, fog, and post-processing passes
  (OpenGL just switches FBO bindings)

Author: laanwj

code/graphics/2d.h

@@ -214,6 +214,8 @@ enum shader_type {
 
 	SDR_TYPE_IRRADIANCE_MAP_GEN,
 
+	SDR_TYPE_SHADOW_MAP,
+
 	NUM_SHADER_TYPES
 };
 

code/graphics/matrix.cpp

@@ -53,9 +53,18 @@ static void create_perspective_projection_matrix(matrix4 *out, float left, float
 	out->a1d[5] = 2.0f * near_dist / (top - bottom);
 	out->a1d[8] = (right + left) / (right - left);
 	out->a1d[9] = (top + bottom) / (top - bottom);
-	out->a1d[10] = -(far_dist + near_dist) / (far_dist - near_dist);
 	out->a1d[11] = -1.0f;
-	out->a1d[14] = -2.0f * far_dist * near_dist / (far_dist - near_dist);
+
+	if (gr_screen.mode == GR_VULKAN) {
+		// Vulkan NDC Z range is [0, 1] (OpenGL is [-1, 1])
+		// Y-flip is handled by negative viewport height (VK_KHR_maintenance1)
+		out->a1d[10] = -far_dist / (far_dist - near_dist);
+		out->a1d[14] = -far_dist * near_dist / (far_dist - near_dist);
+	} else {
+		// OpenGL NDC Z range is [-1, 1]
+		out->a1d[10] = -(far_dist + near_dist) / (far_dist - near_dist);
+		out->a1d[14] = -2.0f * far_dist * near_dist / (far_dist - near_dist);
+	}
 }
 
 static void create_orthographic_projection_matrix(matrix4* out, float left, float right, float bottom, float top, float near_dist, float far_dist)
@@ -64,11 +73,20 @@ static void create_orthographic_projection_matrix(matrix4* out, float left, floa
 
 	out->a1d[0] = 2.0f / (right - left);
 	out->a1d[5] = 2.0f / (top - bottom);
-	out->a1d[10] = -2.0f / (far_dist - near_dist);
 	out->a1d[12] = -(right + left) / (right - left);
 	out->a1d[13] = -(top + bottom) / (top - bottom);
-	out->a1d[14] = -(far_dist + near_dist) / (far_dist - near_dist);
 	out->a1d[15] = 1.0f;
+
+	if (gr_screen.mode == GR_VULKAN) {
+		// Vulkan NDC Z range is [0, 1] (OpenGL is [-1, 1])
+		// Y-flip is handled by negative viewport height (VK_KHR_maintenance1)
+		out->a1d[10] = -1.0f / (far_dist - near_dist);
+		out->a1d[14] = -near_dist / (far_dist - near_dist);
+	} else {
+		// OpenGL NDC Z range is [-1, 1]
+		out->a1d[10] = -2.0f / (far_dist - near_dist);
+		out->a1d[14] = -(far_dist + near_dist) / (far_dist - near_dist);
+	}
 }
 
 void gr_start_instance_matrix(const vec3d *offset, const matrix *rotation)

code/graphics/shaders/batched.frag

@@ -0,0 +1,44 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+#include "gamma.sdr"
+
+// Inputs from vertex shader
+layout (location = 0) in vec4 fragTexCoord;
+layout (location = 1) in vec4 fragColor;
+
+// Output
+layout (location = 0) out vec4 fragOut0;
+
+// Texture sampler array (binding 1 in Material set)
+layout (set = 1, binding = 1) uniform sampler2DArray baseMap;
+
+// Uniform buffer: GenericData (binding 0 in PerDraw set)
+// Must match the layout used by vulkan_set_default_material_uniforms()
+layout (set = 2, binding = 0, std140) uniform genericData {
+	mat4 modelMatrix;
+
+	vec4 color;
+
+	vec4 clipEquation;
+
+	int baseMapIndex;
+	int alphaTexture;
+	int noTexturing;
+	int srgb;
+
+	float intensity;
+	float alphaThreshold;
+	uint clipEnabled;
+};
+
+void main()
+{
+	float y = fragTexCoord.y / fragTexCoord.w;
+	vec4 baseColor = texture(baseMap, vec3(fragTexCoord.x, y, fragTexCoord.z));
+
+	baseColor.rgb = srgb_to_linear(baseColor.rgb);
+	vec4 blendColor = vec4(srgb_to_linear(fragColor.rgb), fragColor.a);
+
+	fragOut0 = baseColor * blendColor * intensity;
+}

code/graphics/shaders/batched.vert

@@ -0,0 +1,43 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+// Vertex inputs
+layout (location = 0) in vec4 vertPosition;
+layout (location = 1) in vec4 vertColor;
+layout (location = 2) in vec4 vertTexCoord;
+
+// Outputs to fragment shader
+layout (location = 0) out vec4 fragTexCoord;
+layout (location = 1) out vec4 fragColor;
+
+// Uniform buffer: Matrices (binding 1 in PerDraw set)
+layout (set = 2, binding = 1, std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
+
+// Uniform buffer: GenericData (binding 0 in PerDraw set)
+// Must match the layout used by vulkan_set_default_material_uniforms()
+layout (set = 2, binding = 0, std140) uniform genericData {
+	mat4 modelMatrix;
+
+	vec4 color;
+
+	vec4 clipEquation;
+
+	int baseMapIndex;
+	int alphaTexture;
+	int noTexturing;
+	int srgb;
+
+	float intensity;
+	float alphaThreshold;
+	uint clipEnabled;
+};
+
+void main()
+{
+	fragColor = vertColor * color;
+	gl_Position = projMatrix * modelViewMatrix * vertPosition;
+	fragTexCoord = vertTexCoord;
+}

code/graphics/shaders/bloom-comp.frag

@@ -0,0 +1,26 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec2 fragTexCoord;
+layout(location = 0) out vec4 fragOut0;
+
+layout(set = 1, binding = 1) uniform sampler2D bloomed;
+
+layout(std140, set = 2, binding = 0) uniform genericData {
+	float bloom_intensity;
+	int levels;
+};
+
+void main()
+{
+	vec4 color_out = vec4(0.0, 0.0, 0.0, 1.0);
+	float factor = 0.0;
+	for (int mipmap = 0; mipmap < levels; ++mipmap) {
+		float scale = 1.0 / exp2(float(mipmap));
+		factor += scale;
+		color_out.rgb += textureLod(bloomed, fragTexCoord, float(mipmap)).rgb * scale;
+	}
+	color_out.rgb /= factor;
+	color_out.rgb *= bloom_intensity;
+	fragOut0 = color_out;
+}

code/graphics/shaders/blur.frag

@@ -0,0 +1,39 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec2 fragTexCoord;
+layout(location = 0) out vec4 fragOut0;
+
+layout(set = 1, binding = 1) uniform sampler2D tex;
+
+layout(std140, set = 2, binding = 0) uniform genericData {
+	float texSize;
+	int level;
+	int direction; // 0 = horizontal, 1 = vertical
+};
+
+void main()
+{
+	float BlurWeights[6];
+	BlurWeights[0] = 0.1362;
+	BlurWeights[1] = 0.1297;
+	BlurWeights[2] = 0.1120;
+	BlurWeights[3] = 0.0877;
+	BlurWeights[4] = 0.0623;
+	BlurWeights[5] = 0.0402;
+
+	vec4 sum = textureLod(tex, fragTexCoord, float(level)) * BlurWeights[0];
+
+	for (int i = 1; i < 6; i++) {
+		float offset = float(i) * texSize;
+		if (direction == 0) {
+			sum += textureLod(tex, vec2(clamp(fragTexCoord.x - offset, 0.0, 1.0), fragTexCoord.y), float(level)) * BlurWeights[i];
+			sum += textureLod(tex, vec2(clamp(fragTexCoord.x + offset, 0.0, 1.0), fragTexCoord.y), float(level)) * BlurWeights[i];
+		} else {
+			sum += textureLod(tex, vec2(fragTexCoord.x, clamp(fragTexCoord.y - offset, 0.0, 1.0)), float(level)) * BlurWeights[i];
+			sum += textureLod(tex, vec2(fragTexCoord.x, clamp(fragTexCoord.y + offset, 0.0, 1.0)), float(level)) * BlurWeights[i];
+		}
+	}
+
+	fragOut0 = sum;
+}

code/graphics/shaders/brightpass.frag

@@ -0,0 +1,13 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec2 fragTexCoord;
+layout(location = 0) out vec4 fragOut0;
+
+layout(set = 1, binding = 1) uniform sampler2D tex;
+
+void main()
+{
+	vec4 color = texture(tex, fragTexCoord);
+	fragOut0 = vec4(max(vec3(0.0), color.rgb - vec3(1.0)), 1.0);
+}