Plumb through is_minimum_GLSL_version()

Echelon9 · Echelon9 · commit 5d593f0df078 · 2016-01-03T16:33:04.000-05:00
diff --git a/code/cutscene/oggplayer.cpp b/code/cutscene/oggplayer.cpp
@@ -345,7 +345,7 @@ static void OGG_video_init(theora_info *tinfo)
 		opengl_set_texture_target(GL_TEXTURE_2D);
 		opengl_tcache_get_adjusted_texture_size(g_screenWidth, g_screenHeight, &wp2, &hp2);
 
-		if(!Use_GLSL)
+		if(!is_minimum_GLSL_version())
 			use_shaders = false;
 
 		if(use_shaders) {
diff --git a/code/graphics/2d.cpp b/code/graphics/2d.cpp
@@ -2147,7 +2147,7 @@ uint gr_determine_model_shader_flags(
 ) {
 	uint shader_flags = 0;
 
-	if ( Use_GLSL > 1 ) {
+	if ( Use_GLSL >= 2 ) {
 		shader_flags |= SDR_FLAG_MODEL_CLIP;
 	}
 
diff --git a/code/graphics/gropengl.cpp b/code/graphics/gropengl.cpp
@@ -2015,7 +2015,7 @@ bool gr_opengl_init()
 	GLint max_texture_units = GL_supported_texture_units;
 	GLint max_texture_coords = GL_supported_texture_units;
 
-	if (Use_GLSL) {
+	if (is_minimum_GLSL_version()) {
 		glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_units);
 	}
 
@@ -2095,7 +2095,7 @@ bool gr_opengl_init()
 	mprintf(( "  Post-processing enabled: %s\n", (Cmdline_postprocess) ? "YES" : "NO"));
 	mprintf(( "  Using %s texture filter.\n", (GL_mipmap_filter) ? NOX("trilinear") : NOX("bilinear") ));
 
-	if (Use_GLSL) {
+	if (is_minimum_GLSL_version()) {
 		mprintf(( "  OpenGL Shader Version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION) ));
 	}
 
diff --git a/code/graphics/gropengldraw.cpp b/code/graphics/gropengldraw.cpp
@@ -2546,7 +2546,7 @@ void opengl_setup_scene_textures()
 {
 	Scene_texture_initialized = 0;
 
-	if ( !Use_GLSL || Cmdline_no_fbo || !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {
+	if ( !is_minimum_GLSL_version() || Cmdline_no_fbo || !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {
 		Cmdline_postprocess = 0;
 		Cmdline_softparticles = 0;
 		Cmdline_fb_explosions = 0;
diff --git a/code/graphics/gropenglextension.cpp b/code/graphics/gropenglextension.cpp
@@ -466,7 +466,7 @@ void opengl_extensions_init()
 	}
 
 	// can't have this stuff without GLSL support
-	if ( !Use_GLSL ) {
+	if ( !is_minimum_GLSL_version() ) {
 		Cmdline_normal = 0;
 		Cmdline_height = 0;
 		Cmdline_postprocess = 0;
@@ -480,7 +480,7 @@ void opengl_extensions_init()
 		Cmdline_no_batching = true;
 	}
 
-	if (Use_GLSL) {
+	if (is_minimum_GLSL_version()) {
 		GLint max_texture_units;
 		glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &max_texture_units);
 
@@ -495,7 +495,7 @@ void opengl_extensions_init()
 			Cmdline_height = 0;
 		} else if (max_texture_units < 4) {
 			mprintf(( "Not enough texture units found for GLSL support. We need at least 4, we found %d.\n", max_texture_units ));
-			Use_GLSL = 0;
+			GLSL_version = 0;
 		}
 	}
 }
diff --git a/code/graphics/gropengllight.cpp b/code/graphics/gropengllight.cpp
@@ -118,7 +118,7 @@ void FSLight2GLLight(light *FSLight, opengl_light *GLLight)
 			GLLight->Position[2] = FSLight->vec2.xyz.z;
 			GLLight->Position[3] = 1.0f;
 
-			if ( Use_GLSL > 1 ) {
+			if ( is_minimum_GLSL_version() ) {
 				// Valathil: When using shaders pass the beam direction (not normalized IMPORTANT for calculation of tube)
 				vec3d a;
 				vm_vec_sub(&a, &FSLight->vec2, &FSLight->vec);
@@ -164,7 +164,7 @@ void opengl_set_light(int light_num, opengl_light *ltp)
 	GLfloat diffuse[4];
 	memcpy(diffuse, ltp->Diffuse, sizeof(GLfloat) * 4);
 
-	if ( !Use_GLSL && (ltp->type == LT_DIRECTIONAL) && (GL_light_factor < 1.0f) ) {
+	if ( !is_minimum_GLSL_version() && (ltp->type == LT_DIRECTIONAL) && (GL_light_factor < 1.0f) ) {
 		// if we're not using shaders, manually adjust the diffuse light factor.
 		diffuse[0] *= GL_light_factor;
 		diffuse[1] *= GL_light_factor;
diff --git a/code/graphics/gropenglpostprocessing.cpp b/code/graphics/gropenglpostprocessing.cpp
@@ -970,7 +970,7 @@ void opengl_post_process_init()
 		return;
 	}
 
-	if ( !Use_GLSL || Cmdline_no_fbo || !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {
+	if ( !is_minimum_GLSL_version() || Cmdline_no_fbo || !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {
 		Cmdline_postprocess = 0;
 		return;
 	}
diff --git a/code/graphics/gropenglshader.cpp b/code/graphics/gropenglshader.cpp
@@ -226,7 +226,7 @@ void opengl_shader_set_current(int handle)
  */
 int gr_opengl_maybe_create_shader(shader_type shader_t, unsigned int flags)
 {
-	if (Use_GLSL < 2)
+	if (!is_minimum_GLSL_version())
 		return -1;
 
 	size_t idx;
@@ -268,7 +268,7 @@ void opengl_shader_shutdown()
 {
 	size_t i;
 
-	if ( !Use_GLSL ) {
+	if ( !is_minimum_GLSL_version() ) {
 		return;
 	}
 
@@ -519,7 +519,7 @@ int opengl_compile_shader(shader_type sdr, uint flags)
  */
 void opengl_shader_init()
 {
-	if ( !Use_GLSL ) {
+	if ( !is_minimum_GLSL_version() ) {
 		return;
 	}
 
diff --git a/code/graphics/gropengltnl.cpp b/code/graphics/gropengltnl.cpp
@@ -563,7 +563,7 @@ void gr_opengl_set_buffer(int idx)
 			GL_state.Array.BindElementBuffer(0);
 		}
 
-		if ( (Use_GLSL > 1) && !GLSL_override ) {
+		if ( is_minimum_GLSL_version() && !GLSL_override ) {
 			opengl_shader_set_current();
 		}
 
@@ -1342,7 +1342,7 @@ void gr_opengl_render_buffer(int start, const vertex_buffer *bufferp, int texi,
 
 	const buffer_data *datap = &bufferp->tex_buf[texi];
 
-	if ( (Use_GLSL > 1) && !GLSL_override ) {
+	if ( is_minimum_GLSL_version() && !GLSL_override ) {
 		opengl_render_pipeline_program(start, bufferp, datap, flags);
 	} else {
 		opengl_render_pipeline_fixed(start, bufferp, datap, flags);
@@ -1837,7 +1837,7 @@ void gr_opengl_end_clip_plane()
 		return;
 	}
 
-	if ( Use_GLSL > 1 ) {
+	if ( is_minimum_GLSL_version() ) {
 		return;
 	}
 
@@ -1850,7 +1850,7 @@ void gr_opengl_start_clip_plane()
 		return;
 	}
 
-	if ( Use_GLSL > 1 ) {
+	if ( is_minimum_GLSL_version() ) {
 		// bail since we're gonna clip in the shader
 		return;
 	}
diff --git a/code/lab/lab.cpp b/code/lab/lab.cpp
@@ -1907,8 +1907,6 @@ void labviewer_close_render_options_window(GUIObject *caller)
 	y += cbp->GetHeight() + 1;	\
 }
 
-extern int Use_GLSL;
-
 void labviewer_make_render_options_window(Button *caller)
 {
 	Checkbox *cbp;
@@ -1930,7 +1928,7 @@ void labviewer_make_render_options_window(Button *caller)
 	ADD_RENDER_FLAG("Show Insignia", Lab_viewer_flags, LAB_FLAG_SHOW_INSIGNIA);
 	ADD_RENDER_FLAG("Show Damage Lightning", Lab_viewer_flags, LAB_FLAG_LIGHTNING_ARCS);
 	ADD_RENDER_FLAG("Rotate Subsystems", Lab_viewer_flags, LAB_FLAG_SUBMODEL_ROTATE);
-	if (Use_GLSL) {
+	if (is_minimum_GLSL_version()) {
 		ADD_RENDER_BOOL("Fixed Render Pipeline", GLSL_override);
 		if (Cmdline_postprocess) {
 			ADD_RENDER_BOOL("Hide Post Processing", PostProcessing_override);
diff --git a/code/lighting/lighting.cpp b/code/lighting/lighting.cpp
@@ -340,7 +340,6 @@ void light_add_point_unique(const vec3d *pos, float r1, float r2, float intensit
 }
 
 // beams affect every ship except the firing ship
-extern int Use_GLSL;
 void light_add_tube(const vec3d *p0, const vec3d *p1, float r1, float r2, float intensity, float r, float g, float b, int affected_objnum, float spec_r, float spec_g, float spec_b, bool specular)
 {
 	Assert(r1 >0);
@@ -377,8 +376,8 @@ void light_add_tube(const vec3d *p0, const vec3d *p1, float r1, float r2, float
 	l->radb = r2;
 	l->rada_squared = l->rada*l->rada;
 	l->radb_squared = l->radb*l->radb;
-	l->light_ignore_objnum = Use_GLSL>1 ?affected_objnum : -1;
-	l->affected_objnum = Use_GLSL>1 ? -1 : affected_objnum;
+	l->light_ignore_objnum = is_minimum_GLSL_version() ? affected_objnum : -1;
+	l->affected_objnum = is_minimum_GLSL_version() ? -1 : affected_objnum;
 	l->instance = Num_lights-1;
 
 	Assert( Num_light_levels <= 1 );
@@ -475,7 +474,7 @@ int light_filter_push( int objnum, const vec3d *pos, float rad )
 
 		// hmm. this could probably be more optimal
 		case LT_TUBE:
-			if(Use_GLSL > 1) {
+			if(is_minimum_GLSL_version()) {
 				if(l->light_ignore_objnum != objnum){
 					vec3d nearest;
 					float dist_squared, max_dist_squared;
@@ -1160,7 +1159,7 @@ void scene_lights::setLightFilter(int objnum, const vec3d *pos, float rad)
 			}
 			break;
 			case LT_TUBE: {
-				if ( Use_GLSL > 1 ) {
+				if ( is_minimum_GLSL_version() ) {
 					if ( l.light_ignore_objnum != objnum ) {
 						vec3d nearest;
 						float dist_squared, max_dist_squared;
diff --git a/code/model/modelread.cpp b/code/model/modelread.cpp
@@ -2395,13 +2395,13 @@ void model_load_texture(polymodel *pm, int i, char *file)
 	
 	gr_maybe_create_shader(SDR_TYPE_MODEL, SDR_FLAG_MODEL_SHADOW_MAP);
 
-	if(Use_GLSL > 1)
+	if(is_minimum_GLSL_version())
 		shader_flags |= SDR_FLAG_MODEL_CLIP;
 
 	gr_maybe_create_shader(SDR_TYPE_MODEL, shader_flags | SDR_FLAG_MODEL_LIGHT | SDR_FLAG_MODEL_ANIMATED);
 	gr_maybe_create_shader(SDR_TYPE_MODEL, shader_flags | SDR_FLAG_MODEL_LIGHT | SDR_FLAG_MODEL_ANIMATED | SDR_FLAG_MODEL_FOG);
 	
-	if(Use_GLSL > 1)
+	if(is_minimum_GLSL_version())
 		shader_flags |= SDR_FLAG_MODEL_DEFERRED;
 
 	gr_maybe_create_shader(SDR_TYPE_MODEL, shader_flags | SDR_FLAG_MODEL_LIGHT);
diff --git a/code/model/modelrender.cpp b/code/model/modelrender.cpp
@@ -1194,7 +1194,7 @@ void model_render_buffers(draw_list* scene, model_render_params* interp, vertex_
 		scale.xyz.x = 1.0f;
 		scale.xyz.y = 1.0f;
 
-		if ( Use_GLSL > 1 ) {
+		if ( is_minimum_GLSL_version() ) {
 			scale.xyz.z = 1.0f;
 			scene->set_thrust_scale(interp->get_thruster_info().length.xyz.z);
 		} else {
diff --git a/code/object/object.cpp b/code/object/object.cpp
@@ -94,8 +94,6 @@ char *Object_type_names[MAX_OBJECT_TYPES] = {
 //XSTR:ON
 };
 
-extern int Use_GLSL;
-
 obj_flag_name Object_flag_names[] = {
 	{OF_INVULNERABLE,			"invulnerable",				1,	},
 	{OF_PROTECTED,				"protect-ship",				1,	},
@@ -1205,7 +1203,7 @@ void obj_move_all_post(object *objp, float frametime)
 						b = i2fl(c.blue)/255.0f;
 
 						//light_add_point( &objp->pos, 10.0f, 20.0f, 1.0f, r, g, b, objp->parent );
-						light_add_point( &objp->pos, 10.0f, Use_GLSL>1?100.0f:20.0f, 1.0f, r, g, b, objp->parent );
+						light_add_point( &objp->pos, 10.0f, is_minimum_GLSL_version()?100.0f:20.0f, 1.0f, r, g, b, objp->parent );
 					} else {
 						light_add_point( &objp->pos, 10.0f, 20.0f, 1.0f, 1.0f, 1.0f, 1.0f, objp->parent );
 					} 
diff --git a/code/ship/ship.cpp b/code/ship/ship.cpp
@@ -7079,7 +7079,7 @@ void ship_render_DEPRECATED(object * obj)
 				}
 
 				// Valathil - maybe do a scripting hook here to do some scriptable effects?
-				if(shipp->shader_effect_active && Use_GLSL > 1)
+				if(shipp->shader_effect_active && is_minimum_GLSL_version())
 				{
 					float timer;
 					render_flags |= (MR_DEPRECATED_ANIMATED_SHADER);
@@ -18964,7 +18964,7 @@ int ship_render_get_insignia(object* obj, ship* shipp)
 
 void ship_render_set_animated_effect(model_render_params *render_info, ship *shipp, uint *render_flags)
 {
-	if ( !shipp->shader_effect_active || Use_GLSL <= 1 || Rendering_to_shadow_map ) {
+	if ( !shipp->shader_effect_active || !is_minimum_GLSL_version() || Rendering_to_shadow_map ) {
 		return;
 	}
 
diff --git a/code/weapon/beam.cpp b/code/weapon/beam.cpp
@@ -239,8 +239,6 @@ float beam_get_ship_damage(beam *b, object *objp);
 // if the beam is likely to tool a given target before its lifetime expires
 int beam_will_tool_target(beam *b, object *objp);
 
-extern int Use_GLSL;
-
 // ------------------------------------------------------------------------------------------------
 // BEAM WEAPON FUNCTIONS
 //
@@ -1075,7 +1073,7 @@ void beam_move_all_post()
 		}		
 
 		// add tube light for the beam
-		if(Use_GLSL > 1 && moveup->objp != NULL)
+		if(is_minimum_GLSL_version() && moveup->objp != NULL)
 			beam_add_light(moveup, OBJ_INDEX(moveup->objp), 1, NULL);
 
 		// stop shooting?
@@ -1733,7 +1731,7 @@ void beam_add_light_large(beam *bm, object *objp, vec3d *pt0, vec3d *pt1)
 	float fg = (float)wip->laser_color_1.green / 255.0f;
 	float fb = (float)wip->laser_color_1.blue / 255.0f;
 
-	if ( Use_GLSL > 1 )
+	if ( is_minimum_GLSL_version() )
 		light_add_tube(pt0, pt1, 1.0f, light_rad, 1.0f * noise, fr, fg, fb, OBJ_INDEX(objp)); 
 	else {
 		vec3d near_pt, a;
@@ -1819,7 +1817,7 @@ void beam_apply_lighting()
 		// from a collision
 		case 2:
 			// Valathil: Dont render impact lights for shaders, handled by tube lighting
-			if ( Use_GLSL > 1 ) {
+			if ( is_minimum_GLSL_version() ) {
 				break;
 			}
 			// a few meters from the collision point			
@@ -2613,7 +2611,7 @@ int beam_collide_ship(obj_pair *pair)
 	}
 
 	// add this guy to the lighting list
-	if(Use_GLSL < 2)
+	if(!is_minimum_GLSL_version())
 		beam_add_light(b, OBJ_INDEX(ship_objp), 1, NULL);
 
 	// reset timestamp to timeout immediately
@@ -2710,7 +2708,7 @@ int beam_collide_asteroid(obj_pair *pair)
 	}
 
 	// add this guy to the lighting list
-	if(Use_GLSL < 2)
+	if(!is_minimum_GLSL_version())
 		beam_add_light(b, OBJ_INDEX(pair->b), 1, NULL);
 
 	// reset timestamp to timeout immediately
@@ -2895,7 +2893,7 @@ int beam_collide_debris(obj_pair *pair)
 	}
 
 	// add this guy to the lighting list
-	if(Use_GLSL < 2)
+	if(!is_minimum_GLSL_version())
 		beam_add_light(b, OBJ_INDEX(pair->b), 1, NULL);
 
 	// reset timestamp to timeout immediately
@@ -3100,7 +3098,7 @@ void beam_handle_collisions(beam *b)
 			draw_effects = 0;
 
 		// add lighting
-		if(Use_GLSL < 2)
+		if(!is_minimum_GLSL_version())
 			beam_add_light(b, target, 2, &b->f_collisions[idx].cinfo.hit_point_world);
 
 		// add to the recent collision list

Original file line number	Diff line number	Diff line change
`@@ -2147,7 +2147,7 @@ uint gr_determine_model_shader_flags(`
`2147`	`2147`	`) {`
`2148`	`2148`	`uint shader_flags = 0;`
`2149`	`2149`
`2150`		`- if ( Use_GLSL > 1 ) {`
	`2150`	`+ if ( Use_GLSL >= 2 ) {`
`2151`	`2151`	`shader_flags \|= SDR_FLAG_MODEL_CLIP;`
`2152`	`2152`	`}`
`2153`	`2153`
Original file line number	Diff line number	Diff line change
`@@ -2015,7 +2015,7 @@ bool gr_opengl_init()`
`2015`	`2015`	`GLint max_texture_units = GL_supported_texture_units;`
`2016`	`2016`	`GLint max_texture_coords = GL_supported_texture_units;`
`2017`	`2017`
`2018`		`- if (Use_GLSL) {`
	`2018`	`+ if (is_minimum_GLSL_version()) {`
`2019`	`2019`	`glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_units);`
`2020`	`2020`	`}`
`2021`	`2021`
`@@ -2095,7 +2095,7 @@ bool gr_opengl_init()`
`2095`	`2095`	`mprintf(( " Post-processing enabled: %s\n", (Cmdline_postprocess) ? "YES" : "NO"));`
`2096`	`2096`	`mprintf(( " Using %s texture filter.\n", (GL_mipmap_filter) ? NOX("trilinear") : NOX("bilinear") ));`
`2097`	`2097`
`2098`		`- if (Use_GLSL) {`
	`2098`	`+ if (is_minimum_GLSL_version()) {`
`2099`	`2099`	`mprintf(( " OpenGL Shader Version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION) ));`
`2100`	`2100`	`}`
`2101`	`2101`
Original file line number	Diff line number	Diff line change
`@@ -2546,7 +2546,7 @@ void opengl_setup_scene_textures()`
`2546`	`2546`	`{`
`2547`	`2547`	`Scene_texture_initialized = 0;`
`2548`	`2548`
`2549`		`- if ( !Use_GLSL \|\| Cmdline_no_fbo \|\| !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {`
	`2549`	`+ if ( !is_minimum_GLSL_version() \|\| Cmdline_no_fbo \|\| !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {`
`2550`	`2550`	`Cmdline_postprocess = 0;`
`2551`	`2551`	`Cmdline_softparticles = 0;`
`2552`	`2552`	`Cmdline_fb_explosions = 0;`
Original file line number	Diff line number	Diff line change
`@@ -466,7 +466,7 @@ void opengl_extensions_init()`
`466`	`466`	`}`
`467`	`467`
`468`	`468`	`// can't have this stuff without GLSL support`
`469`		`- if ( !Use_GLSL ) {`
	`469`	`+ if ( !is_minimum_GLSL_version() ) {`
`470`	`470`	`Cmdline_normal = 0;`
`471`	`471`	`Cmdline_height = 0;`
`472`	`472`	`Cmdline_postprocess = 0;`
`@@ -480,7 +480,7 @@ void opengl_extensions_init()`
`480`	`480`	`Cmdline_no_batching = true;`
`481`	`481`	`}`
`482`	`482`
`483`		`- if (Use_GLSL) {`
	`483`	`+ if (is_minimum_GLSL_version()) {`
`484`	`484`	`GLint max_texture_units;`
`485`	`485`	`glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &max_texture_units);`
`486`	`486`
`@@ -495,7 +495,7 @@ void opengl_extensions_init()`
`495`	`495`	`Cmdline_height = 0;`
`496`	`496`	`} else if (max_texture_units < 4) {`
`497`	`497`	`mprintf(( "Not enough texture units found for GLSL support. We need at least 4, we found %d.\n", max_texture_units ));`
`498`		`- Use_GLSL = 0;`
	`498`	`+ GLSL_version = 0;`
`499`	`499`	`}`
`500`	`500`	`}`
`501`	`501`	`}`
Original file line number	Diff line number	Diff line change
`@@ -970,7 +970,7 @@ void opengl_post_process_init()`
`970`	`970`	`return;`
`971`	`971`	`}`
`972`	`972`
`973`		`- if ( !Use_GLSL \|\| Cmdline_no_fbo \|\| !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {`
	`973`	`+ if ( !is_minimum_GLSL_version() \|\| Cmdline_no_fbo \|\| !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) ) {`
`974`	`974`	`Cmdline_postprocess = 0;`
`975`	`975`	`return;`
`976`	`976`	`}`
Original file line number	Diff line number	Diff line change
`@@ -226,7 +226,7 @@ void opengl_shader_set_current(int handle)`
`226`	`226`	`*/`
`227`	`227`	`int gr_opengl_maybe_create_shader(shader_type shader_t, unsigned int flags)`
`228`	`228`	`{`
`229`		`- if (Use_GLSL < 2)`
	`229`	`+ if (!is_minimum_GLSL_version())`
`230`	`230`	`return -1;`
`231`	`231`
`232`	`232`	`size_t idx;`
`@@ -268,7 +268,7 @@ void opengl_shader_shutdown()`
`268`	`268`	`{`
`269`	`269`	`size_t i;`
`270`	`270`
`271`		`- if ( !Use_GLSL ) {`
	`271`	`+ if ( !is_minimum_GLSL_version() ) {`
`272`	`272`	`return;`
`273`	`273`	`}`
`274`	`274`
`@@ -519,7 +519,7 @@ int opengl_compile_shader(shader_type sdr, uint flags)`
`519`	`519`	`*/`
`520`	`520`	`void opengl_shader_init()`
`521`	`521`	`{`
`522`		`- if ( !Use_GLSL ) {`
	`522`	`+ if ( !is_minimum_GLSL_version() ) {`
`523`	`523`	`return;`
`524`	`524`	`}`
`525`	`525`
Original file line number	Diff line number	Diff line change
`@@ -563,7 +563,7 @@ void gr_opengl_set_buffer(int idx)`
`563`	`563`	`GL_state.Array.BindElementBuffer(0);`
`564`	`564`	`}`
`565`	`565`
`566`		`- if ( (Use_GLSL > 1) && !GLSL_override ) {`
	`566`	`+ if ( is_minimum_GLSL_version() && !GLSL_override ) {`
`567`	`567`	`opengl_shader_set_current();`
`568`	`568`	`}`
`569`	`569`
`@@ -1342,7 +1342,7 @@ void gr_opengl_render_buffer(int start, const vertex_buffer *bufferp, int texi,`
`1342`	`1342`
`1343`	`1343`	`const buffer_data *datap = &bufferp->tex_buf[texi];`
`1344`	`1344`
`1345`		`- if ( (Use_GLSL > 1) && !GLSL_override ) {`
	`1345`	`+ if ( is_minimum_GLSL_version() && !GLSL_override ) {`
`1346`	`1346`	`opengl_render_pipeline_program(start, bufferp, datap, flags);`
`1347`	`1347`	`} else {`
`1348`	`1348`	`opengl_render_pipeline_fixed(start, bufferp, datap, flags);`
`@@ -1837,7 +1837,7 @@ void gr_opengl_end_clip_plane()`
`1837`	`1837`	`return;`
`1838`	`1838`	`}`
`1839`	`1839`
`1840`		`- if ( Use_GLSL > 1 ) {`
	`1840`	`+ if ( is_minimum_GLSL_version() ) {`
`1841`	`1841`	`return;`
`1842`	`1842`	`}`
`1843`	`1843`
`@@ -1850,7 +1850,7 @@ void gr_opengl_start_clip_plane()`
`1850`	`1850`	`return;`
`1851`	`1851`	`}`
`1852`	`1852`
`1853`		`- if ( Use_GLSL > 1 ) {`
	`1853`	`+ if ( is_minimum_GLSL_version() ) {`
`1854`	`1854`	`// bail since we're gonna clip in the shader`
`1855`	`1855`	`return;`
`1856`	`1856`	`}`