Use the new shader system in the bsp renderer.

It mostly works. Skybox is untested, and water surfaces are broken.

libs/video/renderer/glsl/Makefile.am

@@ -5,15 +5,15 @@ AM_CPPFLAGS= -I$(top_srcdir)/include $(GLX_CFLAGS)
 
 shader_src= quakeforge.glsl \
 	iqm.frag iqm.vert \
-	quake2d.frag quakebsp.frag quakebsp.vert quakeico.vert quakemdl.frag \
-	quakemdl.vert quakepar.frag quakepar.vert quakepnt.frag quakepnt.vert \
-	quakeskb.frag quakeski.frag quakesky.vert quakespr.frag quakespr.vert \
+	quake2d.frag quakeico.vert \
+	quakepar.frag quakepar.vert quakepnt.frag quakepnt.vert \
+	quakespr.frag quakespr.vert \
 	quaketrb.frag quaketxt.vert
 shader_gen= quakeforge.slc \
 	iqm.fc iqm.vc \
-	quake2d.fc quakebsp.fc quakebsp.vc quakeico.vc quakemdl.fc quakemdl.vc \
-	quakepar.fc quakepar.vc quakepnt.fc quakepnt.vc quakeskb.fc quakeski.fc \
-	quakesky.vc quakespr.fc quakespr.vc quaketrb.fc quaketxt.vc
+	quake2d.fc quakeico.vc \
+	quakepar.fc quakepar.vc quakepnt.fc quakepnt.vc \
+	quakespr.fc quakespr.vc quaketrb.fc quaketxt.vc
 
 glsl_src = \
 	glsl_alias.c glsl_bsp.c glsl_draw.c glsl_fog.c glsl_iqm.c glsl_lightmap.c \

libs/video/renderer/glsl/glsl_alias.c

@@ -58,6 +58,7 @@
 static const char *alias_vert_effects[] =
 {
 	"QuakeForge.Vertex.mdl",
+	0
 };
 
 static const char *alias_frag_effects[] =
@@ -65,6 +66,7 @@ static const char *alias_frag_effects[] =
 	"QuakeForge.Fragment.fog",
 	"QuakeForge.Fragment.colormap",
 	"QuakeForge.Fragment.mdl",
