Oh boy, here comes a big one.

Doomreal development is officially back to life.
Doomreal now depends on Doom Tournament, as it's an add-on for it.
Most of the resources are in place right now, just a couple more things left to add in.
Flak cannon is still incomplete and weapon development will be resumed soon.
There is a main menu now, I hope you like it.
Player classes don't have models assigned yet, so they will look weird.
Overall this is not yet very playable.

shaders/glsl/95Bg.fp

@@ -0,0 +1,12 @@
+vec4 ProcessTexel()
+{
+	const vec3 col0 = vec3(.0625,.5,1.);
+	const vec3 col1 = vec3(.5,.0625,.375);
+	vec2 coord = vTexCoord.st+vec2(timer*0.02,0.);
+	coord = fract(coord);
+	float base = getTexel(coord).x;
+	double dist = abs(vTexCoord.s-.5)*2.;
+	vec3 col = mix(col0,col1,vec3(min(1.,dist*1.3)));
+	col = mix(col,vec3(0.),vec3(min(1.,dist)));
+	return vec4(base*col,1.);
+}

shaders/glsl/97Bg.fp

@@ -0,0 +1,23 @@
+vec4 ProcessTexel()
+{
+	vec2 ccoord = vTexCoord.st-vec2(.5);
+	if ( ccoord.y < 0 ) ccoord.x *= -1.;
+	ccoord.y = abs(ccoord.y);
+	vec3 pt = vec3(ccoord.x,ccoord.y-1.,ccoord.y);
+	vec2 proj = pt.xy/pt.z;
+	vec2 coord;
+	vec3 col = vec3(0.);
+	coord = proj*.142536+vec2(-.3,-1.)*timer*.0925436;
+	coord = fract(coord);
+	col += getTexel(coord).rgb;
+	coord = proj*.123234+vec2(0.,-1.)*timer*.092346;
+	coord = fract(coord);
+	col += getTexel(coord).rgb;
+	coord = proj*.145463+vec2(0.3,-1.)*timer*.093242;
+	coord = fract(coord);
+	col += getTexel(coord).rgb;
+	col *= vec3(1.2,.4,.8);
+	col += vec3(.9,.7,1.6)*pow(max(1.2-abs(ccoord.y)*2.4,0.),6.);
+	col = clamp(col,vec3(0.),vec3(1.));
+	return vec4(col,1.);
+}

shaders/glsl/AmbientGlow.fp

@@ -1,12 +0,0 @@
-// imitation of the Unreal Engine 1.x ambient glow effect, timing may be off
-#define PI 3.14159265
-vec4 ProcessLight( vec4 color )
-{
-	float glow = (1.0+sin(timer*2*PI))*0.25;
-	return vec4(min(color.rgb+vec3(glow),1.0),color.a);
-}
-
-vec4 ProcessTexel()
-{
-	return getTexel(vTexCoord.st);
-}

shaders/glsl/AmbientGlow_Brightmapped.fp

@@ -1,15 +0,0 @@
-// imitation of the Unreal Engine 1.x ambient glow effect, timing may be off
-// combining with brightmaps requires the brightmap to be embedded into the
-// alpha channel of the diffuse texture
-#define PI 3.14159265
-vec4 ProcessLight( vec4 color )
-{
-	float bright = getTexel(vTexCoord.st).a;
-	float glow = (1.0+sin(timer*2*PI))*0.25;
-	return vec4(min(color.rgb+vec3(bright)+vec3(glow),1.0),color.a);
-}
-
-vec4 ProcessTexel()
-{
-	return vec4(getTexel(vTexCoord.st).rgb,1.0);
-}

shaders/glsl/Menu2.fp

@@ -0,0 +1,58 @@
+/* https://www.shadertoy.com/view/XslcWn */
+
+// Maximum number of cells a ripple can cross.
+#define MAX_RADIUS 1
+
+// Set to 1 to hash twice. Slower, but less patterns.
+#define DOUBLE_HASH 0
+
+// Hash functions shamefully stolen from:
+// https://www.shadertoy.com/view/4djSRW
+#define HASHSCALE1 .1031
+#define HASHSCALE3 vec3(.1031, .1030, .0973)
+
+float hash12(vec2 p)
+{
+	vec3 p3  = fract(vec3(p.xyx) * HASHSCALE1);
+	p3 += dot(p3, p3.yzx + 19.19);
+	return fract((p3.x + p3.y) * p3.z);
+}
+
+vec2 hash22(vec2 p)
+{
+	vec3 p3 = fract(vec3(p.xyx) * HASHSCALE3);
+	p3 += dot(p3, p3.yzx+19.19);
+	return fract((p3.xx+p3.yz)*p3.zy);
+}
+
+vec4 ProcessTexel()
+{
+	vec2 resolution = vec2(3.,6.);
+	vec2 uv = vTexCoord.st*resolution;
+	vec2 p0 = floor(uv);
+	float circles = 0.;
+	for (int j = -MAX_RADIUS; j <= MAX_RADIUS; ++j)
+	{
+		for (int i = -MAX_RADIUS; i <= MAX_RADIUS; ++i)
+		{
+			vec2 pi = p0 + vec2(i, j);
+			#if DOUBLE_HASH
+			vec2 h = hash22(pi);
+			#else
+			vec2 h = pi;
+			#endif
+			vec2 p = pi + hash22(h);
+			float t = fract(0.3*timer + hash12(h));
+			float d = length(p - uv) - (float(MAX_RADIUS) + 1.)*t;
+			circles += (1. - t) * (1. - t)
+			* mix(sin(31.*d) * 0.5 + 0.5, 1., 0.1)
+			* smoothstep(-0.6, -0.3, d)
+			* smoothstep(0., -0.3, d);
+		}
+	}
+	float intensity = 0.05;
+	vec3 n = vec3(dFdx(circles), dFdy(circles), 0.);
+	n.z = sqrt(1. - dot(n.xy, n.xy));
+	vec3 color = getTexel(uv/resolution - intensity*n.xy).rgb + 5.*pow(clamp(dot(n, normalize(vec3(1., 0.7, 0.5))), 0., 1.), 6.);
+	return vec4(color, 1.0);
+}

