Implemented callback and shader recompile, but there is still strange behaviour

The-E · The-E · commit cc876f8bc382 · 2018-03-04T20:14:09.000+01:00
diff --git a/code/graphics/2d.h b/code/graphics/2d.h
@@ -754,7 +754,8 @@ typedef struct screen {
 
 	void (*gf_sphere)(material *material_def, float rad);
 
-	int (*gf_maybe_create_shader)(shader_type type, unsigned int flags);
+	int  (*gf_maybe_create_shader)(shader_type type, unsigned int flags);
+	void (*gf_recompile_all_shaders)(std::function<void(size_t, size_t)>progress_callback);
 
 	void (*gf_clear_states)();
 
@@ -989,6 +990,7 @@ inline void gr_post_process_restore_zbuffer() {
 #define gr_sphere						GR_CALL(*gr_screen.gf_sphere)
 
 #define gr_maybe_create_shader			GR_CALL(*gr_screen.gf_maybe_create_shader)
+#define gr_recompile_all_shaders		GR_CALL(*gr_screen.gf_recompile_all_shaders)
 #define gr_set_animated_effect			GR_CALL(*gr_screen.gf_set_animated_effect)
 
 #define gr_clear_states					GR_CALL(*gr_screen.gf_clear_states)
diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp
@@ -1148,6 +1148,7 @@ void opengl_setup_function_pointers()
 	gr_screen.gf_sphere				= gr_opengl_sphere;
 
 	gr_screen.gf_maybe_create_shader = gr_opengl_maybe_create_shader;
+	gr_screen.gf_recompile_all_shaders = gr_opengl_recompile_all_shaders;
 	gr_screen.gf_shadow_map_start	= gr_opengl_shadow_map_start;
 	gr_screen.gf_shadow_map_end		= gr_opengl_shadow_map_end;
 
diff --git a/code/graphics/opengl/gropenglshader.cpp b/code/graphics/opengl/gropenglshader.cpp
@@ -285,6 +285,17 @@ void opengl_shader_set_current(int handle)
 	opengl_shader_set_current(&GL_shader[handle]);
 }
 
+size_t opengl_get_shader_idx(shader_type shader_t, unsigned int flags) 
+{
+	for (size_t idx = 0; idx < GL_shader.size(); idx++) {
+		if (GL_shader[idx].shader == shader_t && GL_shader[idx].flags == flags) {
+			return idx;
+		}
+	}
+
+	return GL_shader.size();
+}
+
 /**
  * Given a set of flags, determine whether a shader with these flags exists within the GL_shader vector. If no shader with the requested flags exists, attempt to compile one.
  *
@@ -294,14 +305,10 @@ void opengl_shader_set_current(int handle)
  */
 int gr_opengl_maybe_create_shader(shader_type shader_t, unsigned int flags)
 {
-	size_t idx;
-	size_t max = GL_shader.size();
+	size_t idx = opengl_get_shader_idx(shader_t, flags);
 
-	for (idx = 0; idx < max; idx++) {
-		if (GL_shader[idx].shader == shader_t && GL_shader[idx].flags == flags) {
-			return (int)idx;
-		}
-	}
+	if (idx < GL_shader.size())
+		return (int)idx;
 
 	// If we are here, it means we need to compile a new shader
 	return opengl_compile_shader(shader_t, flags);
@@ -313,7 +320,7 @@ void opengl_delete_shader(int sdr_handle)
 	Assert(sdr_handle < (int)GL_shader.size());
 
 	GL_shader[sdr_handle].program.reset();
-
+	
 	GL_shader[sdr_handle].flags = 0;
 	GL_shader[sdr_handle].flags2 = 0;
 	GL_shader[sdr_handle].shader = NUM_SHADER_TYPES;
@@ -636,23 +643,8 @@ static void cache_program_binary(GLuint program, const SCP_string& hash) {
 	cfclose(binary_fp);
 }
 
-/**
- * Compiles a new shader, and creates an opengl_shader_t that will be put into the GL_shader vector
- * if compilation is successful.
- *
- * @param sdr		Identifier defined with the program we wish to compile
- * @param flags		Combination of SDR_* flags
- */
-int opengl_compile_shader(shader_type sdr, uint flags)
+void opengl_compile_shader_actual(shader_type sdr, const uint &flags, opengl_shader_t &new_shader)
 {
-	GR_DEBUG_SCOPE("Creating new shader");
-
-	int sdr_index = -1;
-	int empty_idx;
-	opengl_shader_t new_shader;
-
-	Assert(sdr < NUM_SHADER_TYPES);
-
 	opengl_shader_type_t *sdr_info = &GL_shader_types[sdr];
 
 	Assert(sdr_info->type_id == sdr);
@@ -663,7 +655,7 @@ int opengl_compile_shader(shader_type sdr, uint flags)
 	bool use_geo_sdr = false;
 
 	// do we even have a geometry shader?
-	if ( sdr_info->geo != NULL ) {
+	if (sdr_info->geo != NULL) {
 		for (int i = 0; i < GL_num_shader_variants; ++i) {
 			opengl_shader_variant_t *variant = &GL_shader_variants[i];
 
@@ -697,10 +689,10 @@ int opengl_compile_shader(shader_type sdr, uint flags)
 
 			for (size_t i = 0; i < GL_vertex_attrib_info.size(); ++i) {
 				// Check that the enum values match the position in the vector to make accessing that information more efficient
-				Assertion(GL_vertex_attrib_info[i].attribute_id == (int) i, "Mistmatch between enum values and attribute vector detected!");
+				Assertion(GL_vertex_attrib_info[i].attribute_id == (int)i, "Mistmatch between enum values and attribute vector detected!");
 
 				// assign vert attribute binding locations before we link the shader
-				glBindAttribLocation(program->getShaderHandle(), (GLint) i, GL_vertex_attrib_info[i].name.c_str());
+				glBindAttribLocation(program->getShaderHandle(), (GLint)i, GL_vertex_attrib_info[i].name.c_str());
 			}
 
 			// bind fragment data locations before we link the shader
@@ -716,7 +708,8 @@ int opengl_compile_shader(shader_type sdr, uint flags)
 			}
 
 			program->linkProgram();
-		} catch (const std::exception&) {
+		}
+		catch (const std::exception&) {
 			// Since all shaders are required a compilation failure is a fatal error
 			Error(LOCATION, "A shader failed to compile! Check the debug log for more information.");
 		}
@@ -746,10 +739,10 @@ int opengl_compile_shader(shader_type sdr, uint flags)
 	mprintf(("Shader Variant Features:\n"));
 
 	// initialize all uniforms and attributes that are specific to this variant
-	for ( int i = 0; i < GL_num_shader_variants; ++i ) {
+	for (int i = 0; i < GL_num_shader_variants; ++i) {
 		opengl_shader_variant_t &variant = GL_shader_variants[i];
 
-		if ( sdr_info->type_id == variant.type_id && variant.flag & flags ) {
+		if (sdr_info->type_id == variant.type_id && variant.flag & flags) {
 			for (auto& attr : variant.attributes) {
 				auto& attr_info = GL_vertex_attrib_info[attr];
 				new_shader.program->initAttribute(attr_info.name, attr_info.attribute_id, attr_info.default_value);
@@ -758,14 +751,36 @@ int opengl_compile_shader(shader_type sdr, uint flags)
 			mprintf(("	%s\n", variant.description));
 		}
 	}
+}
+
+/**
+ * Compiles a new shader, and creates an opengl_shader_t that will be put into the GL_shader vector
+ * if compilation is successful.
+ *
+ * @param sdr		Identifier defined with the program we wish to compile
+ * @param flags		Combination of SDR_* flags
+ * @param replacement_idx	The index of the shader this replaces. If -1, the newly compiled shader will be appended to the GL_shader vector
+ *					or inserted at the first available empty slot
+ */
+int opengl_compile_shader(shader_type sdr, uint flags)
+{
+	GR_DEBUG_SCOPE("Creating new shader");
+
+	int sdr_index = -1;
+	int empty_idx;
+	opengl_shader_t new_shader;
+
+	Assert(sdr < NUM_SHADER_TYPES);
+
+	opengl_compile_shader_actual(sdr, flags, new_shader);
 
 	opengl_shader_set_current();
 
 	// add it to our list of embedded shaders
 	// see if we have empty shader slots
 	empty_idx = -1;
-	for ( int i = 0; i < (int)GL_shader.size(); ++i ) {
-		if ( GL_shader[i].shader == NUM_SHADER_TYPES ) {
+	for (int i = 0; i < (int)GL_shader.size(); ++i) {
+		if (GL_shader[i].shader == NUM_SHADER_TYPES) {
 			empty_idx = i;
 			break;
 		}
@@ -783,6 +798,17 @@ int opengl_compile_shader(shader_type sdr, uint flags)
 	return sdr_index;
 }
 
+void gr_opengl_recompile_all_shaders(std::function<void(size_t, size_t)>progress_callback)
+{
+	for (auto sdr = GL_shader.begin(); sdr != GL_shader.end(); ++sdr)
+	{
+		if (progress_callback)
+			progress_callback(std::distance(GL_shader.begin(), sdr), GL_shader.size());
+		sdr->program.reset();
+		opengl_compile_shader_actual(sdr->shader, sdr->flags, *sdr);
+	}
+}
+
 /**
  * Initializes the shader system. Creates a 1x1 texture that can be used as a fallback texture when framebuffer support is missing.
  * Also compiles the shaders used for particle rendering.
diff --git a/code/graphics/opengl/gropenglshader.h b/code/graphics/opengl/gropenglshader.h
@@ -144,6 +144,7 @@ extern SCP_vector<opengl_shader_t> GL_shader;
 extern opengl_shader_t *Current_shader;
 
 int gr_opengl_maybe_create_shader(shader_type shader_t, unsigned int flags);
+void gr_opengl_recompile_all_shaders(std::function<void(size_t, size_t)> progress_callback = nullptr);
 void opengl_delete_shader(int sdr_handle);
 void opengl_shader_set_current(opengl_shader_t *shader_obj = NULL);
 void opengl_shader_set_current(int handle);
diff --git a/code/menuui/optionsmenu.cpp b/code/menuui/optionsmenu.cpp
@@ -1356,12 +1356,26 @@ void options_detail_init()
 	options_detail_synch_sliders();
 }
 
+void shader_recompile_callback(size_t current, size_t total) 
+{
+	SCP_string msg = "";
+	msg += "Recompiling shader ";
+	msg += std::to_string(current);
+	msg += "/";
+	msg += std::to_string(total);
+
+	//popup_change_text(msg.c_str());
+
+	//if (current == total)
+	//	popup_kill_any_active();
+}
+
 void options_detail_sliders_update()
 {
 	int i;
 
-	for ( i = 0; i < NUM_DETAIL_SLIDERS; i++ ) {
-		if ( Detail_sliders[gr_screen.res][i].slider.pos != Detail_slider_pos[i] ) {
+	for (i = 0; i < NUM_DETAIL_SLIDERS; i++) {
+		if (Detail_sliders[gr_screen.res][i].slider.pos != Detail_slider_pos[i]) {
 			Detail_slider_pos[i] = Detail_sliders[gr_screen.res][i].slider.pos;
 			gamesnd_play_iface(SND_USER_SELECT);
 		}
@@ -1374,12 +1388,21 @@ void options_detail_sliders_update()
 	Detail.nebula_detail = Detail_sliders[gr_screen.res][NEBULA_DETAIL_SLIDER].slider.pos;
 	neb2_set_detail_level(Detail.nebula_detail);
 
-	Detail.hardware_textures = Detail_sliders[gr_screen.res][HARDWARE_TEXTURES_SLIDER].slider.pos;	
+	Detail.hardware_textures = Detail_sliders[gr_screen.res][HARDWARE_TEXTURES_SLIDER].slider.pos;
 	Detail.num_small_debris = Detail_sliders[gr_screen.res][SHARD_CULLING_SLIDER].slider.pos;
 	Detail.shield_effects = Detail_sliders[gr_screen.res][SHIELD_DETAIL_SLIDER].slider.pos;
 	Detail.num_stars = Detail_sliders[gr_screen.res][NUM_STARS_SLIDER].slider.pos;
 	Detail.num_particles = Detail_sliders[gr_screen.res][NUM_PARTICLES_SLIDER].slider.pos;
-	Detail.lighting = Detail_sliders[gr_screen.res][LIGHTING_SLIDER].slider.pos;
+
+	// If the new lighting setting is above 3 and the old one was below or the reverse,
+	// we need to recompile all shaders we have to account for the changed lighting model.
+	
+	if (Detail.lighting != Detail_sliders[gr_screen.res][LIGHTING_SLIDER].slider.pos) {
+		Detail.lighting = Detail_sliders[gr_screen.res][LIGHTING_SLIDER].slider.pos;
+		//if (!popup_active())
+		//	popup(PF_BODY_BIG | PF_RUN_STATE, 1, POPUP_OK, "Recompiling shaders...");
+		gr_recompile_all_shaders(shader_recompile_callback);
+	}
 }
 
 void options_detail_hide_stuff()