+	0
 };
 
 static struct {

libs/video/renderer/glsl/glsl_bsp.c

@@ -106,29 +106,45 @@ static double   sky_time;
 static quat_t   default_color = { 1, 1, 1, 1 };
 static quat_t   last_color;
 
-static const char quakebsp_vert[] =
-#include "quakebsp.vc"
-;
+static const char *bsp_vert_effects[] =
+{
+	"QuakeForge.Vertex.bsp",
+	0
+};
 
-static const char quakebsp_frag[] =
-#include "quakebsp.fc"
-;
+static const char *bsp_lit_effects[] =
+{
+	"QuakeForge.Fragment.fog",
+	"QuakeForge.Fragment.colormap",
+	"QuakeForge.Fragment.bsp.lit",
+	0
+};
 
-static const char quaketurb_frag[] =
-#include "quaketrb.fc"
-;
+static const char *bsp_turb_effects[] =
+{
+	"QuakeForge.Fragment.fog",
+	"QuakeForge.Fragment.colormap",
+	"QuakeForge.Fragment.bsp.lit",
+	0
+};
 
-static const char quakesky_vert[] =
-#include "quakesky.vc"
-;
+static const char *bsp_sky_cube_effects[] =
+{
+	"QuakeForge.Fragment.fog",
+	"QuakeForge.Fragment.colormap",
+	"QuakeForge.env.sky.cube",
+	"QuakeForge.Fragment.bsp.sky",
+	0
+};
 
-static const char quakeskyid_frag[] =
-#include "quakeski.fc"
-;
-
-static const char quakeskybox_frag[] =
-#include "quakeskb.fc"
-;
+static const char *bsp_sky_id_effects[] =
+{
+	"QuakeForge.Fragment.fog",
+	"QuakeForge.Fragment.colormap",
+	"QuakeForge.env.sky.id",
+	"QuakeForge.Fragment.bsp.sky",
+	0
+};
 
 static struct {
 	int         program;
@@ -159,7 +175,7 @@ static struct {
 	shaderparam_t vertex;
 	shaderparam_t palette;
 	shaderparam_t texture;
-	shaderparam_t realtime;
+	shaderparam_t time;
 	shaderparam_t color;
 	shaderparam_t fog;
 } quake_turb = {
@@ -169,7 +185,7 @@ static struct {
 	{"vertex", 0},
 	{"palette", 1},
 	{"texture", 1},
-	{"realtime", 1},
+	{"time", 1},
 	{"vcolor", 0},
 	{"fog", 1},
 };
@@ -182,7 +198,7 @@ static struct {
 	shaderparam_t palette;
 	shaderparam_t solid;
 	shaderparam_t trans;
-	shaderparam_t realtime;
+	shaderparam_t time;
 	shaderparam_t fog;
 } quake_skyid = {
 	0,
@@ -192,7 +208,7 @@ static struct {
 	{"palette", 1},
 	{"solid", 1},
 	{"trans", 1},
-	{"realtime", 1},
+	{"time", 1},
 	{"fog", 1},
 };
 
@@ -917,7 +933,7 @@ turb_begin (void)
 	qfeglEnable (GL_TEXTURE_2D);
 	qfeglBindTexture (GL_TEXTURE_2D, glsl_palette);
 
-	qfeglUniform1f (quake_turb.realtime.location, vr_data.realtime);
+	qfeglUniform1f (quake_turb.time.location, vr_data.realtime);
 
 	qfeglUniform1i (quake_turb.texture.location, 0);
 	qfeglActiveTexture (GL_TEXTURE0 + 0);
@@ -1001,7 +1017,7 @@ sky_begin (void)
 		qfeglEnable (GL_TEXTURE_2D);
 		qfeglBindTexture (GL_TEXTURE_2D, glsl_palette);
 
-		qfeglUniform1f (quake_skyid.realtime.location, vr_data.realtime);
+		qfeglUniform1f (quake_skyid.time.location, vr_data.realtime);
 
 		qfeglUniform1i (quake_skyid.trans.location, 0);
 		qfeglActiveTexture (GL_TEXTURE0 + 0);
@@ -1241,12 +1257,15 @@ glsl_R_DrawSky (void)
 void
 glsl_R_InitBsp (void)
 {
+	shader_t   *vert_shader, *frag_shader;
 	int         vert;
 	int         frag;
 
-	vert = GLSL_CompileShaderS ("quakebsp.vert", quakebsp_vert,
+	vert_shader = GLSL_BuildShader (bsp_vert_effects);
+	frag_shader = GLSL_BuildShader (bsp_lit_effects);
+	vert = GLSL_CompileShader ("quakebsp.vert", vert_shader,
 							   GL_VERTEX_SHADER);
-	frag = GLSL_CompileShaderS ("quakebsp.frag", quakebsp_frag,
+	frag = GLSL_CompileShader ("quakebsp.frag", frag_shader,
 							   GL_FRAGMENT_SHADER);
 	quake_bsp.program = GLSL_LinkProgram ("quakebsp", vert, frag);
 	GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.mvp_matrix);
@@ -1257,8 +1276,11 @@ glsl_R_InitBsp (void)
 	GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.lightmap);
 	GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.color);
 	GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.fog);
+	GLSL_FreeShader (vert_shader);
+	GLSL_FreeShader (frag_shader);
 
-	frag = GLSL_CompileShaderS ("quaketrb.frag", quaketurb_frag,
+	frag_shader = GLSL_BuildShader (bsp_turb_effects);
+	frag = GLSL_CompileShader ("quaketrb.frag", frag_shader,
 							   GL_FRAGMENT_SHADER);
 	quake_turb.program = GLSL_LinkProgram ("quaketrb", vert, frag);
 	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.mvp_matrix);
@@ -1266,13 +1288,13 @@ glsl_R_InitBsp (void)
 	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.vertex);
 	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.palette);
 	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.texture);
-	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.realtime);
+	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.time);
 	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.color);
 	GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.fog);
+	GLSL_FreeShader (frag_shader);
 
