Introduced vk_bind_geometry/vk_shade_geometry functions.

src/engine/renderer/tr_backend.c

@@ -977,6 +977,8 @@ void RB_ShowVkImages() {
 
 		GL_Bind( image );
 
+		Com_Memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
+
 		tess.numIndexes = 6;
 		tess.numVertexes = 4;
 
@@ -1007,12 +1009,8 @@ void RB_ShowVkImages() {
 		tess.svars.texcoords[0][3][0] = 0;
 		tess.svars.texcoords[0][3][1] = 1;
 
-		Com_Memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
+		vk_bind_geometry();
-		vk_bind_resources_shared_between_stages();
+		vk_shade_geometry(vk.images_debug_pipeline, false, Vk_Depth_Range::normal);
-		vk_bind_stage_specific_resources(vk.images_debug_pipeline, false, Vk_Depth_Range::normal);
-		vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-		vk_resources.dirty_attachments = true;
-		vk.xyz_elements += tess.numVertexes;
 	}
 	tess.numIndexes = 0;
 	tess.numVertexes = 0;

src/engine/renderer/tr_main.c

@@ -1458,13 +1458,8 @@ void R_DebugPolygon( int color, int numPoints, float *points ) {
 		tess.numIndexes += 3;
 	}
 
-	vk_bind_resources_shared_between_stages();
+	vk_bind_geometry();
-	vk_bind_stage_specific_resources(vk.surface_debug_pipeline_solid, false, Vk_Depth_Range::normal);
+	vk_shade_geometry(vk.surface_debug_pipeline_solid, false, Vk_Depth_Range::normal);
-	vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-	vk_resources.dirty_attachments = true;
-	vk.xyz_elements += tess.numVertexes;
-	tess.numVertexes = 0;
-	tess.numIndexes = 0;
 
 	// Outline.
 	Com_Memset(tess.svars.colors, tr.identityLightByte, numPoints * 2 * sizeof(color4ub_t));
@@ -1476,11 +1471,9 @@ void R_DebugPolygon( int color, int numPoints, float *points ) {
 	tess.numVertexes = numPoints * 2;
 	tess.numIndexes = 0;
 
-	vk_bind_resources_shared_between_stages();
+	vk_bind_geometry();
-	vk_bind_stage_specific_resources(vk.surface_debug_pipeline_outline, false, Vk_Depth_Range::force_zero);
+	vk_shade_geometry(vk.surface_debug_pipeline_outline, false, Vk_Depth_Range::force_zero, false);
-	vkCmdDraw(vk.command_buffer, tess.numVertexes, 1, 0, 0);
+
-	vk_resources.dirty_attachments = true;
-	vk.xyz_elements += tess.numVertexes;
 	tess.numVertexes = 0;
 }
 

src/engine/renderer/tr_shade.c

@@ -118,11 +118,7 @@ static void DrawTris (shaderCommands_t *input) {
 	// VULKAN
 	if (vk.active) {
 		Com_Memset(tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
-		vk_bind_resources_shared_between_stages();
+		vk_shade_geometry(vk.tris_debug_pipeline, false, Vk_Depth_Range::force_zero);
-		vk_bind_stage_specific_resources(vk.tris_debug_pipeline, false, Vk_Depth_Range::force_zero);
-		vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-		vk_resources.dirty_attachments = true;
-		vk.xyz_elements += tess.numVertexes;
 	}
 }
 
@@ -173,11 +169,8 @@ static void DrawNormals (shaderCommands_t *input) {
 			tess.numVertexes = 2 * count;
 			tess.numIndexes = 0;
 
-			vk_bind_resources_shared_between_stages();
+			vk_bind_geometry();
-			vk_bind_stage_specific_resources(vk.normals_debug_pipeline, false, Vk_Depth_Range::force_zero);
+			vk_shade_geometry(vk.normals_debug_pipeline, false, Vk_Depth_Range::force_zero, false);
-			vkCmdDraw(vk.command_buffer, tess.numVertexes, 1, 0, 0);
-			vk_resources.dirty_attachments = true;
-			vk.xyz_elements += tess.numVertexes;
 
 			i += count;
 		}
@@ -402,9 +395,7 @@ static void ProjectDlightTexture( void ) {
         // VULKAN
         if (vk.active) {
             VkPipeline pipeline = vk.dlight_pipelines[dl->additive > 0 ? 1 : 0][tess.shader->cullType][tess.shader->polygonOffset];
-            vk_bind_stage_specific_resources(pipeline, false, Vk_Depth_Range::normal);
+            vk_shade_geometry(pipeline, false, Vk_Depth_Range::normal);
-            vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-            vk_resources.dirty_attachments = true;
         }
 	}
 }
@@ -449,9 +440,7 @@ static void RB_FogPass( void ) {
     if (vk.active) {
         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, Vk_Depth_Range::normal);
+        vk_shade_geometry(pipeline, false, Vk_Depth_Range::normal);
-        vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-        vk_resources.dirty_attachments = true;
     }
 }
 
