Merge pull request scp-fs2open#1627 from asarium/fix/lineDrawList

Add a mechanism for batching line draw calls

Author: asarium

code/graphics/2d.h

@@ -216,6 +216,7 @@ struct vertex_format_data
 		SCREEN_POS,
 		COLOR3,
 		COLOR4,
+		COLOR4F,
 		TEX_COORD2,
 		TEX_COORD3,
 		NORMAL,

code/graphics/line_draw_list.cpp

@@ -0,0 +1,67 @@
+//
+//
+
+#include "line_draw_list.h"
+#include "2d.h"
+#include "material.h"
+#include "tracing/tracing.h"
+
+namespace graphics {
+
+line_draw_list::line_draw_list() {
+}
+void line_draw_list::add_line(int x1, int y1, int x2, int y2, int resize_mode) {
+	add_vertex(x1, y1, resize_mode, &gr_screen.current_color);
+	add_vertex(x2, y2, resize_mode, &gr_screen.current_color);
+}
+void line_draw_list::add_gradient(int x1, int y1, int x2, int y2, int resize_mode) {
+	add_vertex(x1, y1, resize_mode, &gr_screen.current_color);
+
+	color endColor = gr_screen.current_color;
+	endColor.alpha = 0;
+	add_vertex(x2, y2, resize_mode, &endColor);
+}
+void line_draw_list::flush() {
+	if (_line_vertices.empty()) {
+		// Nothing to do here...
+		return;
+	}
+
+	GR_DEBUG_SCOPE("Line draw list flush");
+	TRACE_SCOPE(tracing::LineDrawListFlush);
+
+	material line_mat;
+	line_mat.set_blend_mode(ALPHA_BLEND_ALPHA_BLEND_ALPHA);
+	line_mat.set_depth_mode(ZBUFFER_TYPE_NONE);
+	line_mat.set_cull_mode(false);
+	line_mat.set_color(1.0f, 1.0f, 1.0f, 1.0f); // Color is handled by the vertices
+
+
+	vertex_layout layout;
+	layout.add_vertex_component(vertex_format_data::POSITION2, sizeof(line_vertex), offsetof(line_vertex, position));
+	layout.add_vertex_component(vertex_format_data::COLOR4F, sizeof(line_vertex), offsetof(line_vertex, color));
+
+	gr_render_primitives_2d_immediate(&line_mat,
+									  PRIM_TYPE_LINES,
+									  &layout,
+									  static_cast<int>(_line_vertices.size()),
+									  _line_vertices.data(),
+									  _line_vertices.size() * sizeof(line_vertex));
+
+	_line_vertices.clear();
+}
+void line_draw_list::add_vertex(int x, int y, int resize_mode, const color* color) {
+	line_vertex vtx{};
+	vtx.position.x = i2fl(x);
+	vtx.position.y = i2fl(y);
+
+	gr_resize_screen_posf(&vtx.position.x, &vtx.position.y, nullptr, nullptr, resize_mode);
+	vtx.color.xyzw.x = color->red / 255.f;
+	vtx.color.xyzw.y = color->green / 255.f;
+	vtx.color.xyzw.z = color->blue / 255.f;
+	vtx.color.xyzw.w = color->is_alphacolor ? color->alpha / 255.f : 1.f;
+
+	_line_vertices.push_back(vtx);
+}
+
+}

code/graphics/line_draw_list.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "globalincs/pstypes.h"
+#include "2d.h"
+
+namespace graphics {
+
+/**
+ * @brief A class for batching multiple line draw operations together
+ *
+ * This should be used when a lot of lines are going to be rendered together. The actual rendering operation will only
+ * be done once flush() is called so the lines may overlap other objects that were rendered after the line was added to
+ * this class.
+ */
+class line_draw_list {
+	struct line_vertex {
+		vec2d position;
+		vec4 color;
+	};
+	SCP_vector<line_vertex> _line_vertices;
+
+	void add_vertex(int x, int y, int resize_mode, const color* color);
+ public:
+	line_draw_list();
+
+	/**
+	 * @brief Adds a line to this draw list. The coordinates are screen pixel positions.
+	 * @param x1 Start X-Coordinate of the line
+	 * @param y1 Start Y-Coordinate of the line
+	 * @param x2 End X-Coordinate of the line
+	 * @param y2 End Y-Coordinate of the line
+	 * @param resize_mode The resize mode of the screen position
+	 */
+	void add_line(int x1, int y1, int x2, int y2, int resize_mode = GR_RESIZE_FULL);
+
+	/**
+	 * @brief Adds a gradient to this draw list. The coordinates are screen pixel positions.
+	 *
+	 * A gradient is like a normal line but line will fade out towards the end of the line.
+	 *
+	 * @param x1 Start X-Coordinate of the line
+	 * @param y1 Start Y-Coordinate of the line
+	 * @param x2 End X-Coordinate of the line
+	 * @param y2 End Y-Coordinate of the line
+	 * @param resize_mode The resize mode of the screen position
+	 */
+	void add_gradient(int x1, int y1, int x2, int y2, int resize_mode = GR_RESIZE_FULL);
+
+	/**
+	 * @brief Flushes the stored line draws
+	 *
+	 * This will clear al previously drawn line segments so after this is called the instance can be filled with new
+	 * line draws.
+	 */
+	void flush();
+};
+
+}
+