-	vert = GLSL_CompileShaderS ("quakesky.vert", quakesky_vert,
-							   GL_VERTEX_SHADER);
-	frag = GLSL_CompileShaderS ("quakeski.frag", quakeskyid_frag,
+	frag_shader = GLSL_BuildShader (bsp_sky_id_effects);
+	frag = GLSL_CompileShader ("quakeski.frag", frag_shader,
 							   GL_FRAGMENT_SHADER);
 	quake_skyid.program = GLSL_LinkProgram ("quakeskyid", vert, frag);
 	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.mvp_matrix);
@@ -1281,10 +1303,12 @@ glsl_R_InitBsp (void)
 	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.palette);
 	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.solid);
 	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.trans);
-	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.realtime);
+	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.time);
 	GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.fog);
+	GLSL_FreeShader (frag_shader);
 
-	frag = GLSL_CompileShaderS ("quakeskb.frag", quakeskybox_frag,
+	frag_shader = GLSL_BuildShader (bsp_sky_cube_effects);
+	frag = GLSL_CompileShader ("quakeskb.frag", frag_shader,
 							   GL_FRAGMENT_SHADER);
 	quake_skybox.program = GLSL_LinkProgram ("quakeskybox", vert, frag);
 	GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.mvp_matrix);
@@ -1292,6 +1316,7 @@ glsl_R_InitBsp (void)
 	GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.vertex);
 	GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky);
 	GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.fog);
+	GLSL_FreeShader (frag_shader);
 }
 
 static inline int

libs/video/renderer/glsl/quakebsp.vert

@@ -1,18 +0,0 @@
-uniform mat4 mvp_mat;
-
-attribute vec4 vcolor;
-attribute vec4 tlst;
-attribute vec4 vertex;
-
-varying vec2 tst;
-varying vec2 lst;
-varying vec4 color;
-
-void
-main (void)
-{
-	gl_Position = mvp_mat * vertex;
-	tst = tlst.st;
-	lst = tlst.pq;
-	color = vcolor;
-}

libs/video/renderer/glsl/quakeforge.glsl

@@ -64,24 +64,36 @@ turb_st (vec2 st, float time)
 	return st + (sin ((angle + phase) * FACTOR) + BIAS) / SCALE;
 }
 
--- Fragment.skydome
+-- env.sky.cube
+
+uniform samplerCube sky;
+
+vec4
+sky_color (vec3 dir)
+{
+	// NOTE: quake's world and GL's world are rotated relative to each other
+	// quake has x right, y in, z up. gl has x right, y up, z out
+	// The textures are loaded with GL's z (quake's y) already negated, so
+	// all that's needed here is to swizzle y and z.
+	return textureCube(sky, dir.xzy);
+}
+
+-- env.sky.id
 
 uniform sampler2D palette;
 uniform sampler2D solid;
 uniform sampler2D trans;
-uniform float time
-varying vec3 direction
+uniform float time;
 
 const float SCALE = 189.0 / 64.0;
 
 vec4
-skydome (dir, time)
+sky_color (vec3 dir)
 {
 	float       len;
 	float       pix;
 	vec2        flow = vec2 (1.0, 1.0);
 	vec2        st, base;
-	vec3        dir = direction;
 
 	dir.z *= 3.0;
 	len = dot (dir, dir);
@@ -91,13 +103,14 @@ skydome (dir, time)
 	st = base + flow * time / 8.0;
 	pix = texture2D (trans, st).r;
 	if (pix == 0.0) {
-		st = base + flow * realtime / 16.0;
+		st = base + flow * time / 16.0;
 		pix = texture2D (solid, st).r;
 	}
 	return texture2D (palette, pix);
 }
 
 -- Vertex.mdl
+
 uniform mat4 mvp_mat;
 uniform mat3 norm_mat;
 uniform vec2 skin_size;
@@ -125,7 +138,9 @@ main (void)
 	normal = norm_mat * vnormal;
 	color = mix (vcolora, vcolorb, blend);
 }
+
 -- Fragment.mdl
+
 uniform sampler2D skin;
 uniform float ambient;
 uniform float shadelight;
@@ -150,3 +165,58 @@ main (void)
 	lit = mappedColor (pix, light / 255.0);
 	gl_FragColor = fogBlend (lit * color);
 }