@@ -756,7 +745,7 @@ static void ComputeTexCoords( shaderStage_t *pStage ) {
 static void RB_IterateStagesGeneric( shaderCommands_t *input )
 {
     // VULKAN
-    vk_bind_resources_shared_between_stages();
+    vk_bind_geometry();
 
 	for ( int stage = 0; stage < MAX_SHADER_STAGES; stage++ )
 	{
@@ -823,9 +812,7 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
 				depth_range = Vk_Depth_Range::normal;
 			}
 
-            vk_bind_stage_specific_resources(pipeline, multitexture, depth_range);
+            vk_shade_geometry(pipeline, multitexture, depth_range);
-            vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-            vk_resources.dirty_attachments = true;
         }
 
 		// allow skipping out to show just lightmaps during development
@@ -932,9 +919,6 @@ void RB_StageIteratorGeneric( void )
 		RB_FogPass();
 	}
 
-    // VULKAN
-    vk.xyz_elements += tess.numVertexes;
-
 	// 
 	// unlock arrays
 	//
@@ -964,6 +948,9 @@ void RB_EndSurface( void ) {
 	if (input->numIndexes == 0) {
 		return;
 	}
+	if (tess.shader->isSky && r_fastsky->integer) {
+		return;
+	}
 
 	if (input->indexes[SHADER_MAX_INDEXES-1] != 0) {
 		ri.Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_INDEXES hit");

src/engine/renderer/tr_shadows.c

@@ -143,11 +143,8 @@ static void R_Vk_RenderShadowEdges(VkPipeline pipeline) {
 			tess.svars.colors[k][3] = 255;
 		}
 
-		vk_bind_resources_shared_between_stages();
+		vk_bind_geometry();
-		vk_bind_stage_specific_resources(pipeline, false, Vk_Depth_Range::normal);
+		vk_shade_geometry(pipeline, false, Vk_Depth_Range::normal);
-		vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-		vk_resources.dirty_attachments = true;
-		vk.xyz_elements += tess.numVertexes;
 
 		i += count;
 	}
@@ -341,15 +338,10 @@ void RB_ShadowFinish( void ) {
 		vk_resources.modelview_transform[10] = 1.0f;
 		vk_resources.modelview_transform[15] = 1.0f;
 
-		vk_bind_resources_shared_between_stages();
+		vk_bind_geometry();
+		vk_shade_geometry(vk.shadow_finish_pipeline, false, Vk_Depth_Range::normal);
 
 		Com_Memcpy(vk_resources.modelview_transform, tmp, 64);
-
-		vk_bind_stage_specific_resources(vk.shadow_finish_pipeline, false, Vk_Depth_Range::normal);
-		vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-		vk_resources.dirty_attachments = true;
-		vk.xyz_elements += tess.numVertexes;
-
 		tess.numIndexes = 0;
 		tess.numVertexes = 0;
 	}

src/engine/renderer/tr_sky.c

@@ -454,6 +454,8 @@ static void DrawSkyBox( shader_t *shader )
         if (vk.active) {
 			GL_Bind(shader->sky.outerbox[sky_texorder[i]]);
 
+			Com_Memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
+
             tess.numVertexes = 0;
             tess.numIndexes = 0;
 
@@ -492,12 +494,8 @@ static void DrawSkyBox( shader_t *shader )
                 }
             }
 
