Instanced Decals (#6813)

* prepare instancing

* Render single decal with instance-like buffer

* encode per-instance data in the instance matrix

* Actually render decals instanced

* Update todo commit

* actually add stubs

* Gate decal preparation behind GPU capability flag

* Fix MSVC warnigns

* remove explicit layout

* Fix MSVC warnigns 2

* Clang Tidy

Author: BMagnu

code/decals/decals.cpp

@@ -370,7 +370,11 @@ void initializeMission() {
 	active_decals.clear();
 }
 
-matrix4 getDecalTransform(Decal& decal) {
+// Discard any fragments where the angle to the direction to greater than 45°
+const float DECAL_ANGLE_CUTOFF = fl_radians(45.f);
+const float DECAL_ANGLE_FADE_START = fl_radians(30.f);
+
+static matrix4 getDecalTransform(Decal& decal, float alpha) {
 	Assertion(decal.object.objp()->type == OBJ_SHIP, "Only ships are currently supported for decals!");
 
 	auto objp = decal.object.objp();
@@ -405,11 +409,17 @@ matrix4 getDecalTransform(Decal& decal) {
 	matrix4 mat4;
 	vm_matrix4_set_transform(&mat4, &worldOrient, &worldPos);
 
+	// This is currently a constant but in the future this may be configurable by the decals table
+	mat4.a2d[0][3] = DECAL_ANGLE_CUTOFF;
+	mat4.a2d[1][3] = DECAL_ANGLE_FADE_START;
+
+	mat4.a2d[2][3] = alpha;
+
 	return mat4;
 }
 
 void renderAll() {
-	if (!Decal_system_active || !Decal_option_active) {
+	if (!Decal_system_active || !Decal_option_active || !gr_is_capable(gr_capability::CAPABILITY_INSTANCED_RENDERING)) {
 		return;
 	}
 
@@ -438,7 +448,7 @@ void renderAll() {
 
 	auto mission_time = f2fl(Missiontime);
 
-	graphics::decal_draw_list draw_list(active_decals.size());
+	graphics::decal_draw_list draw_list;
 	for (auto& decal : active_decals) {
 
 		Assertion(decal.definition_handle >= 0 && decal.definition_handle < (int)DecalDefinitions.size(),
@@ -473,7 +483,7 @@ void renderAll() {
 				+ bm_get_anim_frame(decalDef.getNormalBitmap(), decal_time, 0.0f, decalDef.isNormalLooping());
 		}
 
-		draw_list.add_decal(diffuse_bm, glow_bm, normal_bm, decal_time, getDecalTransform(decal), alpha);
+		draw_list.add_decal(diffuse_bm, glow_bm, normal_bm, decal_time, getDecalTransform(decal, alpha));
 	}
 
 	draw_list.render();

code/def_files/data/effects/decal-f.sdr

@@ -10,6 +10,12 @@ out vec4 fragOut0; // Diffuse buffer
 out vec4 fragOut1; // Normal buffer
 out vec4 fragOut2; // Emissive buffer
 
+in flat mat4 invModelMatrix;
+in flat vec3 decalDirection;
+in flat float normal_angle_cutoff;
+in flat float angle_fade_start;
+in flat float alpha_scale;
+
 uniform sampler2D gDepthBuffer;
 uniform sampler2D gNormalBuffer;
 
@@ -24,23 +30,17 @@ layout (std140) uniform decalGlobalData {
 	mat4 invProjMatrix;
 
 	vec3 ambientLight;
+	float pad0;
 
 	vec2 viewportSize;
 };
-layout (std140) uniform decalInfoData {
-	mat4 model_matrix;
-	mat4 inv_model_matrix;
-
-	vec3 decal_direction;
-	float normal_angle_cutoff;
 
+layout (std140) uniform decalInfoData {
 	int diffuse_index;
 	int glow_index;
 	int normal_index;
-	float angle_fade_start;
-
-	float alpha_scale;
 	int diffuse_blend_mode;
+
 	int glow_blend_mode;
 };
 
@@ -77,7 +77,7 @@ vec3 getPixelNormal(vec3 frag_position, vec2 tex_coord, inout float alpha, out v
 #endif
 
 	//Calculate angle between surface normal and decal direction
-	float angle = acos(dot(normal, decal_direction));
+	float angle = acos(dot(normal, decalDirection));
 
 	if (angle > normal_angle_cutoff) {
 		// The angle between surface normal and decal direction is too big
@@ -91,7 +91,7 @@ vec3 getPixelNormal(vec3 frag_position, vec2 tex_coord, inout float alpha, out v
 }
 
 vec2 getDecalTexCoord(vec3 view_pos, inout float alpha) {
-	vec4 object_pos = inv_model_matrix * invViewMatrix * vec4(view_pos, 1.0);
+	vec4 object_pos = invModelMatrix * invViewMatrix * vec4(view_pos, 1.0);
 
 	bvec3 invalidComponents = greaterThan(abs(object_pos.xyz), vec3(0.5));
 	bvec4 nanComponents = isnan(object_pos); // nan can happen some times if we have an infinite depth value
@@ -111,6 +111,7 @@ void main() {
 	vec3 frag_position = computeViewPosition(gl_FragCoord.xy);
 
 	float alpha = alpha_scale;
+
 	vec2 tex_coord = getDecalTexCoord(frag_position, alpha);
 
 	vec3 binormal;

code/def_files/data/effects/decal-v.sdr

@@ -1,5 +1,12 @@
 
 in vec4 vertPosition;
+in mat4 vertModelMatrix;
+
+out flat mat4 invModelMatrix;
+out flat vec3 decalDirection;
+out flat float normal_angle_cutoff;
+out flat float angle_fade_start;
+out flat float alpha_scale;
 
 layout (std140) uniform decalGlobalData {
 	mat4 viewMatrix;
@@ -8,26 +15,31 @@ layout (std140) uniform decalGlobalData {
 	mat4 invProjMatrix;
 
 	vec3 ambientLight;
+	float pad0;
 
 	vec2 viewportSize;
 };
-layout (std140) uniform decalInfoData {
-	mat4 model_matrix;
-	mat4 inv_model_matrix;
-
-	vec3 decal_direction;
-	float normal_angle_cutoff;
 
+layout (std140) uniform decalInfoData {
 	int diffuse_index;
 	int glow_index;
 	int normal_index;
-	float angle_fade_start;
-
-	float alpha_scale;
 	int diffuse_blend_mode;
+
 	int glow_blend_mode;
 };
 
 void main() {
-	gl_Position = projMatrix * viewMatrix * model_matrix * vertPosition;
+    normal_angle_cutoff = vertModelMatrix[0][3];
+    angle_fade_start = vertModelMatrix[1][3];
+    alpha_scale = vertModelMatrix[2][3];
+
+    mat4 modelMatrix = vertModelMatrix;
+    modelMatrix[0][3] = 0.0;
+    modelMatrix[1][3] = 0.0;
+    modelMatrix[2][3] = 0.0;
+
+    invModelMatrix = inverse(modelMatrix);
+    decalDirection = mat3(viewMatrix) * vec3(modelMatrix[0][2], modelMatrix[1][2], modelMatrix[2][2]);
+	gl_Position = projMatrix * viewMatrix * modelMatrix * vertPosition;
 }

code/graphics/2d.cpp

@@ -79,7 +79,8 @@ gr_capability_def gr_capabilities[] = {
 	GR_CAPABILITY_ENTRY(SEPARATE_BLEND_FUNCTIONS),
 	GR_CAPABILITY_ENTRY(PERSISTENT_BUFFER_MAPPING),
 	gr_capability_def {gr_capability::CAPABILITY_BPTC, "BPTC Texture Compression"}, //This one had a different parse string already!
-	GR_CAPABILITY_ENTRY(LARGE_SHADER)
+	GR_CAPABILITY_ENTRY(LARGE_SHADER),
+	GR_CAPABILITY_ENTRY(INSTANCED_RENDERING),
 };
 
 const size_t gr_capabilities_num = sizeof(gr_capabilities) / sizeof(gr_capabilities[0]);
@@ -3072,7 +3073,7 @@ size_t hash<vertex_layout>::operator()(const vertex_layout& data) const {
 bool vertex_layout::resident_vertex_format(vertex_format_data::vertex_format format_type) const {
 	return ( Vertex_mask & vertex_format_data::mask(format_type) ) ? true : false;
 }
-void vertex_layout::add_vertex_component(vertex_format_data::vertex_format format_type, size_t stride, size_t offset) {
+void vertex_layout::add_vertex_component(vertex_format_data::vertex_format format_type, size_t stride, size_t offset, size_t divisor, size_t buffer_number ) {
 	// A stride value of 0 is not handled consistently by the graphics API so we must enforce that that does not happen
 	Assertion(stride != 0, "The stride of a vertex component may not be zero!");
 
@@ -3081,15 +3082,16 @@ void vertex_layout::add_vertex_component(vertex_format_data::vertex_format forma
 		return;
 	}
 
-	if (Vertex_mask == 0) {
+	auto stride_it = Vertex_stride.find(buffer_number);
+	if (stride_it == Vertex_stride.end()) {
 		// This is the first element so we need to initialize the global stride here
-		Vertex_stride = stride;
+		stride_it = Vertex_stride.emplace(buffer_number, stride).first;
 	}
 
-	Assertion(Vertex_stride == stride, "The strides of all elements must be the same in a vertex layout!");
+	Assertion(stride_it->second == stride, "The strides of all elements must be the same in a vertex layout!");
 
 	Vertex_mask |= (1 << format_type);
-	Vertex_components.push_back(vertex_format_data(format_type, stride, offset));
+	Vertex_components.emplace_back(format_type, stride, offset, divisor, buffer_number);
 }
 bool vertex_layout::operator==(const vertex_layout& other) const {
 	if (Vertex_mask != other.Vertex_mask) {

code/graphics/2d.h

@@ -271,14 +271,17 @@ struct vertex_format_data
 		MODEL_ID,
 		RADIUS,
 		UVEC,
+		MATRIX4,
 	};
 
 	vertex_format format_type;
 	size_t stride;
 	size_t offset;
+	size_t divisor;
+	size_t buffer_number;
 
-	vertex_format_data(vertex_format i_format_type, size_t i_stride, size_t i_offset) :
-	format_type(i_format_type), stride(i_stride), offset(i_offset) {}
+	vertex_format_data(vertex_format i_format_type, size_t i_stride, size_t i_offset, size_t i_divisor, size_t i_buffer_number) :
+	format_type(i_format_type), stride(i_stride), offset(i_offset), divisor(i_divisor), buffer_number(i_buffer_number) {}
 
 	static inline uint mask(vertex_format v_format) { return 1 << v_format; }
 
@@ -291,7 +294,7 @@ class vertex_layout
 	SCP_vector<vertex_format_data> Vertex_components;
 
 	uint Vertex_mask = 0;
-	size_t Vertex_stride = 0;
+	SCP_unordered_map<size_t, size_t> Vertex_stride;
 public:
 	vertex_layout() {}
 
@@ -301,9 +304,9 @@ class vertex_layout
 
 	bool resident_vertex_format(vertex_format_data::vertex_format format_type) const;
 
-	void add_vertex_component(vertex_format_data::vertex_format format_type, size_t stride, size_t offset);
+	void add_vertex_component(vertex_format_data::vertex_format format_type, size_t stride, size_t offset, size_t divisor = 0, size_t buffer_number = 0);
 
-	size_t get_vertex_stride() const { return Vertex_stride; }
+	size_t get_vertex_stride(size_t buffer_number = 0) const { return Vertex_stride.at(buffer_number); }
 
 	bool operator==(const vertex_layout& other) const;
 
@@ -333,7 +336,8 @@ enum class gr_capability {
 	CAPABILITY_SEPARATE_BLEND_FUNCTIONS,
 	CAPABILITY_PERSISTENT_BUFFER_MAPPING,
 	CAPABILITY_BPTC,
-	CAPABILITY_LARGE_SHADER
+	CAPABILITY_LARGE_SHADER,
+	CAPABILITY_INSTANCED_RENDERING
 };
 
 struct gr_capability_def {
@@ -891,7 +895,9 @@ typedef struct screen {
 		primitive_type prim_type,
 		vertex_layout* layout,
 		int num_elements,
-		const indexed_vertex_source& buffers)>
+		const indexed_vertex_source& buffers,
+		const gr_buffer_handle& instance_buffer,
+		int num_instances)>
 		gf_render_decals;
 	void (*gf_render_rocket_primitives)(interface_material* material_info,
 		primitive_type prim_type,