+
+-- Vertex.bsp
+
+uniform mat4 mvp_mat;
+uniform mat4 sky_mat;
+
+attribute vec4 vcolor;
+attribute vec4 tlst;
+attribute vec4 vertex;
+
+varying vec2 tst;
+varying vec2 lst;
+varying vec4 color;
+varying vec3 direction;
+
+void
+main (void)
+{
+	gl_Position = mvp_mat * vertex;
+	direction = (sky_mat * vertex).xyz;
+	tst = tlst.st;
+	lst = tlst.pq;
+	color = vcolor;
+}
+
+-- Fragment.bsp.lit
+
+uniform sampler2D texture;
+uniform sampler2D lightmap;
+
+varying vec2 tst;
+varying vec2 lst;
+varying vec4 color;
+
+void
+main (void)
+{
+	float       pix = texture2D (texture, tst).r;
+	float       light = texture2D (lightmap, lst).r;
+	vec4        c;
+
+	c = mappedColor (pix, light * 4.0) * color;
+	gl_FragColor = fogBlend (c);
+}
+
+-- Fragment.bsp.sky
+
+varying vec3 direction;
+
+void
+main (void)
+{
+	vec4        c = sky_color (direction);
+	gl_FragColor = fogBlend (c);
+}

libs/video/renderer/glsl/quakeskb.frag

@@ -1,32 +0,0 @@
-uniform samplerCube sky;
-uniform vec4 fog;
-
-varying vec3 direction;
-
-float
-sqr (float x)
-{
-	return x * x;
-}
-
-vec4
-fogBlend (vec4 color)
-{
-	float       f;
-	vec4        fog_color = vec4 (fog.rgb, 1.0);
-
-	f = exp (-sqr (fog.a * gl_FragCoord.z / gl_FragCoord.w));
-	return vec4 (mix (fog_color.rgb, color.rgb, f), color.a);
-}
-
-void
-main (void)
-{
-	vec3        dir = direction;
-
-	// NOTE: quake's world and GL's world are rotated relative to each other
-	// quake has x right, y in, z up. gl has x right, y up, z out
-	// The textures are loaded with GL's z (quake's y) already negated, so
-	// all that's needed here is to swizzle y and z.
-	gl_FragColor = fogBlend (textureCube(sky, dir.xzy));
-}

libs/video/renderer/glsl/quakeski.frag

@@ -1,48 +0,0 @@
-uniform sampler2D palette;
-uniform sampler2D solid;
-uniform sampler2D trans;
-uniform float realtime;
-uniform vec4 fog;
-
-varying vec3 direction;
-
-const float SCALE = 189.0 / 64.0;
-
-float
-sqr (float x)
-{
-	return x * x;
-}
-
-vec4
-fogBlend (vec4 color)
-{
-	float       f;
-	vec4        fog_color = vec4 (fog.rgb, 1.0);
-
-	f = exp (-sqr (fog.a * gl_FragCoord.z / gl_FragCoord.w));
-	return vec4 (mix (fog_color.rgb, color.rgb, f), color.a);
-}
-
-void
-main (void)
-{
-	float       len;
-	float       pix;
-	vec2        flow = vec2 (1.0, 1.0);
-	vec2        st, base;
-	vec3        dir = direction;
-
-	dir.z *= 3.0;
-	len = dot (dir, dir);
-	len = SCALE * inversesqrt (len);
-
-	base = direction.yx * vec2(1.0, -1.0) * len;
-	st = base + flow * realtime / 8.0;
-	pix = texture2D (trans, st).r;
-	if (pix == 0.0) {
-		st = base + flow * realtime / 16.0;
-		pix = texture2D (solid, st).r;
-	}
-	gl_FragColor = fogBlend (texture2D (palette, vec2 (pix, 0.0)));
-}

libs/video/renderer/glsl/quakesky.vert

@@ -1,14 +0,0 @@
-uniform mat4 mvp_mat;
-uniform mat4 sky_mat;
-
-attribute vec4 tlst;
-attribute vec4 vertex;
-
-varying vec3 direction;
-
-void
-main (void)
-{
-	gl_Position = mvp_mat * vertex;
-	direction = (sky_mat * vertex).xyz;
-}