-            Com_Memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
+            vk_bind_geometry();
-            vk_bind_resources_shared_between_stages();
+            vk_shade_geometry(vk.skybox_pipeline, false, r_showsky->integer ? Vk_Depth_Range::force_zero : Vk_Depth_Range::force_one);
-            vk_bind_stage_specific_resources(vk.skybox_pipeline, false, r_showsky->integer ? Vk_Depth_Range::force_zero : Vk_Depth_Range::force_one);
-            vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
-            vk_resources.dirty_attachments = true;
-            vk.xyz_elements += tess.numVertexes;
         }
 	}
 
@@ -709,10 +707,6 @@ Other things could be stuck in here, like birds in the sky, etc
 ================
 */
 void RB_StageIteratorSky( void ) {
-	if ( r_fastsky->integer ) {
-		return;
-	}
-
 	// go through all the polygons and project them onto
 	// the sky box to see which blocks on each side need
 	// to be drawn

src/engine/renderer/vk.cpp

@@ -2073,32 +2073,36 @@ static void get_mvp_transform(float* mvp) {
     }
 }
 
-void vk_bind_resources_shared_between_stages() {
+void vk_bind_geometry() {
-    if (!vk.active) return;
+	if (!vk.active) 
+		return;
 
-    // xyz
+    // xyz stream
     {
         if ((vk.xyz_elements + tess.numVertexes) * sizeof(vec4_t) > XYZ_SIZE)
-            ri.Error(ERR_DROP, "vulkan: vertex buffer overflow (xyz)\n");
+            ri.Error(ERR_DROP, "vk_bind_geometry: vertex buffer overflow (xyz)\n");
 
         byte* dst = vk.vertex_buffer_ptr + XYZ_OFFSET + vk.xyz_elements * sizeof(vec4_t);
         Com_Memcpy(dst, tess.xyz, tess.numVertexes * sizeof(vec4_t));
+
+		VkDeviceSize xyz_offset = XYZ_OFFSET + vk.xyz_elements * sizeof(vec4_t);
+		vkCmdBindVertexBuffers(vk.command_buffer, 0, 1, &vk.vertex_buffer, &xyz_offset);
+		vk.xyz_elements += tess.numVertexes;
     }
 
-    std::size_t indexes_size = tess.numIndexes * sizeof(uint32_t);        
+    // indexes stream
-
-    // update index buffer
     {
+		std::size_t indexes_size = tess.numIndexes * sizeof(uint32_t);        
+
         if (vk.index_buffer_offset + indexes_size > INDEX_BUFFER_SIZE)
-            ri.Error(ERR_DROP, "vk_draw: index buffer overflow\n");
+            ri.Error(ERR_DROP, "vk_bind_geometry: index buffer overflow\n");
 
         byte* dst = vk.index_buffer_ptr + vk.index_buffer_offset;
         Com_Memcpy(dst, tess.indexes, indexes_size);
-    }
 
-    // configure indexes stream
+		vkCmdBindIndexBuffer(vk.command_buffer, vk.index_buffer, vk.index_buffer_offset, VK_INDEX_TYPE_UINT32);
-    vkCmdBindIndexBuffer(vk.command_buffer, vk.index_buffer, vk.index_buffer_offset, VK_INDEX_TYPE_UINT32);
+		vk.index_buffer_offset += indexes_size;
-    vk.index_buffer_offset += indexes_size;
+    }
 
     //
     // Specify push constants.
@@ -2138,16 +2142,10 @@ 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);
 }
 