shaders/glsl/MenuBarrier.fp

@@ -0,0 +1,52 @@
+/* https://www.shadertoy.com/view/XsXSWS */
+
+vec2 hash( vec2 p )
+{
+	p = vec2( dot(p,vec2(127.1,311.7)),
+			 dot(p,vec2(269.5,183.3)) );
+	return -1.0 + 2.0*fract(sin(p)*43758.5453123);
+}
+
+float noise( in vec2 p )
+{
+	const float K1 = 0.366025404; // (sqrt(3)-1)/2;
+	const float K2 = 0.211324865; // (3-sqrt(3))/6;
+	vec2 i = floor( p + (p.x+p.y)*K1 );
+	vec2 a = p - i + (i.x+i.y)*K2;
+	vec2 o = (a.x>a.y) ? vec2(1.0,0.0) : vec2(0.0,1.0);
+	vec2 b = a - o + K2;
+	vec2 c = a - 1.0 + 2.0*K2;
+	vec3 h = max( 0.5-vec3(dot(a,a), dot(b,b), dot(c,c) ), 0.0 );
+	vec3 n = h*h*h*h*vec3( dot(a,hash(i+0.0)), dot(b,hash(i+o)), dot(c,hash(i+1.0)));
+	return dot( n, vec3(70.0) );
+}
+
+float fbm(vec2 uv)
+{
+	float f;
+	mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
+	f  = 0.5000*noise( uv ); uv = m*uv;
+	f += 0.2500*noise( uv ); uv = m*uv;
+	f += 0.1250*noise( uv ); uv = m*uv;
+	f += 0.0625*noise( uv ); uv = m*uv;
+	f = 0.5 + 0.5*f;
+	return f;
+}
+
+vec4 ProcessTexel()
+{
+	vec2 uv = vTexCoord.st;
+	uv.y = 1.0-uv.y;
+	vec2 q = uv;
+	float strength = 1.5;
+	float T3 = max(1.5,0.5*strength)*timer;
+	q.x = mod(q.x,1.)-0.5;
+	q.y -= 0.2;
+	float n = fbm(strength*q*vec2(4.,1.) - vec2(0,T3));
+	float c = 1. - 15. * pow( max( 0., length(q*vec2(0.45+q.y*1.2,.75) ) - n * max( 0., q.y+.15 ) ),1.5 );
+	float c1 = n * c * (1.5-pow(1.2*uv.y,4.));
+	c1=clamp(c1,0.,1.);
+	vec3 col = vec3(c1*c1*c1, 1.5*c1, c1*c1*c1*c1*c1*c1);
+	float a = clamp(c * (1.-pow(uv.y,3.)),0.,1.);
+	return vec4( mix(vec3(0.),col,a), 1.0);
+}

shaders/glsl/MeshEnviroMap.fp

@@ -1,7 +0,0 @@
-// imitation of the Unreal Engine 1.x bMeshEnviroMap effect, not 1:1 but gets close
-vec4 ProcessTexel()
-{
-	vec3 eyedir = normalize(uCameraPos.xyz-pixelpos.xyz);
-	vec3 norm = reflect(eyedir,normalize(vWorldNormal.xyz));
-	return getTexel(norm.xz*0.5);
-}

shaders/glsl/MeshEnviroMap_AmbientGlow.fp

@@ -1,15 +0,0 @@
-// imitation of the Unreal Engine 1.x ambient glow effect, timing may be off
-#define PI 3.14159265
-vec4 ProcessLight( vec4 color )
-{
-	float glow = (1.0+sin(timer*4*PI))*0.25;
-	return vec4(min(color.rgb+vec3(glow),1.0),color.a);
-}
-
-// imitation of the Unreal Engine 1.x bMeshEnviroMap effect, not 1:1 but gets close
-vec4 ProcessTexel()
-{
-	vec3 eyedir = normalize(uCameraPos.xyz-pixelpos.xyz);
-	vec3 norm = reflect(eyedir,normalize(vWorldNormal.xyz));
-	return getTexel(norm.xz*0.5);
-}

shaders/glsl/UnBg.fp

@@ -0,0 +1,10 @@
+vec4 ProcessTexel()
+{
+	vec2 coord = vTexCoord.st*4.-vec2(0.,timer*0.1);
+	coord = fract(coord);
+	vec3 base = getTexel(coord).rgb;
+	float dist = pow(distance(vec2(.5),vTexCoord.st)*1.4,.5);
+	vec3 col = mix(vec3(1.,.9,.7),vec3(0.),min(1.,dist));
+	col *= 1.-vTexCoord.t*.8;
+	return vec4(base*col,1.);
+}