Fog.

src/engine/renderer/tr_shade.c

@@ -486,6 +486,13 @@ static void RB_FogPass( void ) {
 	}
 
 	R_DrawElements( tess.numIndexes, tess.indexes );
+
+    // VULKAN
+    assert(tess.shader->fogPass > 0);
+    VkPipeline pipeline = vk.fog_pipelines[tess.shader->fogPass - 1][tess.shader->cullType][tess.shader->polygonOffset];
+    vk_bind_stage_specific_resources(pipeline, false, false);
+    vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
+    glState.vk_dirty_attachments = true;
 }
 
 /*
@@ -858,9 +865,6 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
 			break;
 		}
 	}
-
-    // VULKAN
-    vk.xyz_elements += tess.numVertexes;
 }
 
 
@@ -959,6 +963,9 @@ void RB_StageIteratorGeneric( void )
 		RB_FogPass();
 	}
 
+    // VULKAN
+    vk.xyz_elements += tess.numVertexes;
+
 	// 
 	// unlock arrays
 	//

src/engine/renderer/vk.cpp

@@ -864,8 +864,10 @@ void vk_create_instance(HWND hwnd) {
     }
 
     //
-    // Skybox pipeline.
+    // Standard pipelines.
     //
+    {
+        // skybox
         {
             Vk_Pipeline_Def def;
             def.shader_type = Vk_Shader_Type::single_texture;
@@ -877,6 +879,33 @@ void vk_create_instance(HWND hwnd) {
 
             vk.skybox_pipeline = create_pipeline(def);
         }
+
+        // fog
+        {
+            Vk_Pipeline_Def def;
+            def.shader_type = Vk_Shader_Type::single_texture;
+            def.clipping_plane = false;
+            def.mirror = false;
+
+            unsigned int state_bits[2] = {
+                GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL,
+                GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA
+            };
+            bool polygon_offset[2] = {false, true};
+
+            for (int i = 0; i < 2; i++) {
+                def.state_bits = state_bits[i];
+                for (int j = 0; j < 3; j++) {
+                    def.face_culling = j; // cullType_t value
+                    for (int k = 0; k < 2; k++) {
+                        def.polygon_offset = polygon_offset[k];
+                        vk.fog_pipelines[i][j][k] = create_pipeline(def);
+                    }
+                }
+            }
+        }
+
+    }
 }
 
 void vk_destroy_instance() {
@@ -916,6 +945,10 @@ void vk_destroy_instance() {
     vkDestroyShaderModule(vk.device, vk.multi_texture_add_fs, nullptr);
 
     vkDestroyPipeline(vk.device, vk.skybox_pipeline, nullptr);
+    for (int i = 0; i < 2; i++)
+        for (int j = 0; j < 3; j++)
+            for (int k = 0; k < 2; k++)
+                vkDestroyPipeline(vk.device, vk.fog_pipelines[i][j][k], nullptr);
 
     vkDestroySwapchainKHR(vk.device, vk.swapchain, nullptr);
     vkDestroyDevice(vk.device, nullptr);
@@ -1655,7 +1688,9 @@ void vk_bind_resources_shared_between_stages() {
     vkCmdBindIndexBuffer(vk.command_buffer, vk.index_buffer, vk.index_buffer_offset, VK_INDEX_TYPE_UINT32);
     vk.index_buffer_offset += indexes_size;
 
-    // specify push constants
+    //
+    // Specify push constants.
+    //
     float push_constants[16 + 12 + 4]; // mvp transform + eye transform + clipping plane in eye space
 
     get_mvp_transform(push_constants);
@@ -1691,6 +1726,7 @@ void vk_bind_resources_shared_between_stages() {
 
         push_constants_size += 64;
     }
+
     vkCmdPushConstants(vk.command_buffer, vk.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, push_constants_size, push_constants);
 }
 

src/engine/renderer/vk.h

@@ -133,6 +133,11 @@ struct Vk_Instance {
     VkShaderModule multi_texture_add_fs = VK_NULL_HANDLE;
 
     VkPipeline skybox_pipeline = VK_NULL_HANDLE;
+
+    // dim 0 is based on fogPass_t: 0 - corresponds to FP_EQUAL, 1 - corresponds to FP_LE.
+    // dim 1 is directly a cullType_t enum value.
+    // dim 2 is a polygon offset value (0 - off, 1 - on).
+    VkPipeline fog_pipelines[2][3][2];
 };
 
 struct Vk_Resources {