-void vk_bind_stage_specific_resources(VkPipeline pipeline, bool multitexture, Vk_Depth_Range depth_range) {
+void vk_shade_geometry(VkPipeline pipeline, bool multitexture, Vk_Depth_Range depth_range, bool indexed) {
-    //
-    // Specify color/st for each draw call since they are regenerated for each Q3 shader's stage.
-    // xyz are specified only once for all stages.
-    //
-
     // color
     {
         if ((vk.color_st_elements + tess.numVertexes) * sizeof(color4ub_t) > COLOR_SIZE)
@@ -2156,7 +2154,6 @@ void vk_bind_stage_specific_resources(VkPipeline pipeline, bool multitexture, Vk
         byte* dst = vk.vertex_buffer_ptr + COLOR_OFFSET + vk.color_st_elements * sizeof(color4ub_t);
         Com_Memcpy(dst, tess.svars.colors, tess.numVertexes * sizeof(color4ub_t));
     }
-
     // st0
     {
         if ((vk.color_st_elements + tess.numVertexes) * sizeof(vec2_t) > ST0_SIZE)
@@ -2165,7 +2162,6 @@ void vk_bind_stage_specific_resources(VkPipeline pipeline, bool multitexture, Vk
         byte* dst = vk.vertex_buffer_ptr + ST0_OFFSET + vk.color_st_elements * sizeof(vec2_t);
         Com_Memcpy(dst, tess.svars.texcoords[0], tess.numVertexes * sizeof(vec2_t));
     }
-
     // st1
     if (multitexture) {
         if ((vk.color_st_elements + tess.numVertexes) * sizeof(vec2_t) > ST1_SIZE)
@@ -2176,15 +2172,13 @@ void vk_bind_stage_specific_resources(VkPipeline pipeline, bool multitexture, Vk
     }
 
     // configure vertex data stream
-    VkBuffer bufs[4] = { vk.vertex_buffer, vk.vertex_buffer, vk.vertex_buffer, vk.vertex_buffer }; // turtles all the way down
+    VkBuffer bufs[3] = { vk.vertex_buffer, vk.vertex_buffer, vk.vertex_buffer };
-    VkDeviceSize offs[4] = {
+    VkDeviceSize offs[3] = {
-        XYZ_OFFSET   + vk.xyz_elements * sizeof(vec4_t),
         COLOR_OFFSET + vk.color_st_elements * sizeof(color4ub_t),
         ST0_OFFSET   + vk.color_st_elements * sizeof(vec2_t),
         ST1_OFFSET   + vk.color_st_elements * sizeof(vec2_t)
     };
-
+    vkCmdBindVertexBuffers(vk.command_buffer, 1, multitexture ? 3 : 2, bufs, offs);
-    vkCmdBindVertexBuffers(vk.command_buffer, 0, multitexture ? 4 : 3, bufs, offs);
     vk.color_st_elements += tess.numVertexes;
 
     // bind descriptor sets
@@ -2204,6 +2198,14 @@ void vk_bind_stage_specific_resources(VkPipeline pipeline, bool multitexture, Vk
     if (tess.shader->polygonOffset) {
         vkCmdSetDepthBias(vk.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value);
     }
+
+	// issue draw call
+	if (indexed)
+		vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
+	else
+		vkCmdDraw(vk.command_buffer, tess.numVertexes, 1, 0, 0);
+
+	vk_resources.dirty_attachments = true;
 }
 
 void vk_begin_frame() {

src/engine/renderer/vk.h

@@ -97,8 +97,8 @@ VkPipeline vk_find_pipeline(const Vk_Pipeline_Def& def);
 //
 VkRect2D vk_get_scissor_rect();
 void vk_clear_attachments(bool clear_depth_stencil, bool clear_color, vec4_t color);
-void vk_bind_resources_shared_between_stages();
+void vk_bind_geometry();
-void vk_bind_stage_specific_resources(VkPipeline pipeline, bool multitexture, Vk_Depth_Range depth_range);
+void vk_shade_geometry(VkPipeline pipeline, bool multitexture, Vk_Depth_Range depth_range, bool indexed = true);
 void vk_begin_frame();
 void vk_end_frame();