code/graphics/opengl/gropengltnl.cpp

@@ -75,6 +75,7 @@ static opengl_vertex_bind GL_array_binding_data[] =
 		{ vertex_format_data::SCREEN_POS,	2, GL_INT,				GL_FALSE, opengl_vert_attrib::POSITION	},
 		{ vertex_format_data::COLOR3,		3, GL_UNSIGNED_BYTE,	GL_TRUE,opengl_vert_attrib::COLOR		},
 		{ vertex_format_data::COLOR4,		4, GL_UNSIGNED_BYTE,	GL_TRUE, opengl_vert_attrib::COLOR		},
+		{ vertex_format_data::COLOR4F,		4, GL_FLOAT,			GL_FALSE, opengl_vert_attrib::COLOR		},
 		{ vertex_format_data::TEX_COORD2,	2, GL_FLOAT,			GL_FALSE, opengl_vert_attrib::TEXCOORD	},
 		{ vertex_format_data::TEX_COORD3,	3, GL_FLOAT,			GL_FALSE, opengl_vert_attrib::TEXCOORD	},
 		{ vertex_format_data::NORMAL,		3, GL_FLOAT,			GL_FALSE, opengl_vert_attrib::NORMAL	},

code/graphics/paths/NanoVGRenderer.cpp

@@ -19,6 +19,7 @@
 // This code was adapted from the original NanoVG OpenGL renderer to work with the FreeSpace Open graphics API
 
 #include "NanoVGRenderer.h"
+#include "tracing/tracing.h"
 
 namespace {
 using namespace graphics::paths;
@@ -386,7 +387,9 @@ void NanoVGRenderer::renderFlush() {
 		return;
 	}
 
+	TRACE_SCOPE(tracing::NanoVGFlushFrame);
 	GR_DEBUG_SCOPE("NanoVG flush");
+
 	gr_set_viewport(0, 0, gr_screen.max_w, gr_screen.max_h);
 
 	_uniformBuffer = gr_get_uniform_buffer(uniform_block_type::NanoVGData);
@@ -616,6 +619,7 @@ NanoVGRenderer::Image* NanoVGRenderer::getTexture(int id) {
 
 void NanoVGRenderer::drawTriangles(const DrawCall& call) {
 	GR_DEBUG_SCOPE("Draw triangles");
+	TRACE_SCOPE(tracing::NanoVGDrawTriangles);
 
 	auto mat = _trianglesMaterial;
 	materialSetTexture(mat, call.image);
@@ -629,6 +633,7 @@ void NanoVGRenderer::drawTriangles(const DrawCall& call) {
 }
 void NanoVGRenderer::drawFill(const DrawCall& call) {
 	GR_DEBUG_SCOPE("Draw fill");
+	TRACE_SCOPE(tracing::NanoVGDrawFill);
 
 	auto mat = _fillShapeMaterial;
 	mat.set_texture_map(TM_BASE_TYPE, -1);
@@ -672,6 +677,7 @@ void NanoVGRenderer::drawFill(const DrawCall& call) {
 }
 void NanoVGRenderer::drawConvexFill(const DrawCall& call) {
 	GR_DEBUG_SCOPE("Draw convex fill");
+	TRACE_SCOPE(tracing::NanoVGDrawConvexFill);
 
 	auto mat = _triangleFillMaterial;
 	materialSetTexture(mat, call.image);
@@ -704,6 +710,7 @@ void NanoVGRenderer::drawConvexFill(const DrawCall& call) {
 }
 void NanoVGRenderer::drawStroke(const DrawCall& call) {
 	GR_DEBUG_SCOPE("Draw stroke");
+	TRACE_SCOPE(tracing::NanoVGDrawStroke);
 
 	auto mat = _strokeFillMaterial;
 	materialSetTexture(mat, call.image);