Minor cleanups, just compiles...

30 files changed, 1641 insertions, 163 deletions

diff --git a/data/glsl.cfg b/data/glsl.cfg
index dac63f2..e058ddd 100644
--- a/data/glsl.cfg
+++ b/data/glsl.cfg
@@ -164,6 +164,69 @@ shader 0 "cubemap" [
 
 //////////////////////////////////////////////////////////////////////
 //
+// fogged variants of default shaders
+//
+//////////////////////////////////////////////////////////////////////
+
+shader 0 "fogged" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    attribute vec2 vtexcoord0;
+    uniform mat4 camprojmatrix;
+    varying vec2 texcoord0;
+    varying vec4 color;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        texcoord0 = vtexcoord0;
+        color = vcolor;
+    }
+] [
+    varying vec2 texcoord0;
+    varying vec4 color;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        gl_FragColor = color * texture2D(tex0, texcoord0);
+    }
+]
+
+shader 0 "foggednotexture" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    uniform mat4 camprojmatrix;
+    varying vec4 color;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+    }
+] [
+    varying vec4 color;
+    void main(void)
+    {
+        gl_FragColor = color;
+    }
+]
+
+shader 0 "fogoverlay" [
+    attribute vec4 vvertex, vcolor;
+    varying vec4 color;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        color = vcolor;
+    }
+] [
+    varying vec4 color;
+    void main(void)
+    {
+        gl_FragColor = color;
+    }
+]
+
+//////////////////////////////////////////////////////////////////////
+//
 // for filling the z-buffer only (i.e. multi-pass rendering, OQ)
 //
 //////////////////////////////////////////////////////////////////////
@@ -243,6 +306,36 @@ worldshader = [
     ]
 ]
 
+glareworldshader = [
+    variantshader (if (< (strstr $arg1 "env") 0) 4 6) $arg1 4 [
+        //:fog
+        @(if (>= $numargs 4) [result $arg4])
+        attribute vec4 vvertex;
+        attribute vec3 vnormal;
+        attribute vec2 vtexcoord0, vtexcoord1;
+        uniform mat4 camprojmatrix;
+        uniform vec2 texgenscroll;
+        varying vec2 texcoord0, texcoord1;
+        void main(void)
+        {
+            gl_Position = camprojmatrix * vvertex;
+            texcoord0 = vtexcoord0 + texgenscroll;
+            texcoord1 = vtexcoord1 * @lmcoordscale;
+
+            @arg2
+        }
+    ] [
+        @(if (>= $numargs 4) [result $arg4])
+        @(if (>= $numargs 5) [result $arg5])
+        uniform vec4 colorparams;
+        varying vec2 texcoord0, texcoord1;
+        void main(void)
+        {
+            @arg3
+        }
+    ]
+]
+
 worldshader "stdworld" [] []
 worldshader "alphaworld" [] []
 
@@ -253,6 +346,89 @@ defershader 0 "decalworld" [
   ] [] [] [uniform sampler2D decal;]
 ]
 
+glowshader = [
+  defershader 0 $arg1 [
+    defuniformparam "glowcolor" 1 1 1 // glow color
+    worldshader @arg1 [] [] [
+      vec3 glow = texture2D(glowmap, texcoord0).rgb;
+      glow *= glowcolor.rgb;
+      gl_FragColor = diffuse*lm + vec4(glow, 0.0);
+    ] [] [uniform sampler2D glowmap;]
+    glareworldshader @arg1 [] [
+      vec3 glow = texture2D(glowmap, texcoord0).rgb;
+      glow *= glowcolor.rgb;
+      float k = max(glow.r, max(glow.g, glow.b));
+      gl_FragColor.rgb = min(k*k*32.0, 1.0) * glow;
+      gl_FragColor.a =
+          //:variantoverride texture2D(lightmap, texcoord1).a
+          colorparams.a
+          ;
+    ] [] [
+      uniform sampler2D glowmap;
+      //:variant uniform sampler2D lightmap;
+    ]
+  ]
+]
+glowshader "glowworld"
+glowshader "glowalphaworld"
+
+defershader 0 "pulseworld" [
+  defuniformparam "pulsespeed" 1 // pulse frequency (Hz)
+  worldshader "pulseworld" [
+    pulse = abs(fract(millis * pulsespeed.x)*2.0 - 1.0);
+  ] [
+    vec3 diffuse2 = texture2D(decal, texcoord0).rgb;
+    diffuse.rgb = mix(diffuse.rgb, diffuse2, pulse);
+  ] [] [uniform float millis; varying float pulse;] [uniform sampler2D decal;]
+]
+
+pulseglowshader = [
+  defershader 0 $arg1 [
+    defuniformparam "glowcolor" 1 1 1 // glow color
+    defuniformparam "pulseglowspeed" 1 // pulse frequency (Hz)
+    defuniformparam "pulseglowcolor" 0 0 0 // pulse glow color
+    worldshader @arg1 [
+      pulse = mix(glowcolor.rgb, pulseglowcolor.rgb, abs(fract(millis * pulseglowspeed.x)*2.0 - 1.0));
+    ] [] [
+      vec3 glow = texture2D(glowmap, texcoord0).rgb;
+      gl_FragColor = diffuse*lm + vec4(glow*pulse, 0.0);
+    ] [uniform float millis; varying vec3 pulse;] [uniform sampler2D glowmap;]
+    glareworldshader @arg1 [
+      pulse = mix(glowcolor.rgb, pulseglowcolor.rgb, abs(fract(millis * pulseglowspeed.x)*2.0 - 1.0));
+    ] [
+      vec3 glow = texture2D(glowmap, texcoord0).rgb;
+      glow *= pulse;
+      float k = max(glow.r, max(glow.g, glow.b));
+      gl_FragColor.rgb = min(k*k*32.0, 1.0) * glow;
+      gl_FragColor.a =
+          //:variantoverride texture2D(lightmap, texcoord1).a
+          colorparams.a
+          ;
+    ] [uniform float millis; varying vec3 pulse;] [
+      uniform sampler2D glowmap;
+      //:variant uniform sampler2D lightmap;
+    ]
+  ]
+]
+pulseglowshader "pulseglowworld"
+pulseglowshader "pulseglowalphaworld"
+
+shader 0 "fogworld" [
+    //:water
+    attribute vec4 vvertex;
+    uniform mat4 camprojmatrix;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+    }
+] [
+    uniform vec3 fogcolor;
+    void main(void)
+    {
+        gl_FragColor = vec4(fogcolor, 1.0);
+    }
+]
+
 shader 0 "noglareworld" [
     attribute vec4 vvertex;
     uniform mat4 camprojmatrix;
@@ -304,12 +480,90 @@ shader 0 "noglarealphaworld" [
     }
 ]
 
+defershader 2 "envworld" [
+  defuniformparam "envscale" 0.2 0.2 0.2 // reflectivity
+  worldshader "envworld" [
+    normal = vnormal;
+    camvec = camera - vvertex.xyz;
+  ] [
+    vec3 reflect = textureCube(envmap, 2.0*normal*dot(camvec, normal) - camvec).rgb;
+  ] [
+    diffuse *= lm;
+    gl_FragColor.rgb = mix(diffuse.rgb, reflect, envscale.rgb);
+    gl_FragColor.a = diffuse.a;
+  ] [uniform vec3 camera; varying vec3 normal, camvec;] [uniform samplerCube envmap;]
+
+  defuniformparam "envscale" 0.2 0.2 0.2 // reflectivity
+  worldshader "envworldfast" [
+    vec3 camvec = camera - vvertex.xyz;
+    rvec = 2.0*vnormal*dot(camvec, vnormal) - camvec;
+  ] [
+    vec3 reflect = textureCube(envmap, rvec).rgb;
+  ] [
+    diffuse *= lm;
+    gl_FragColor.rgb = mix(diffuse.rgb, reflect, envscale.rgb);
+    gl_FragColor.a = diffuse.a;
+  ] [uniform vec3 camera; varying vec3 rvec;] [uniform samplerCube envmap;]
+
+  defuniformparam "envscale" 0.2 0.2 0.2 // reflectivity
+  worldshader "envworldalt" [] []
+
+  altshader envworld envworldalt
+  fastshader envworld envworldfast 2
+  fastshader envworld envworldalt 1
+]
+
+shader 0 "depthfxworld" [
+    attribute vec4 vvertex;
+    uniform mat4 camprojmatrix;
+    uniform vec4 depthscale, depthoffsets;
+    varying vec4 depthranges;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        depthranges = depthoffsets + gl_Position.w*depthscale;
+    }
+] [
+    varying vec4 depthranges;
+    void main(void)
+    {
+        gl_FragColor = depthranges;
+    }
+]
+
+shader 0 depthfxsplitworld [
+    attribute vec4 vvertex;
+    uniform mat4 camprojmatrix;
+    uniform vec4 depthscale, depthoffsets;
+    varying vec4 depthranges;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        depthranges = depthoffsets + gl_Position.w*depthscale;
+    }
+] [
+    varying vec4 depthranges;
+    void main(void)
+    {
+        vec4 ranges = vec4(depthranges.x, fract(depthranges.yzw));
+        ranges.xy -= ranges.yz*vec2(0.00390625, 0.00390625);
+        gl_FragColor = ranges;
+    }
+]
+
 // bumptype:
+//    e -> reserve envmap texture slot
 //    o -> orthonormalize
 //    t -> tangent space cam
+//    r -> envmap reflection
+//    R -> modulate envmap reflection with spec map
 //    s -> spec
 //    S -> spec map
 //    p -> parallax
+//    P -> steep parallax (7 steps)
+//    g -> glow
+//    G -> pulse glow
+//    i -> glare intensity
 //    a -> alpha map
 
 btopt = [ >= (strstr $bumptype $arg1) 0 ]
@@ -318,6 +572,13 @@ bumpvariantshader = [
     bumptype = $arg2
     stype = (? (btopt "e") 3 1)
     if (! (btopt "i")) [
+        if (btopt "G") [
+            defuniformparam "glowcolor" 1 1 1 // glow color
+            defuniformparam "pulseglowspeed" 1     // pulse frequency (Hz)
+            defuniformparam "pulseglowcolor" 0 0 0 // pulse glow color
+        ] [if (btopt "g") [
+            defuniformparam "glowcolor" 1 1 1  // glow color
+        ]]
         if (btopt "S") [
             defuniformparam "specscale" 6 6 6 // spec map multiplier
         ] [if (btopt "s") [
@@ -326,6 +587,11 @@ bumpvariantshader = [
         if (|| (btopt "p") (btopt "P")) [
             defuniformparam "parallaxscale" 0.06 -0.03 // parallax scaling
         ]
+        if (btopt "R") [
+            defuniformparam "envscale" 1 1 1 // reflectivity map multiplier
+        ] [if (btopt "r") [
+            defuniformparam "envscale" 0.2 0.2 0.2 // reflectivity
+        ]]
     ] [
         if (btopt "s") [stype = (+ $stype 8)]
     ]
@@ -338,6 +604,9 @@ bumpvariantshader = [
         uniform mat4 camprojmatrix;
         uniform vec2 texgenscroll;
         varying vec2 texcoord0, texcoord1;
+        @(if (|| (btopt "t") (btopt "r")) [result [uniform vec3 camera; varying vec3 camvec;]])
+        @(if (btopt "G") [result [uniform float millis; varying float pulse;]])
+        @(if (btopt "r") [result [varying mat3 world;]])
         void main(void)
         {
             gl_Position = camprojmatrix * vvertex;
@@ -360,6 +629,10 @@ bumpvariantshader = [
                 ]])
             ]])
 
+            @(if (btopt "G") [result [
+                pulse = abs(fract(millis*pulseglowspeed.x)*2.0 - 1.0);
+            ]])
+
             @(if (|| (! (btopt "i")) (btopt "s")) [result [
                 //:dynlight
             ]])
@@ -373,6 +646,11 @@ bumpvariantshader = [
         varying vec2 texcoord0, texcoord1;
         uniform sampler2D diffusemap, lmcolor, lmdir;
         @(if (|| (! (btopt "i")) (btopt "s") (btopt "p") (btopt "P")) [result [uniform sampler2D normalmap;]])
+        @(if (|| (btopt "t") (btopt "r")) [result [varying vec3 camvec;]])
+        @(if (btopt "g") [result [uniform sampler2D glowmap;]])
+        @(if (btopt "G") [result [varying float pulse;]])
+        @(if (btopt "r") [result [uniform samplerCube envmap; varying mat3 world;]])
+        @(if (|| (! (btopt "i")) (btopt "s")) [result [uniform vec4 ambient;]])
         void main(void)
         {
             @(if (|| (! (btopt "i")) (btopt "s")) [result [
@@ -399,6 +677,28 @@ bumpvariantshader = [
             ]])
             @(if (|| (btopt "p") (btopt "P")) [] [result [#define dtc texcoord0]])
 
+            @(if (|| (! (btopt "i")) (btopt "S") (btopt "a")) [result [
+                vec4 diffuse = texture2D(diffusemap, dtc);
+                @(if (&& (btopt "a") (! (btopt "S"))) [result [
+                    #define alpha diffuse.a
+                ]])
+            ]])
+            @(if (! (btopt "i")) [result [
+                diffuse.rgb *= colorparams.rgb;
+            ]])
+            @(if (|| (! (btopt "i")) (btopt "s") (btopt "a")) [result [
+                @(if (! (btopt "P")) [
+                    if (&& (btopt "a") (btopt "S")) [result [
+                        vec4 normal = texture2D(normalmap, dtc);
+                        #define alpha normal.a
+                        #define bump normal.rgb
+                    ]] [result [
+                        vec3 bump = texture2D(normalmap, dtc).rgb;
+                    ]]
+                ])
+                bump = bump*2.0 - 1.0;
+            ]])
+
             @(if (btopt "s") [result [
                 vec3 halfangle = normalize(camdir + lmlv);
                 float spec = pow(clamp(dot(halfangle, bump), 0.0, 1.0), @(? (btopt "i") "128.0" "32.0"));
@@ -411,6 +711,65 @@ bumpvariantshader = [
                 ]])
             ]])
 
+            @(if (|| (! (btopt "i")) (btopt "s")) [result [
+                lmc.rgb = max(lmc.rgb*clamp(dot(lmlv, bump), 0.0, 1.0), ambient.xyz);
+                @(if (btopt "i") [result [
+                    //:dynlight lmc
+
+                    @(? (btopt "g") "diffuse.rgb" "gl_FragColor.rgb") = diffuse.rgb * lmc.rgb;
+                ]] [result [
+                    //:shadowmap lmc
+                    //:dynlight lmc
+
+                    @(? (|| (btopt "g") (btopt "r")) "diffuse.rgb" "gl_FragColor.rgb") = diffuse.rgb * lmc.rgb;
+                ]])
+            ]])
+
+            @(if (btopt "r") [result [
+                vec3 rvec;
+                @(if (btopt "t") [result [
+                    vec3 rvects = 2.0*bump*dot(camvec, bump) - camvec;
+                    rvec = world * rvects;
+                ]] [result [
+                    vec3 bumpw = world * bump;
+                    rvec = 2.0*bumpw*dot(camvec, bumpw) - camvec;
+                ]])
+                vec3 reflect = textureCube(envmap, rvec).rgb;
+                @@(if (btopt "R") [result [
+                    vec3 rmod = envscale.xyz*diffuse.a;
+                ]] [result [
+                    #define rmod envscale.xyz
+                ]])
+                @(? (btopt "g") "diffuse.rgb" "gl_FragColor.rgb") = mix(diffuse.rgb, reflect, rmod);
+            ]])
+
+            @(if (btopt "a") [result [
+                @(? (btopt "g") "diffuse.rgb" "gl_FragColor.rgb") *= alpha;
+            ]])
+
+            @(if (btopt "g") [result [
+                vec3 glow = texture2D(glowmap, dtc).rgb;
+                @@(if (btopt "G") [result [
+                    vec3 pulsecol = mix(glowcolor.xyz, pulseglowcolor.xyz, pulse);
+                ]])
+                @@(if (btopt "i") [result [
+                    glow *= @(? (btopt "G") "pulsecol" "glowcolor.xyz");
+                    float k = max(glow.r, max(glow.g, glow.b));
+                    k = min(k*k*32.0, 1.0);
+                    @(if (btopt "s") [result [
+                        gl_FragColor.rgb = glow*k + diffuse.rgb;
+                    ]] [result [
+                        gl_FragColor.rgb = glow*k;
+                        gl_FragColor.a =
+                            //:variantoverride texture2D(lmcolor, texcoord1).a
+                            colorparams.a
+                            ;
+                    ]])
+                ]] [result [
+                    gl_FragColor.rgb = glow * @(? (btopt "G") "pulsecol" "glowcolor.xyz") + diffuse.rgb;
+                ]])
+            ]])
+
             @(if (btopt "a") [result [
                 gl_FragColor.a *= alpha;
                 //:fog fogcolor * alpha
@@ -444,6 +803,20 @@ bumpshader "bumpspecmapalphaworld" "otsSa"
 fastshader bumpspecmapalphaworld bumpalphaworld 1
 altshader bumpspecmapalphaworld bumpalphaworld
 
+bumpshader "bumpglowworld" "g"
+bumpshader "bumpspecglowworld" "otsg"
+altshader bumpspecglowworld bumpglowworld
+bumpshader "bumpspecmapglowworld" "otsSg"
+fastshader bumpspecmapglowworld bumpglowworld 2
+altshader bumpspecmapglowworld bumpglowworld
+
+bumpshader "bumppulseglowworld" "gG"
+bumpshader "bumpspecpulseglowworld" "otsgG"
+altshader bumpspecpulseglowworld bumppulseglowworld
+bumpshader "bumpspecmappulseglowworld" "otsSgG"
+fastshader bumpspecmappulseglowworld bumppulseglowworld 2
+altshader bumpspecmappulseglowworld bumppulseglowworld
+
 bumpshader "bumpparallaxworld" "pot"
 fastshader bumpparallaxworld bumpworld 1
 altshader bumpparallaxworld bumpworld
@@ -456,6 +829,30 @@ fastshader bumpspecmapparallaxworld bumpparallaxworld 2
 fastshader bumpspecmapparallaxworld bumpworld 1
 altshader bumpspecmapparallaxworld bumpworld
 
+bumpshader "bumpparallaxglowworld" "potg"
+fastshader bumpparallaxglowworld bumpglowworld 1
+altshader bumpparallaxglowworld bumpglowworld
+bumpshader "bumpspecparallaxglowworld" "potsg"
+fastshader bumpspecparallaxglowworld bumpparallaxglowworld 2
+fastshader bumpspecparallaxglowworld bumpglowworld 1
+altshader bumpspecparallaxglowworld bumpglowworld
+bumpshader "bumpspecmapparallaxglowworld" "potsSg"
+fastshader bumpspecmapparallaxglowworld bumpparallaxglowworld 2
+fastshader bumpspecmapparallaxglowworld bumpglowworld 1
+altshader bumpspecmapparallaxglowworld bumpglowworld
+
+bumpshader "bumpparallaxpulseglowworld" "potgG"
+fastshader bumpparallaxpulseglowworld bumppulseglowworld 1
+altshader bumpparallaxpulseglowworld bumppulseglowworld
+bumpshader "bumpspecparallaxpulseglowworld" "potsgG"
+fastshader bumpspecparallaxpulseglowworld bumpparallaxpulseglowworld 2
+fastshader bumpspecparallaxpulseglowworld bumppulseglowworld 1
+altshader bumpspecparallaxpulseglowworld bumppulseglowworld
+bumpshader "bumpspecmapparallaxpulseglowworld" "potsSgG"
+fastshader bumpspecmapparallaxpulseglowworld bumpparallaxpulseglowworld 2
+fastshader bumpspecmapparallaxpulseglowworld bumppulseglowworld 1
+altshader bumpspecmapparallaxpulseglowworld bumppulseglowworld
+
 bumpshader "bumpenvworldalt" "e"
 bumpshader "bumpenvworld" "eor"
 altshader bumpenvworld bumpenvworldalt
@@ -467,6 +864,28 @@ bumpshader "bumpenvspecmapworld" "eotsSrR"
 altshader bumpenvspecmapworld bumpenvworldalt
 fastshader bumpenvspecmapworld bumpenvworldalt 2
 
+bumpshader "bumpenvglowworldalt" "eg"
+bumpshader "bumpenvglowworld" "eorg"
+altshader bumpenvglowworld bumpenvglowworldalt
+fastshader bumpenvglowworld bumpenvglowworldalt 2
+bumpshader "bumpenvspecglowworld" "eotsrg"
+altshader bumpenvspecglowworld bumpenvglowworldalt
+fastshader bumpenvspecglowworld bumpenvglowworldalt 2
+bumpshader "bumpenvspecmapglowworld" "eotsSrRg"
+altshader bumpenvspecmapglowworld bumpenvglowworldalt
+fastshader bumpenvspecmapglowworld bumpenvglowworldalt 2
+
+bumpshader "bumpenvpulseglowworldalt" "egG"
+bumpshader "bumpenvpulseglowworld" "eorgG"
+altshader bumpenvpulseglowworld bumpenvpulseglowworldalt
+fastshader bumpenvpulseglowworld bumpenvpulseglowworldalt 2
+bumpshader "bumpenvspecpulseglowworld" "eotsrgG"
+altshader bumpenvspecpulseglowworld bumpenvpulseglowworldalt
+fastshader bumpenvspecpulseglowworld bumpenvpulseglowworldalt 2
+bumpshader "bumpenvspecmappulseglowworld" "eotsSrRgG"
+altshader bumpenvspecmappulseglowworld bumpenvpulseglowworldalt
+fastshader bumpenvspecmappulseglowworld bumpenvpulseglowworldalt 2
+
 bumpshader "bumpenvparallaxworldalt" "epot"
 altshader bumpenvparallaxworldalt bumpenvworldalt
 bumpshader "bumpenvparallaxworld" "epotr"
@@ -482,6 +901,38 @@ altshader bumpenvspecmapparallaxworld bumpenvparallaxworldalt
 fastshader bumpenvspecmapparallaxworld bumpenvparallaxworldalt 2
 fastshader bumpenvspecmapparallaxworld bumpenvworldalt 1
 
+bumpshader "bumpenvparallaxglowworldalt" "epotg"
+altshader bumpenvparallaxglowworldalt bumpenvglowworldalt
+bumpshader "bumpenvparallaxglowworld" "epotrg"
+altshader bumpenvparallaxglowworld bumpenvparallaxglowworldalt
+fastshader bumpenvparallaxglowworld bumpenvparallaxglowworldalt 2
+fastshader bumpenvparallaxglowworld bumpenvglowworldalt 1
+bumpshader "bumpenvspecparallaxglowworld" "epotsrg"
+altshader bumpenvspecparallaxglowworld bumpenvparallaxglowworldalt
+fastshader bumpenvspecparallaxglowworld bumpenvparallaxglowworldalt 2
+fastshader bumpenvspecparallaxglowworld bumpenvglowworldalt 1
+bumpshader "bumpenvspecmapparallaxglowworld" "epotsSrRg"
+altshader bumpenvspecmapparallaxglowworld bumpenvparallaxglowworldalt
+fastshader bumpenvspecmapparallaxglowworld bumpenvparallaxglowworldalt 2
+fastshader bumpenvspecmapparallaxglowworld bumpenvglowworldalt 1
+
+bumpshader "bumpenvparallaxpulseglowworldalt" "epotgG"
+altshader bumpenvparallaxpulseglowworldalt bumpenvpulseglowworldalt
+bumpshader "bumpenvparallaxpulseglowworld" "epotrgG"
+altshader bumpenvparallaxpulseglowworld bumpenvparallaxpulseglowpulseglowworldalt
+fastshader bumpenvparallaxpulseglowworld bumpenvparallaxpulseglowpulseglowworldalt 2
+fastshader bumpenvparallaxpulseglowworld bumpenvpulseglowworldalt 1
+bumpshader "bumpenvspecparallaxpulseglowworld" "epotsrgG"
+altshader bumpenvspecparallaxpulseglowworld bumpenvparallaxpulseglowworldalt
+fastshader bumpenvspecparallaxpulseglowworld bumpenvparallaxpulseglowworldalt 2
+fastshader bumpenvspecparallaxpulseglowworld bumpenvpulseglowworldalt 1
+bumpshader "bumpenvspecmapparallaxpulseglowworld" "epotsSrRgG"
+altshader bumpenvspecmapparallaxpulseglowworld bumpenvparallaxpulseglowworldalt
+fastshader bumpenvspecmapparallaxpulseglowworld bumpenvparallaxpulseglowworldalt 2
+fastshader bumpenvspecmapparallaxpulseglowworld bumpenvpulseglowworldalt 1
+
+//bumpshader "steepworld" "Pot"
+
 ////////////////////////////////////////////////
 //
 // model shaders
@@ -631,12 +1082,14 @@ loop i 4 [
 ]
 
 // mdltype:
+//    e -> envmap
 //    n -> normalmap
 //    s -> spec
 //    m -> masks
 //    b -> dual-quat skeletal animation
 //    a -> alpha-tested
 //    q -> qtangents
+//    i -> glare intensity
 
 mdlopt = [ >= (strstr $modeltype $arg1) 0 ]
 
@@ -671,6 +1124,7 @@ modelvertexshader = [
             ]])
             @(if (mdlopt "e") [result [
                 uniform mat3 modelworld;
+                uniform vec2 envmapscale;
                 varying vec3 rvec;
                 varying float rmod;
             ]])
@@ -728,6 +1182,7 @@ modelvertexshader = [
                 @(if (mdlopt "e") [result [
                     float invfresnel = dot(camdir, mnormal);
                     rvec = modelworld * (2.0*invfresnel*mnormal - camdir);
+                    rmod = envmapscale.x*max(invfresnel, 0.0) + envmapscale.y;
                 ]])
             ]])
         }
@@ -743,6 +1198,7 @@ modelfragmentshader = [
             @(if (mdlopt "e") [result [
                 #define lightvec lightdirworld
                 uniform vec3 lightdirworld;
+                uniform vec2 envmapscale;
                 varying vec3 camvec;
                 varying mat3 world;
             ]] [result [
@@ -777,6 +1233,11 @@ modelfragmentshader = [
 
             light.rgb *= 2.0;
 
+            @(if (mdlopt "m") [result [
+                vec3 masks = texture2D(tex1, texcoord0).rgb;
+                vec3 glow = light.rgb * maskscale.y;
+            ]])
+
             @(if (mdlopt "n") [result [
                 vec3 normal = texture2D(tex3, texcoord0).rgb - 0.5;
                 @(if (mdlopt "e") [result [
@@ -824,6 +1285,7 @@ modelfragmentshader = [
                     vec3 camn = normalize(camvec);
                     float invfresnel = dot(camn, normal);
                     vec3 rvec = 2.0*invfresnel*normal - camn;
+                    float rmod = envmapscale.x*max(invfresnel, 0.0) + envmapscale.y;
                 ]])
                 vec3 reflect = textureCube(tex2, rvec).rgb;
                 @(if (! (mdlopt "m")) [result [
@@ -831,6 +1293,18 @@ modelfragmentshader = [
                 ]])
             ]])
 
+            @(if (mdlopt "m") [result [
+                @(if (mdlopt "e") [result [
+                    light.rgb = mix(light.rgb, glow, masks.g); // glow mask in green channel
+                    gl_FragColor.rgb = mix(light.rgb, reflect, rmod*masks.b); // envmap mask in blue channel
+                ]] [if (mdlopt "i") [result [
+                    float k = min(masks.g*masks.g*maskscale.w, 1.0); // glow mask in green channel
+                    gl_FragColor.rgb = @(? (mdlopt "s") "glow*k + light.rgb" "glow*k");
+                ]] [result [
+                    gl_FragColor.rgb = mix(light.rgb, glow, masks.g); // glow mask in green channel
+                ]]])
+            ]])
+
             @(if (|| (mdlopt "i") (mdlopt "m") (mdlopt "e")) [result [
                 gl_FragColor.a = light.a * color.a;
             ]])
@@ -846,6 +1320,12 @@ modelshader = [
         loop i 4 [
             variantshader 0 $shadername 0 (modelvertexshader (concatword $arg1 "b") (+ $i 1)) []
         ]
+        glaremodeltype = (strreplace (concatword $arg1 "i") "e")
+        if (< (strstr $glaremodeltype "s") 0) [glaremodeltype = (strreplace $glaremodeltype "n")]
+        variantshader 0 $shadername 1 (modelvertexshader $glaremodeltype) (modelfragmentshader $glaremodeltype)
+        loop i 4 [
+            variantshader 0 $shadername 1 (modelvertexshader (concatword $glaremodeltype "b") (+ $i 1)) 1
+        ]
         if (>= (strstr $arg1 "e") 0) [
             altshader $shadername (modelshader (strreplace $arg1 "e"))
         ]
@@ -927,6 +1407,131 @@ loop i 7 [
     ]
 ]
 
+////////////////////////////////////////////////
+//
+// full screen shaders:
+//
+////////////////////////////////////////////////
+
+fsvs = [result [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    uniform vec2 postfxscale;
+    varying vec2 texcoord0;
+    @arg2
+    void main(void)
+    {
+        gl_Position = vvertex;   // woohoo, no mvp :)
+        texcoord0 = vtexcoord0;
+        @arg1
+    }
+]]
+
+fsps = [result [
+    uniform sampler2D tex0;
+    varying vec2 texcoord0;
+    @arg2
+    void main(void)
+    {
+        vec4 color = texture2D(tex0, texcoord0);
+        @arg1
+    }
+]]
+
+fsvs4 = [
+    fsvs [
+        texcoord1 = vtexcoord0 + vec2(-1.5, -1.5)*postfxscale;
+        texcoord2 = vtexcoord0 + vec2( 1.5, -1.5)*postfxscale;
+        texcoord3 = vtexcoord0 + vec2(-1.5,  1.5)*postfxscale;
+        texcoord4 = vtexcoord0 + vec2( 1.5,  1.5)*postfxscale;
+        @arg1
+    ] [
+        varying vec2 texcoord1, texcoord2, texcoord3, texcoord4;
+    ]
+]
+
+fsps4 = [
+    fsps [
+        vec4 s00 = texture2D(tex0, texcoord1);
+        vec4 s02 = texture2D(tex0, texcoord2);
+        vec4 s20 = texture2D(tex0, texcoord3);
+        vec4 s22 = texture2D(tex0, texcoord4);
+        @arg1
+    ] [
+        varying vec2 texcoord1, texcoord2, texcoord3, texcoord4;
+    ]
+]
+
+// some simple ones that just do an effect on the RGB value...
+
+lazyshader 0 "invert" (fsvs) (fsps [gl_FragColor = 1.0 - color;])
+lazyshader 0 "gbr"    (fsvs) (fsps [gl_FragColor = color.yzxw;])
+lazyshader 0 "bw"     (fsvs) (fsps [gl_FragColor = vec4(dot(color.xyz, vec3(0.333)));])
+
+// sobel
+
+lazyshader 0 "sobel" (fsvs4) (fsps4 [
+    vec4 t = s00 + s20 - s02 - s22;
+    vec4 u = s00 + s02 - s20 - s22;
+    gl_FragColor = color + t*t + u*u;
+])
+
+// rotoscope
+
+lazyshader 0 "rotoscope" [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    uniform vec2 postfxscale;
+    uniform vec4 params;
+    varying vec2 t11, t00, t12, t01, t20, t02, t21, t10, t22;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        t11 = vtexcoord0;
+        vec2 scale = postfxscale*params.x;
+        t00 = vec2(-1.0, -1.0)*scale + vtexcoord0;
+        t12 = vec2( 0.0,  1.0)*scale + vtexcoord0;
+        t01 = vec2(-1.0,  0.0)*scale + vtexcoord0;
+        t20 = vec2( 1.0, -1.0)*scale + vtexcoord0;
+        t02 = vec2(-1.0,  1.0)*scale + vtexcoord0;
+        t21 = vec2( 1.0,  0.0)*scale + vtexcoord0;
+        t10 = vec2( 0.0, -1.0)*scale + vtexcoord0;
+        t22 = vec2( 1.0,  1.0)*scale + vtexcoord0;
+    }
+] [
+    uniform sampler2D tex0;
+    varying vec2 t11, t00, t12, t01, t20, t02, t21, t10, t22;
+    void main(void)
+    {
+        vec4 c00 = texture2D(tex0, t00);
+        vec4 c01 = texture2D(tex0, t01);
+        vec4 c02 = texture2D(tex0, t02);
+        vec4 c10 = texture2D(tex0, t10);
+        vec4 c11 = texture2D(tex0, t11);
+        vec4 c12 = texture2D(tex0, t12);
+        vec4 c20 = texture2D(tex0, t20);
+        vec4 c21 = texture2D(tex0, t21);
+        vec4 c22 = texture2D(tex0, t22);
+
+        vec4 diag1 = c00 - c22;
+        vec4 diag2 = c02 - c20;
+        vec4 xedge = (c01 - c21)*2.0 + diag1 + diag2;
+        vec4 yedge = (c10 - c12)*2.0 + diag1 - diag2;
+        xedge *= xedge;
+        yedge *= yedge;
+
+        vec4 xyedge = xedge + yedge;
+        float sobel = step(max(xyedge.x, max(xyedge.y, xyedge.z)), 0.1);
+
+        float hue = dot(c11.xyz, vec3(1.0));
+        c11 /= hue;
+        vec3 cc = step(vec3(0.2, 0.8, 1.5), vec3(hue));
+        c11 *= dot(cc, vec3(0.5, 0.5, 1.5));
+
+        gl_FragColor = c11 * max(cc.z, sobel);
+    }
+]
+
 blur3shader = [
     lazyshader 0 $arg1 [
         attribute vec4 vvertex;
@@ -976,6 +1581,96 @@ blur5shader = [
 blur5shader hblur5 1 0
 blur5shader vblur5 0 1
 
+rotoscope = [
+    clearpostfx
+    if (>= $numargs 1) [addpostfx rotoscope 0 0 0 $arg1]
+    if (>= $numargs 2) [
+        if (= $arg2 1) [addpostfx hblur3; addpostfx vblur3]
+        if (= $arg2 2) [addpostfx hblur5; addpostfx vblur5]
+    ]
+]
+
+shader 0 "screenrect" [
+    attribute vec4 vvertex, vcolor;
+    @(screentexcoord 0)
+    varying vec2 texcoord0;
+    varying vec4 color;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        texcoord0 = vtexcoord0;
+        color = vcolor;
+    }
+] [
+    varying vec2 texcoord0;
+    varying vec4 color;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        gl_FragColor = color * texture2D(tex0, texcoord0);
+    }
+]
+
+// bloom-ish
+
+lazyshader 0 "bloom_scale" (fsvs4) (fsps4 [
+    gl_FragColor = 0.2 * (s02 + s00 + s22 + s20 + color);
+])
+
+lazyshader 0 "bloom_init" (fsvs) (fsps [
+    float t = max(color.r, max(color.g, color.b));
+    gl_FragColor = t*t*color;
+])
+
+bloomshader = [
+  defershader 0 $arg1 [
+    forceshader "bloom_scale"
+    forceshader "bloom_init"
+    shader 0 @arg1 [
+        attribute vec4 vvertex;
+        @(screentexcoord 0)
+        varying vec2 texcoord0;
+        void main(void)
+        {
+            gl_Position = vvertex;
+            texcoord0 = vtexcoord0;
+        }
+    ] [
+        uniform vec4 params;
+        varying vec2 texcoord0;
+        uniform sampler2D tex0 @@(loopconcat i $arg2 [result [, tex@(+ $i 1)]]);
+        void main(void)
+        {
+            vec4 sample = texture2D(tex0, texcoord0);
+            @@(loopconcat i $arg2 [result [
+                @(? $i "bloom +=" "vec4 bloom =") texture2D(tex@(+ $i 1), texcoord0);
+            ]])
+            gl_FragColor = bloom*params.x + sample;
+        }
+    ]
+  ]
+]
+
+bloomshader bloom1 1
+bloomshader bloom2 2
+bloomshader bloom3 3
+bloomshader bloom4 4
+bloomshader bloom5 5
+bloomshader bloom6 6
+
+setupbloom = [
+    addpostfx bloom_init 1 1 "+0"
+    loop i (- $arg1 1) [
+        addpostfx bloom_scale (+ $i 2) (+ $i 2) (concatword "+" (+ $i 1))
+    ]
+    addpostfx (concatword bloom $arg1) 0 0 (loopconcat i (+ $arg1 1) [result $i]) $arg2
+]
+
+bloom = [
+    clearpostfx
+    if (>= $numargs 1) [setupbloom 6 $arg1]
+]
+
 ////////////////////////////////////////////////
 //
 // miscellaneous effect shaders:
@@ -1031,6 +1726,15 @@ explosionshader = [
             vec2 dtc = texcoord0 + texture2D(tex0, texcoord2).xy*0.1; // use color texture as noise to distort texcoords
             vec4 diffuse = texture2D(tex0, dtc);
             float blend = max(pow(clamp(1.0 - dot(texcoord1, texcoord1), 0.0, 1.0), blendparams.x), blendparams.y);
+            @(if (>= (strstr $arg1 "glare") 0) [result [
+                float k = blend*blend;
+                diffuse.rgb *= k*8.0;
+                diffuse.a *= k;
+                diffuse.b += k*k;
+            ]] [result [
+                diffuse *= blend*4.0; // dup alpha into RGB channels + intensify and over saturate
+                diffuse.b += 0.5 - blend*0.5; // blue tint
+            ]])
 
             @(if (>= (strstr $arg1 "soft") 0) [result [
                 gl_FragColor.rgb = diffuse.rgb * color.rgb;
@@ -1049,7 +1753,7 @@ explosionshader = [
     ]
 ]
 
-looplist i ["" "soft" "soft8"] [
+looplist i ["" "glare" "soft" "soft8"] [
     explosionshader [explosion@i]
 ]
 
@@ -1127,6 +1831,28 @@ looplist i ["" "soft" "soft8"] [
     particleshader [particle@i]
 ]
 
+shader 0 "blendbrush" [
+    attribute vec4 vvertex, vcolor;
+    uniform mat4 camprojmatrix;
+    uniform vec4 texgenS, texgenT;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        texcoord0 = vec2(dot(texgenS, vvertex), dot(texgenT, vvertex));
+    }
+] [
+    varying vec4 color;
+    varying vec2 texcoord0;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        gl_FragColor = texture2D(tex0, texcoord0).r * color;
+    }
+]
+
 lazyshader 0 "prefab" [
     attribute vec4 vvertex, vcolor;
     attribute vec3 vnormal;
@@ -1148,6 +1874,752 @@ lazyshader 0 "prefab" [
     }
 ]
 
+lazyshader 0 "moviergb" [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        texcoord0 = vtexcoord0;
+    }
+] [
+    varying vec2 texcoord0;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        gl_FragColor = texture2D(tex0, texcoord0);
+    }
+]
+
+lazyshader 0 "movieyuv" [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        texcoord0 = vtexcoord0;
+    }
+] [
+    varying vec2 texcoord0;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        vec3 sample = texture2D(tex0, texcoord0).rgb;
+        gl_FragColor = vec4(dot(sample, vec3(0.439216, -0.367788, -0.071427)) + 0.501961,
+                            dot(sample, vec3(-0.148224, -0.290992, 0.439216)) + 0.501961,
+                            dot(sample, vec3(0.256788, 0.504125, 0.097905)) + 0.062745,
+                            0.0);
+    }
+]
+
+lazyshader 0 "moviey" [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    uniform vec2 moviescale;
+    varying vec2 texcoord0, texcoord1, texcoord2, texcoord3;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        texcoord0 = vtexcoord0 + vec2(-1.5, 0.0)*moviescale;
+        texcoord1 = vtexcoord0 + vec2(-0.5, 0.0)*moviescale;
+        texcoord2 = vtexcoord0 + vec2( 0.5, 0.0)*moviescale;
+        texcoord3 = vtexcoord0 + vec2( 1.5, 0.0)*moviescale;
+    }
+] [
+    varying vec2 texcoord0, texcoord1, texcoord2, texcoord3;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        vec3 sample1 = texture2D(tex0, texcoord0).rgb;
+        vec3 sample2 = texture2D(tex0, texcoord1).rgb;
+        vec3 sample3 = texture2D(tex0, texcoord2).rgb;
+        vec3 sample4 = texture2D(tex0, texcoord3).rgb;
+        gl_FragColor = vec4(dot(sample3, vec3(0.256788, 0.504125, 0.097905)) + 0.062745,
+                            dot(sample2, vec3(0.256788, 0.504125, 0.097905)) + 0.062745,
+                            dot(sample1, vec3(0.256788, 0.504125, 0.097905)) + 0.062745,
+                            dot(sample4, vec3(0.256788, 0.504125, 0.097905)) + 0.062745);
+    }
+]
+
+lazyshader 0 "movieu" [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    uniform vec2 moviescale;
+    varying vec2 texcoord0, texcoord1, texcoord2, texcoord3;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        texcoord0 = vtexcoord0 + vec2(-3.0, 0.0)*moviescale;
+        texcoord1 = vtexcoord0 + vec2(-1.0, 0.0)*moviescale;
+        texcoord2 = vtexcoord0 + vec2( 1.0, 0.0)*moviescale;
+        texcoord3 = vtexcoord0 + vec2( 3.0, 0.0)*moviescale;
+    }
+] [
+    varying vec2 texcoord0, texcoord1, texcoord2, texcoord3;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        vec3 sample1 = texture2D(tex0, texcoord0).rgb;
+        vec3 sample2 = texture2D(tex0, texcoord1).rgb;
+        vec3 sample3 = texture2D(tex0, texcoord2).rgb;
+        vec3 sample4 = texture2D(tex0, texcoord3).rgb;
+        gl_FragColor = vec4(dot(sample3, vec3(-0.148224, -0.290992, 0.43921)) + 0.501961,
+                            dot(sample2, vec3(-0.148224, -0.290992, 0.43921)) + 0.501961,
+                            dot(sample1, vec3(-0.148224, -0.290992, 0.43921)) + 0.501961,
+                            dot(sample4, vec3(-0.148224, -0.290992, 0.43921)) + 0.501961);
+    }
+]
+
+lazyshader 0 "moviev" [
+    attribute vec4 vvertex;
+    @(screentexcoord 0)
+    uniform vec2 moviescale;
+    varying vec2 texcoord0, texcoord1, texcoord2, texcoord3;
+    void main(void)
+    {
+        gl_Position = vvertex;
+        texcoord0 = vtexcoord0 + vec2(-3.0, 0.0)*moviescale;
+        texcoord1 = vtexcoord0 + vec2(-1.0, 0.0)*moviescale;
+        texcoord2 = vtexcoord0 + vec2( 1.0, 0.0)*moviescale;
+        texcoord3 = vtexcoord0 + vec2( 3.0, 0.0)*moviescale;
+    }
+] [
+    varying vec2 texcoord0, texcoord1, texcoord2, texcoord3;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        vec3 sample1 = texture2D(tex0, texcoord0).rgb;
+        vec3 sample2 = texture2D(tex0, texcoord1).rgb;
+        vec3 sample3 = texture2D(tex0, texcoord2).rgb;
+        vec3 sample4 = texture2D(tex0, texcoord3).rgb;
+        gl_FragColor = vec4(dot(sample3, vec3(0.439216, -0.367788, -0.071427)) + 0.501961,
+                            dot(sample2, vec3(0.439216, -0.367788, -0.071427)) + 0.501961,
+                            dot(sample1, vec3(0.439216, -0.367788, -0.071427)) + 0.501961,
+                            dot(sample4, vec3(0.439216, -0.367788, -0.071427)) + 0.501961);
+    }
+]
+
+///////////////////////////////////////////////////
+//
+// reflective/refractive water shaders:
+//
+///////////////////////////////////////////////////
+
+watershader = [
+    specular = $arg2
+    rgbfog = $arg3
+    distort = $arg4
+    combine = $arg5
+    lazyshader 0 $arg1 [
+        attribute vec4 vvertex;
+        attribute vec3 vcolor;
+        uniform mat4 camprojmatrix;
+        uniform vec3 camera;
+        uniform mat4 watermatrix;
+        uniform float waterheight;
+        uniform float millis;
+        @(if $specular [result [uniform vec3 lightpos; varying vec3 lightdir;]])
+        varying vec3 camdir, color;
+        varying vec4 texcoord0;
+        varying vec2 texcoord1, texcoord2;
+        void main(void)
+        {
+            gl_Position = camprojmatrix * vvertex;
+            color = vcolor;
+            texcoord0 = watermatrix * vvertex;
+            @(if (>= (strstr $arg1 "underwater") 0) [result [
+                texcoord0.z = waterheight - vvertex.z;
+            ]] [result [
+                texcoord0.z = vvertex.z - waterheight;
+            ]])
+            vec2 tc = vvertex.xy * 0.02;
+            texcoord1 = tc + millis*0.05;
+            texcoord2 = tc - millis*0.03;
+            camdir = camera - vvertex.xyz;
+            @(if $specular [result [
+                lightdir = lightpos - vvertex.xyz;
+            ]])
+        }
+    ] [
+        @(if $rgbfog [result [
+            //:fog
+        ]] [result [
+            //:fogrgba vec4(vec3(0.0), 1.0)
+        ]])
+        uniform vec2 depth;
+        @(if $specular [result [uniform vec3 lightcolor; uniform float lightradius; varying vec3 lightdir;]])
+        varying vec3 camdir, color;
+        varying vec4 texcoord0;
+        varying vec2 texcoord1, texcoord2;
+        @(if (>= (strstr $arg1 "env") 0) [result [
+            uniform samplerCube tex0;
+        ]] [result [
+            uniform sampler2D tex0;
+        ]])
+        uniform sampler2D tex1, tex2, tex3;
+        void main(void)
+        {
+            vec3 camvec = normalize(camdir);
+            @(if $specular [result [
+                vec3 lightvec = normalize(lightdir);
+                vec3 halfangle = normalize(camvec + lightvec);
+            ]])
+
+            vec2 dudv = texture2D(tex2, texcoord1).xy*2.0 - 1.0;
+
+            @distort
+
+            @(if $specular [result [
+                float spec = pow(clamp(dot(halfangle, bump), 0.0, 1.0), 96.0);
+                vec3 light = lightcolor * (1.0 - clamp(length(lightdir)/lightradius, 0.0, 1.0));
+            ]])
+
+            @combine
+        }
+    ]
+]
+
+watershader "waterglare" 1 1 [
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    gl_FragColor = vec4(light*spec*spec*32.0, 0.0);
+]
+lazyshader 0 "waterglarefast" [
+    //:fog
+    attribute vec4 vvertex;
+    uniform mat4 camprojmatrix;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+    }
+] [
+    void main(void)
+    {
+        gl_FragColor = vec4(0.0);
+    }
+]
+fastshader waterglare waterglarefast 2
+altshader waterglare waterglarefast
+
+lazyshader 0 "underwater" [
+    attribute vec4 vvertex;
+    attribute vec3 vcolor;
+    uniform mat4 camprojmatrix;
+    varying vec3 color;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+    }
+] [
+    //:fogrgba vec4(vec3(0.0), 1.0)
+    uniform vec2 depth;
+    varying vec3 color;
+    void main(void)
+    {
+        gl_FragColor.rgb = 0.8*depth.x*color;
+        gl_FragColor.a = 0.5*depth.y;
+    }
+]
+
+watershader "underwaterrefract" 0 1 [
+    dudv = texture2D(tex2, texcoord2 + 0.025*dudv).xy*2.0 - 1.0;
+
+    gl_FragColor = texture2D(tex3, texcoord0.xy/texcoord0.w + 0.007*dudv);
+] []
+watershader "underwaterrefractfast" 0 1 [
+    gl_FragColor = texture2DProj(tex3, texcoord0 + vec4(0.3*dudv, 0.0, 0.0));
+] []
+fastshader underwaterrefract underwaterrefractfast 2
+altshader underwaterrefract underwaterrefractfast
+
+watershader "underwaterfade" 0 1 [
+    dudv = texture2D(tex2, texcoord2 + 0.025*dudv).xy*2.0 - 1.0;
+
+    vec2 projtc = texcoord0.xy/texcoord0.w;
+    float fade = texcoord0.z + 4.0*texture2D(tex3, projtc).a;
+    gl_FragColor.a = fade * clamp(gl_FragCoord.z, 0.0, 1.0);
+    gl_FragColor.rgb = texture2D(tex3, projtc + 0.007*dudv).rgb;
+] []
+watershader "underwaterfadefast" 0 1 [
+    gl_FragColor.rgb = texture2DProj(tex3, texcoord0 + vec4(0.3*dudv, 0.0, 0.0)).rgb;
+    gl_FragColor.a = texcoord0.z + 4.0*texture2DProj(tex3, texcoord0).a;
+] []
+fastshader underwaterfade underwaterfadefast 2
+altshader underwaterfade underwaterfadefast
+
+watershader "water" 1 0 [
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor.rgb = color*depth.x*mix(0.6, 1.0, invfresnel*0.5+0.5) + spec*light;
+    gl_FragColor.a = invfresnel*depth.y;
+]
+watershader "waterfast" 0 0 [
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor.rgb = color*depth.x*mix(0.6, 1.0, invfresnel*0.5+0.5);
+    gl_FragColor.a = invfresnel*depth.y;
+]
+fastshader water waterfast 1
+altshader water waterfast
+
+watershader "waterreflect" 1 0 [
+    vec3 reflect = texture2DProj(tex0, texcoord0 + vec4(0.3*dudv, 0.0, 0.0)).rgb;
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor.rgb = mix(reflect, color*depth.x, invfresnel*0.5+0.5) + spec*light;
+    gl_FragColor.a = invfresnel*depth.y;
+]
+watershader "waterreflectfast" 0 0 [
+    vec3 reflect = texture2DProj(tex0, texcoord0 + vec4(0.3*dudv, 0.0, 0.0)).rgb;
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor.rgb = mix(reflect, color*depth.x, invfresnel*0.5+0.5);
+    gl_FragColor.a = invfresnel*depth.y;
+]
+fastshader waterreflect waterreflectfast 2
+altshader waterreflect waterreflectfast
+
+watershader "waterrefract" 1 1 [
+    vec2 dtc = texcoord2 + 0.025*dudv;
+    vec3 bump = texture2D(tex1, dtc).rgb*2.0 - 1.0;
+    dudv = texture2D(tex2, dtc).xy*2.0 - 1.0;
+
+    vec2 rtc = texcoord0.xy/texcoord0.w + 0.007*dudv;
+    vec3 reflect = texture2D(tex0, rtc).rgb;
+    vec3 refract = texture2D(tex3, rtc).rgb;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor = vec4(mix(reflect, refract, invfresnel*0.5+0.5) + spec*light, 0.0);
+]
+watershader "waterrefractfast" 0 1 [
+    vec4 rtc = texcoord0 + vec4(0.3*dudv, 0.0, 0.0);
+    vec3 reflect = texture2DProj(tex0, rtc).rgb;
+    vec3 refract = texture2DProj(tex3, rtc).rgb;
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor = vec4(mix(reflect, refract, invfresnel*0.5+0.5), 0.0);
+]
+fastshader waterrefract waterrefractfast 2
+altshader waterrefract waterrefractfast
+
+watershader "waterfade" 1 1 [
+    vec2 dtc = texcoord2 + 0.025*dudv;
+    vec3 bump = texture2D(tex1, dtc).rgb*2.0 - 1.0;
+    dudv = texture2D(tex2, dtc).xy*2.0 - 1.0;
+
+    vec2 projtc = texcoord0.xy/texcoord0.w;
+    vec2 rtc = projtc + 0.007*dudv;
+    vec3 reflect = texture2D(tex0, rtc).rgb;
+    vec3 refract = texture2D(tex3, rtc).rgb;
+    float fade = texcoord0.z + 4.0*texture2D(tex3, projtc).a;
+    gl_FragColor.a = fade * clamp(gl_FragCoord.z, 0.0, 1.0);
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor.rgb = mix(reflect, refract, invfresnel*0.5+0.5) + spec*light;
+]
+watershader "waterfadefast" 0 1 [
+    vec4 rtc = texcoord0 + vec4(0.3*dudv, 0.0, 0.0);
+    vec3 reflect = texture2DProj(tex0, rtc).rgb;
+    vec3 refract = texture2DProj(tex3, rtc).rgb;
+    gl_FragColor.a = texcoord0.z + 4.0*texture2DProj(tex3, texcoord0).a;
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+] [
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    gl_FragColor.rgb = mix(reflect, refract, invfresnel*0.5+0.5);
+]
+fastshader waterfade waterfadefast 2
+altshader waterfade waterrefract
+
+watershader "waterenv" 1 0 [
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    vec3 reflect = textureCube(tex0, camvec - 2.0*invfresnel*bump).rgb;
+] [
+    gl_FragColor.rgb = mix(reflect, color*depth.x, invfresnel*0.5+0.5) + spec*light;
+    gl_FragColor.a = invfresnel*depth.y;
+]
+watershader "waterenvfast" 0 0 [
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    vec3 reflect = textureCube(tex0, camvec - 2.0*invfresnel*bump).rgb;
+] [
+    gl_FragColor.rgb = mix(reflect, color*depth.x, invfresnel*0.5+0.5);
+    gl_FragColor.a = invfresnel*depth.y;
+]
+fastshader waterenv waterenvfast 2
+altshader waterenv waterenvfast
+
+watershader "waterenvrefract" 1 1 [
+    vec2 dtc = texcoord2 + 0.025*dudv;
+    vec3 bump = texture2D(tex1, dtc).rgb*2.0 - 1.0;
+    dudv = texture2D(tex2, dtc).xy*2.0 - 1.0;
+
+    vec3 refract = texture2D(tex3, texcoord0.xy/texcoord0.w + 0.007*dudv).rgb;
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    vec3 reflect = textureCube(tex0, camvec - 2.0*invfresnel*bump).rgb;
+] [
+    gl_FragColor = vec4(mix(reflect, refract, invfresnel*0.5+0.5) + spec*light, 0.0);
+]
+watershader "waterenvrefractfast" 0 1 [
+    vec3 refract = texture2DProj(tex3, texcoord0 + vec4(0.3*dudv, 0.0, 0.0)).rgb;
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    vec3 reflect = textureCube(tex0, camvec - 2.0*invfresnel*bump).rgb;
+] [
+    gl_FragColor = vec4(mix(reflect, refract, invfresnel*0.5+0.5), 0.0);
+]
+fastshader waterenvrefract waterenvrefractfast 2
+altshader waterenvrefract waterenvrefractfast
+
+watershader "waterenvfade" 1 1 [
+    vec2 dtc = texcoord2 + 0.025*dudv;
+    vec3 bump = texture2D(tex1, dtc).rgb*2.0 - 1.0;
+    dudv = texture2D(tex2, dtc).xy*2.0 - 1.0;
+
+    vec2 projtc = texcoord0.xy/texcoord0.w;
+    vec3 refract = texture2D(tex3, projtc + 0.007*dudv).rgb;
+    float fade = texcoord0.z + 4.0*texture2D(tex3, projtc).a;
+    gl_FragColor.a = fade * clamp(gl_FragCoord.z, 0.0, 1.0);
+
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    vec3 reflect = textureCube(tex0, camvec - 2.0*invfresnel*bump).rgb;
+] [
+    gl_FragColor.rgb = mix(reflect, refract, invfresnel*0.5+0.5) + spec*light;
+]
+watershader "waterenvfadefast" 0 1 [
+    vec3 refract = texture2DProj(tex3, texcoord0 + vec4(0.3*dudv, 0.0, 0.0)).rgb;
+    gl_FragColor.a = texcoord0.z + 4.0*texture2DProj(tex3, texcoord0).a;
+    vec3 bump = texture2D(tex1, texcoord2 + 0.025*dudv).rgb*2.0 - 1.0;
+    float invfresnel = clamp(dot(camvec, bump), 0.0, 1.0);
+    vec3 reflect = textureCube(tex0, camvec - 2.0*invfresnel*bump).rgb;
+] [
+    gl_FragColor.rgb = mix(reflect, refract, invfresnel*0.5+0.5);
+]
+fastshader waterenvfade waterenvfadefast 2
+altshader waterenvfade waterenvrefract
+
+causticshader = [
+    lazyshader 0 $arg1 [
+        attribute vec4 vvertex;
+        uniform mat4 camprojmatrix;
+        uniform vec3 texgenS, texgenT;
+        varying vec2 texcoord0;
+        void main(void)
+        {
+            gl_Position = camprojmatrix * vvertex;
+            texcoord0 = vec2(dot(texgenS, vvertex.xyz), dot(texgenT, vvertex.xyz));
+        }
+    ] [
+        //:fog vec3(1.0)
+        uniform vec4 frameblend;
+        varying vec2 texcoord0;
+        uniform sampler2D tex0, tex1;
+        void main(void)
+        {
+            @arg2
+        }
+    ]
+]
+causticshader caustic [
+    gl_FragColor = vec4(vec3(frameblend.x*texture2D(tex0, texcoord0).r + frameblend.y*texture2D(tex1, texcoord0).r + frameblend.w), 1.0);
+]
+
+lazyshader 0 "lava" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    attribute vec3 vnormal;
+    uniform mat4 camprojmatrix;
+    varying vec4 color;
+    uniform vec4 lavatexgen;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        vec2 tc = mix(vvertex.xz, vvertex.yy, abs(vnormal.xz));
+        texcoord0 = (tc + lavatexgen.zw) * lavatexgen.xy;
+    }
+] [
+    uniform sampler2D tex0;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_FragColor = color * texture2D(tex0, texcoord0) * 2.0;
+    }
+]
+
+lazyshader 0 "lavaglare" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    attribute vec3 vnormal;
+    uniform mat4 camprojmatrix;
+    varying vec4 color;
+    uniform vec4 lavatexgen;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vec4(vcolor.rgb*2.0 - 1.0, vcolor.a);
+        vec2 tc = mix(vvertex.xz, vvertex.yy, abs(vnormal.xz));
+        texcoord0 = (tc + lavatexgen.zw) * lavatexgen.xy;
+    }
+] [
+    uniform sampler2D tex0;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        vec4 glow = texture2D(tex0, texcoord0) * color;
+        float k = max(glow.r, max(glow.g, glow.b));
+        gl_FragColor = glow*k*k*32.0;
+    }
+]
+
+lazyshader 0 "waterfall" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    attribute vec3 vnormal;
+    uniform mat4 camprojmatrix;
+    varying vec4 color;
+    uniform vec4 waterfalltexgen;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        vec2 tc = mix(vvertex.xz, vvertex.yy, abs(vnormal.xz));
+        texcoord0 = (tc + waterfalltexgen.zw) * waterfalltexgen.xy;
+    }
+] [
+    uniform sampler2D tex0;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_FragColor = color * texture2D(tex0, texcoord0);
+    }
+]
+
+lazyshader 0 "waterfallrefract" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    attribute vec3 vnormal;
+    uniform mat4 camprojmatrix;
+    uniform mat4 watermatrix;
+    varying vec4 color;
+    uniform vec4 waterfalltexgen;
+    varying vec2 texcoord0;
+    varying vec4 texcoord1;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        vec2 tc = mix(vvertex.xz, vvertex.yy, abs(vnormal.xz));
+        texcoord0 = (tc + waterfalltexgen.zw) * waterfalltexgen.xy;
+        texcoord1 = watermatrix * vvertex;
+    }
+] [
+    uniform vec2 dudvoffset;
+    uniform sampler2D tex0, tex2, tex4;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    varying vec4 texcoord1;
+    void main(void)
+    {
+        vec4 diffuse = texture2D(tex0, texcoord0);
+        vec2 dudv = texture2D(tex2, texcoord0 + 0.2*diffuse.xy + dudvoffset).xy;
+        vec4 refract = texture2DProj(tex4, texcoord1 + vec4(4.0*dudv, 0.0, 0.0));
+        gl_FragColor = mix(refract, color, diffuse);
+    }
+]
+
+lazyshader 0 "waterfallenvrefract" [
+    //:fog
+    attribute vec4 vvertex, vcolor;
+    attribute vec3 vnormal;
+    uniform mat4 camprojmatrix;
+    uniform mat4 watermatrix;
+    uniform vec3 camera;
+    varying vec4 color;
+    uniform vec4 waterfalltexgen;
+    varying vec2 texcoord0;
+    varying vec4 texcoord1;
+    varying vec3 camdir;
+    varying mat3 world;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        camdir = camera - vvertex.xyz;
+        vec3 absnorm = abs(vnormal);
+        world = mat3(absnorm.yzx, -absnorm.zxy, vnormal);
+        vec2 tc = mix(vvertex.xz, vvertex.yy, absnorm.xz);
+        texcoord0 = (tc + waterfalltexgen.zw) * waterfalltexgen.xy;
+        texcoord1 = watermatrix * vvertex;
+    }
+] [
+    uniform vec2 dudvoffset;
+    uniform sampler2D tex0, tex1, tex2, tex4;
+    uniform samplerCube tex3;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    varying vec4 texcoord1;
+    varying vec3 camdir;
+    varying mat3 world;
+    void main(void)
+    {
+        vec4 diffuse = texture2D(tex0, texcoord0);
+        vec2 dudv = texture2D(tex2, texcoord0 + 0.2*diffuse.xy + dudvoffset).xy;
+        vec3 normal = world * (texture2D(tex1, texcoord0 + 0.1*dudv).rgb*2.0 - 1.0);
+        vec4 refract = texture2DProj(tex4, texcoord1 + vec4(4.0*dudv, 0.0, 0.0));
+        vec3 camvec = normalize(camdir);
+        float invfresnel = dot(normal, camvec);
+        vec4 reflect = textureCube(tex3, 2.0*invfresnel*normal - camvec);
+        gl_FragColor = mix(mix(reflect, refract, 1.0 - 0.4*step(0.0, invfresnel)), color, diffuse);
+    }
+]
+altshader waterfallenvrefract waterfallrefract
+
+lazyshader 0 "waterfallenv" [
+    //:fog
+    attribute vec4 vvertex;
+    attribute vec3 vcolor, vnormal;
+    uniform mat4 camprojmatrix;
+    uniform vec3 camera;
+    uniform vec4 waterfalltexgen;
+    varying vec2 texcoord0;
+    varying vec3 color, camdir;
+    varying mat3 world;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        camdir = camera - vvertex.xyz;
+        vec3 absnorm = abs(vnormal);
+        world = mat3(absnorm.yzx, -absnorm.zxy, vnormal);
+        vec2 tc = mix(vvertex.xz, vvertex.yy, absnorm.xz);
+        texcoord0 = (tc + waterfalltexgen.zw) * waterfalltexgen.xy;
+    }
+] [
+    uniform vec2 dudvoffset;
+    uniform sampler2D tex0, tex1, tex2;
+    uniform samplerCube tex3;
+    varying vec2 texcoord0;
+    varying vec3 color, camdir;
+    varying mat3 world;
+    void main(void)
+    {
+        vec4 diffuse = texture2D(tex0, texcoord0);
+        vec2 dudv = texture2D(tex2, texcoord0 + 0.2*diffuse.xy + dudvoffset).xy;
+        vec3 normal = world * (texture2D(tex1, texcoord0 + 0.1*dudv).rgb*2.0 - 1.0);
+        vec3 camvec = normalize(camdir);
+        vec4 reflect = textureCube(tex3, 2.0*dot(normal, camvec)*normal - camvec);
+        gl_FragColor.rgb = mix(reflect.rgb, color, diffuse.rgb);
+        gl_FragColor.a = 0.25 + 0.75*diffuse.r;
+    }
+]
+
+lazyshader 0 "glass" [
+    attribute vec4 vvertex;
+    attribute vec3 vcolor, vnormal;
+    uniform mat4 camprojmatrix;
+    uniform vec3 camera;
+    varying vec3 color, rvec, camdir, normal;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        normal = vnormal;
+        camdir = camera - vvertex.xyz;
+        rvec = 2.0*dot(camdir, vnormal) * vnormal - camdir;
+    }
+] [
+    //:fogrgba vec4(vec3(0.0), 1.0)
+    uniform samplerCube tex0;
+    varying vec3 color, rvec, camdir, normal;
+    void main(void)
+    {
+        vec3 camvec = normalize(camdir);
+        vec3 reflect = textureCube(tex0, rvec).rgb;
+
+        float invfresnel = max(dot(camvec, normal), 0.70);
+        gl_FragColor.rgb = mix(reflect, color*0.05, invfresnel);
+        gl_FragColor.a = invfresnel * 0.95;
+    }
+]
+lazyshader 0 "glassfast" [
+    attribute vec4 vvertex;
+    attribute vec3 vcolor, vnormal;
+    uniform mat4 camprojmatrix;
+    uniform vec3 camera;
+    varying vec3 color, rvec;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        vec3 camdir = camera - vvertex.xyz;
+        rvec = 2.0*dot(camdir, vnormal) * vnormal - camdir;
+    }
+] [
+    //:fogrgba vec4(vec3(0.0), 1.0)
+    uniform samplerCube tex0;
+    varying vec3 color, rvec;
+    void main(void)
+    {
+        vec3 reflect = textureCube(tex0, rvec).rgb;
+        const float invfresnel = 0.75;
+        gl_FragColor.rgb = mix(reflect, color*0.05, invfresnel);
+        gl_FragColor.a = invfresnel * 0.95;
+    }
+]
+fastshader glass glassfast 2
+altshader glass glassfast
+
+lazyshader 0 "grass" [
+    attribute vec4 vvertex, vcolor;
+    attribute vec2 vtexcoord0, vtexcoord1;
+    attribute vec4 vtangent;
+    uniform mat4 camprojmatrix;
+    uniform vec3 camera;
+    uniform vec3 grassmargin;
+    varying vec4 color;
+    varying vec2 texcoord0, texcoord1;
+    varying vec2 bounds;
+    void main(void)
+    {
+        gl_Position = camprojmatrix * vvertex;
+        color = vcolor;
+        texcoord0 = vtexcoord0;
+        texcoord1 = vtexcoord1 * @lmcoordscale;
+        vec2 camdir = (camera.xy - vvertex.xy) * grassmargin.y;
+        bounds = vec2(dot(camdir, vtangent.xy), dot(camdir, vtangent.zw)) + grassmargin.z;
+    }
+] [
+    //:fogrgba vec4(0.0)
+    varying vec4 color;
+    varying vec2 texcoord0, texcoord1;
+    varying vec2 bounds;
+    uniform sampler2D tex0, tex1;
+    void main(void)
+    {
+        vec4 diffuse = texture2D(tex0, texcoord0);
+        diffuse.rgb *= 2.0;
+        vec4 lm = texture2D(tex1, texcoord1) * color;
+        lm.rgb *= lm.a;
+        float margin = clamp(min(bounds.x, bounds.y), 0.0, 1.0);
+        gl_FragColor = diffuse * lm * margin;
+    }
+]
+
 shader 0 "overbrightdecal" [
     attribute vec4 vvertex, vcolor;
     attribute vec2 vtexcoord0;
@@ -1161,6 +2633,7 @@ shader 0 "overbrightdecal" [
         texcoord0 = vtexcoord0;
     }
 ] [
+    //:fog vec3(0.5)
     varying vec4 color;
     varying vec2 texcoord0;
     uniform sampler2D tex0;
@@ -1172,6 +2645,7 @@ shader 0 "overbrightdecal" [
 ]
 
 shader 0 "saturatedecal" [
+    //:fog
     attribute vec4 vvertex, vcolor;
     attribute vec2 vtexcoord0;
     uniform mat4 camprojmatrix;
@@ -1194,3 +2668,135 @@ shader 0 "saturatedecal" [
         gl_FragColor = diffuse * color;
     }
 ]
+
+shader 0 "skybox" [
+    attribute vec4 vvertex, vcolor;
+    attribute vec2 vtexcoord0;
+    uniform mat4 skymatrix;
+    varying vec2 texcoord0;
+    varying vec4 color;
+    void main(void)
+    {
+        gl_Position = skymatrix * vvertex;
+        texcoord0 = vtexcoord0;
+        color = vcolor;
+    }
+] [
+    varying vec2 texcoord0;
+    varying vec4 color;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        gl_FragColor = color * texture2D(tex0, texcoord0);
+    }
+]
+
+shader 0 "skyboxglare" [
+    attribute vec4 vvertex, vcolor;
+    attribute vec2 vtexcoord0;
+    uniform mat4 skymatrix;
+    varying vec4 color;
+    varying vec2 texcoord0;
+    void main(void)
+    {
+        gl_Position = skymatrix * vvertex;
+        color = vcolor;
+        texcoord0 = vtexcoord0;
+    }
+] [
+    varying vec4 color;
+    varying vec2 texcoord0;
+    uniform sampler2D tex0;
+    void main(void)
+    {
+        vec4 glare = texture2D(tex0, texcoord0) * color;
+        gl_FragColor.rgb = vec3(dot(glare.rgb, vec3(10.56, 10.88, 10.56)) - 30.4);
+        gl_FragColor.a = glare.a;
+    }
+]
+
+shader 0 "skyfog" [
+    attribute vec4 vvertex, vcolor;
+    uniform mat4 skymatrix;
+    varying vec4 color;
+    void main(void)
+    {
+        gl_Position = skymatrix * vvertex;
+        color = vcolor;
+    }
+] [
+    varying vec4 color;
+    void main(void)
+    {
+        gl_FragColor = color;
+    }
+]
+
+loop i 2 [
+  lazyshader 0 (? $i "atmosphereglare" "atmosphere") [
+    attribute vec4 vvertex;
+    uniform mat4 skymatrix;
+    varying vec3 camvec;
+    void main(void)
+    {
+        gl_Position = skymatrix * vvertex;
+
+        camvec = vvertex.xyz;
+    }
+  ] [
+    uniform vec4 sunlight;
+    uniform vec3 sundir;
+    uniform vec3 sunweight;
+    uniform vec3 sundiskcolor;
+    uniform vec2 sundiskparams;
+    uniform vec4 opticaldepthparams;
+    uniform vec3 mieparams;
+    uniform vec3 betarayleigh, betamie, betaozone;
+    varying vec3 camvec;
+
+    void main(void)
+    {
+        vec3 camdir = normalize(camvec);
+        float costheta = dot(camdir, sundir);
+
+        // sun disk
+        float edgeoffset = max(1.0 - (1.0 - max(costheta, 0.0)*costheta)*sundiskparams.x, 0.0);
+        // limb darken with distance to edge
+        float limbdarken = sqrt(edgeoffset);
+        // lighten edges for corona, but limit it to not interfere with limb darkening
+        float corona = min(edgeoffset * sundiskparams.y, 1.0);
+        corona = max(0.75 / (1.5 - corona * corona) - 0.5, 0.0);
+        // apply limb darkening and corona to clamped sunlight color
+        vec3 sundisk = sundiskcolor * limbdarken * corona;
+
+        // optical depth along view ray
+        float offset = camdir.z*opticaldepthparams.w;
+        vec3 depth = sqrt(offset*offset + opticaldepthparams.xyz) - offset;
+        vec3 rayleighweight = betarayleigh * depth.x;
+        vec3 mieweight = betamie * depth.y;
+        vec3 ozoneweight = betaozone * (depth.z - depth.x);
+
+        // extinction of light along view ray
+        vec3 viewweight = sunweight - (rayleighweight + mieweight + ozoneweight);
+        vec3 extinction = (exp2(viewweight) - 1.0) / viewweight;
+
+        @(? $i [
+            // only glare sundisk, excluding other scattering
+            // squared (by skipping gamma encode) to limit it
+            gl_FragColor = vec4(sundisk * extinction, sunlight.a);
+        ] [
+            // calculate in-scattering
+            float rphase = (1.5 + 0.5*costheta*costheta) * (3.0 / (16.0 * 3.14159265));
+            float mphase = inversesqrt(mieparams.x + mieparams.y*min(costheta, mieparams.z));
+            vec3 scatter = rayleighweight * rphase + mieweight * (mphase * mphase * mphase);
+
+            // combine scattering and extinction with sundisk
+            vec3 inscatter = (sunlight.rgb * scatter + sundisk) * extinction;
+
+            // gamma encode
+            gl_FragColor = vec4(sqrt(inscatter), sunlight.a);
+        ])
+    }
+  ]
+]
+
diff --git a/packages/hud/damage.png b/packages/hud/damage.png
deleted file mode 100644
index 77fef80..0000000
--- a/packages/hud/damage.png
+++ /dev/null
diff --git a/packages/models/health/iqm.cfg b/packages/models/health/iqm.cfg
deleted file mode 100644
index f492fcd..0000000
--- a/packages/models/health/iqm.cfg
+++ /dev/null
@@ -1,12 +0,0 @@
-iqmload model.iqm

-iqmskin * "diffuse.png" "mask.png"

-iqmbumpmap * "normal.png"

-iqmalphatest Cylinder01

-iqmalphatest Cylinder02

-iqmalphatest Cylinder03

-iqmskin Cylinder01 "overlay_diffuse.png" "overlay_mask.png"

-iqmskin Cylinder02 "overlay_diffuse.png" "overlay_mask.png"

-iqmskin Cylinder03 "overlay_diffuse.png" "overlay_mask.png"

-mdlambient 40

-mdlspec 120

-mdlscale 75

diff --git a/packages/models/health/md3.cfg b/packages/models/health/md3.cfg
new file mode 100644
index 0000000..a26ea6d
--- /dev/null
+++ b/packages/models/health/md3.cfg
@@ -0,0 +1,12 @@
+md3load model.md3

+md3skin * "diffuse.png" "mask.png"

+md3bumpmap * "normal.png"

+md3alphatest Cylinder01

+md3alphatest Cylinder02

+md3alphatest Cylinder03

+md3skin Cylinder01 "overlay_diffuse.png" "overlay_mask.png"

+md3skin Cylinder02 "overlay_diffuse.png" "overlay_mask.png"

+md3skin Cylinder03 "overlay_diffuse.png" "overlay_mask.png"

+mdlambient 40

+mdlspec 120

+mdlscale 75

diff --git a/packages/models/health/model.iqm b/packages/models/health/model.iqm
deleted file mode 100644
index 3824f0a..0000000
--- a/packages/models/health/model.iqm
+++ /dev/null
diff --git a/packages/models/health/model.md3 b/packages/models/health/model.md3
new file mode 100644
index 0000000..06419c9
--- /dev/null
+++ b/packages/models/health/model.md3
diff --git a/packages/models/hudguns/chaing/md5.cfg b/packages/models/hudguns/chaing/md5.cfg
index 86b23d9..09499a4 100644
--- a/packages/models/hudguns/chaing/md5.cfg
+++ b/packages/models/hudguns/chaing/md5.cfg
@@ -10,7 +10,6 @@ md5load "chaing.md5mesh"
 md5skin minigun "m134.png" "m134_mask.png"// .6 .2
 md5bumpmap minigun "m134_normals.png"
 md5spec minigun 200
-md5glare minigun 0.5 1
 md5tag Muzzle_Flash tag_muzzle
 md5adjust Root 0 0 0      -0.75 0.5 0.1
 md5anim "gun idle" "chaing_idle.md5anim"
diff --git a/packages/models/hudguns/fist/md5.cfg b/packages/models/hudguns/fist/md5.cfg
index 1ef74dc..77bb526 100644
--- a/packages/models/hudguns/fist/md5.cfg
+++ b/packages/models/hudguns/fist/md5.cfg
@@ -21,7 +21,6 @@ md5anim "gun shoot" "hands_saw_attack.md5anim" 15
 md5load "chainsaw.md5mesh"
 md5skin chainsaw "chainsaw.png" "chainsaw_mask.png" .2 .05
 md5bumpmap chainsaw "chainsaw_normals.png"
-md5glare chainsaw 0.5 1
 md5anim "gun idle" "chainsaw_idle.md5anim"
 md5anim "gun shoot" "chainsaw_attack.md5anim" 120
 
diff --git a/packages/models/hudguns/gl/md5.cfg b/packages/models/hudguns/gl/md5.cfg
index 6aa7dbd..a45a2d5 100644
--- a/packages/models/hudguns/gl/md5.cfg
+++ b/packages/models/hudguns/gl/md5.cfg
@@ -8,8 +8,6 @@ md5anim "gun shoot" "hands_gl_shoot.md5anim" 35
 md5load "gl.md5mesh"
 md5skin gl "gl.png" "gl_mask.png"
 md5bumpmap gl "gl_normals.png"
-//md5spec gl 200
-md5glare gl 0.5 1
 md5tag Muzzle_Flash tag_muzzle
 md5anim "gun idle" "gl_idle.md5anim"
 md5anim "gun shoot" "gl_shoot.md5anim" 35
diff --git a/packages/models/hudguns/pistol/md5.cfg b/packages/models/hudguns/pistol/md5.cfg
index 55fde7c..c2b4579 100644
--- a/packages/models/hudguns/pistol/md5.cfg
+++ b/packages/models/hudguns/pistol/md5.cfg
@@ -15,7 +15,5 @@ md5anim "gun shoot" "revolver_shoot.md5anim" 18
 
 md5link 0 1 tag_weapon
 mdlscale 300
-//mdltrans 1.75 .25 -1 //-1.5
-//mdltrans 1.75 -0.25 -1.25
 mdltrans 1.2 -1.2 -1.0
 
diff --git a/packages/models/hudguns/rifle/md5.cfg b/packages/models/hudguns/rifle/md5.cfg
index 12c3623..9078554 100644
--- a/packages/models/hudguns/rifle/md5.cfg
+++ b/packages/models/hudguns/rifle/md5.cfg
@@ -10,15 +10,12 @@ md5load "rifle.md5mesh"
 md5skin rifle "sniper.png" "sniper_mask.png"
 md5bumpmap rifle "sniper_normals.png"
 md5spec rifle 150
-md5glare rifle 0.5 1
 md5tag muzzle_flash tag_muzzle
 md5anim "gun idle" "rifle_idle.md5anim"
 md5anim "gun shoot" "rifle_shoot.md5anim" 60
 
 md5link 0 1 tag_bicep
 mdlscale 300
-//mdltrans 2.7 .65 -0.95
-//mdltrans 3 0.95 -1.15
 mdltrans 1.0 -2.0 -0.3
 
 
diff --git a/packages/models/hudguns/rocket/md5.cfg b/packages/models/hudguns/rocket/md5.cfg
index 38bb4c1..0deb013 100644
--- a/packages/models/hudguns/rocket/md5.cfg
+++ b/packages/models/hudguns/rocket/md5.cfg
@@ -14,7 +14,6 @@ md5anim "gun shoot" "hands_rl_shoot.md5anim" 26
 md5load "rl.md5mesh"
 md5skin rl "rl.png" "rl_mask.png"
 md5spec rl 50
-md5glare rl 0.5 1
 md5tag Flash tag_muzzle
 md5adjust Root 0 0 0 0.18 1.5 -2
 md5anim "gun idle" "rl_idle.md5anim"
diff --git a/packages/models/hudguns/shotg/md5.cfg b/packages/models/hudguns/shotg/md5.cfg
index 8ffbec6..f2d9fa7 100644
--- a/packages/models/hudguns/shotg/md5.cfg
+++ b/packages/models/hudguns/shotg/md5.cfg
@@ -8,8 +8,6 @@ md5anim "gun shoot" "hands_shotgun_shoot.md5anim" 50
 md5load "shotgun.md5mesh"
 md5skin shotgun "shotgun.png" "shotgun_mask.png"// .4 .15
 md5bumpmap shotgun "shotgun_normals.png"
-//md5spec shotgun 200
-md5glare shotgun 0.5 1
 md5skin "shell"  "shotgun_shell.png" "shotgun_shell_mask.png"// .4 .15
 md5bumpmap "shell" "shotgun_shell_normals.png"
 md5tag flash tag_muzzle
@@ -18,6 +16,4 @@ md5anim "gun shoot" "shotgun_attack.md5anim" 50
 
 md5link 0 1 tag_weapon
 mdlscale 300
-//mdltrans 3.5 .2 -1
-//mdltrans 3 0 -.5
 mdltrans 1.5 -1.85 -0.3
diff --git a/packages/models/mrfixit/hudguns/md5.cfg b/packages/models/mrfixit/hudguns/md5.cfg
index 9d72956..4a13e80 100644
--- a/packages/models/mrfixit/hudguns/md5.cfg
+++ b/packages/models/mrfixit/hudguns/md5.cfg
@@ -11,4 +11,3 @@ if (>= (strstr (mdlname) "blue") 0) [
 ]
 md5bumpmap "fixit_hands" "fixit_hands_normals.png"
 md5spec "fixit_hands" 100
-md5glare "fixit_hands" 0.5 1
diff --git a/packages/textures/evillair/light_u201_c.png b/packages/textures/evillair/light_u201_c.png
index aa2a3e9..10f8ab3 100644
--- a/packages/textures/evillair/light_u201_c.png
+++ b/packages/textures/evillair/light_u201_c.png
diff --git a/packages/textures/evillair/lightpanel_01_c.png b/packages/textures/evillair/lightpanel_01_c.png
index 3629b93..08439b4 100644
--- a/packages/textures/evillair/lightpanel_01_c.png
+++ b/packages/textures/evillair/lightpanel_01_c.png
diff --git a/packages/textures/evillair/package.cfg b/packages/textures/evillair/package.cfg
index e970b78..03d09d9 100644
--- a/packages/textures/evillair/package.cfg
+++ b/packages/textures/evillair/package.cfg
@@ -1,22 +1,16 @@
-setshader bumpspecmapglowworld

-setshaderparam specscale 0.8 0.7 0.6

-setshaderparam glowcolor 1.0 0.6 0.1

+setshader "bumpspecmapworld"

+setshaderparam "specscale" 1.2 1.1 1.0

 

 texture c "textures/evillair/light_u201_c.png"

 texture n "textures/evillair/light_u201_n.png"

 texture s "textures/evillair/light_u201_s.png"

-texture g "textures/evillair/light_u201_g.png"

 texscale 0.5

 

 texture c "textures/evillair/lightpanel_01_c.png"

 texture n "textures/evillair/lightpanel_01_n.png"

 texture s "textures/evillair/lightpanel_01_s.png"

-texture g "textures/evillair/lightpanel_01_g.png"

 texscale 0.5

 

-setshader bumpspecmapworld

-setshaderparam specscale 1.2 1.1 1.0

-

 texture c "textures/evillair/clangfloor_01_c.png"

 texture n "textures/evillair/clangfloor_01_n.png"

 texture s "textures/evillair/clangfloor_01_s.png"

diff --git a/src/engine/lightmap.cpp b/src/engine/lightmap.cpp
index e705e4b..a317dd5 100644
--- a/src/engine/lightmap.cpp
+++ b/src/engine/lightmap.cpp
@@ -349,13 +349,6 @@ static void insertlightmap(lightmapinfo &li, layoutinfo &si)
 	}
 }
 
-static void copylightmap(lightmapinfo &li, layoutinfo &si)
-{
-	lightmaps[si.lmid-LMID_RESERVED].copy(si.x, si.y, li.colorbuf, si.w, si.h);
-	if((li.type&LM_TYPE)==LM_BUMPMAP0 && lightmaps.inrange(si.lmid+1-LMID_RESERVED))
-		lightmaps[si.lmid+1-LMID_RESERVED].copy(si.x, si.y, (uchar *)li.raybuf, si.w, si.h);
-}
-
 static inline bool htcmp(const lightmapinfo &k, const layoutinfo &v)
 {
 	int kw = k.w, kh = k.h;
diff --git a/src/engine/main.cpp b/src/engine/main.cpp
index d00e0e4..5d264ed 100644
--- a/src/engine/main.cpp
+++ b/src/engine/main.cpp
@@ -1270,6 +1270,9 @@ int main(int argc, char **argv)
 		if(minimized) continue;
 
 		inbetweenframes = false;
+
+		glClearColor(0,0,0,1);///TODO
+
 		if(mainmenu) gl_drawmainmenu();
 		else gl_drawframe();
 		swapbuffers();
diff --git a/src/engine/material.cpp b/src/engine/material.cpp
index b8a3f7f..e29ccf5 100644
--- a/src/engine/material.cpp
+++ b/src/engine/material.cpp
@@ -59,8 +59,6 @@ struct QuadNode {
 	}
 };
 
-static float wfwave;
-
 static const bvec4 matnormals[6] = {
 	bvec4(0x80, 0, 0),
 	bvec4(0x7F, 0, 0),
@@ -366,7 +364,6 @@ void sortmaterials(vector<materialsurface *> &vismats)
 			materialsurface &m = va->matbuf[i];
 			if(!editmode || !showmat || drawtex)
 			{
-				int matvol = 0;
 				if(m.visible == MATSURF_EDIT_ONLY) { i += m.skip; continue; }
 			}
 			vismats.add(&m);
@@ -413,7 +410,6 @@ void rendermaterials()
 
 	glDisable(GL_CULL_FACE);
 
-	MSlot *mslot = NULL;
 	int lastorient = -1, lastmat = -1;
 	bool depth = true, blended = false;
 
diff --git a/src/engine/octaedit.cpp b/src/engine/octaedit.cpp
index af8e9ec..fb37088 100644
--- a/src/engine/octaedit.cpp
+++ b/src/engine/octaedit.cpp
@@ -2522,14 +2522,12 @@ void rendertexturepanel(int w, int h)
 			{
 				VSlot &vslot = lookupvslot(texmru[ti]), *layer = NULL;
 				Slot &slot = *vslot.slot;
-				Texture *tex = slot.sts.empty() ? notexture : slot.sts[0].t, *layertex = NULL;
+				Texture *tex = slot.sts.empty() ? notexture : slot.sts[0].t;
 				if(vslot.layer)
 				{
 					layer = &lookupvslot(vslot.layer);
-					layertex = layer->slot->sts.empty() ? notexture : layer->slot->sts[0].t;
 				}
 				float sx = min(1.0f, tex->xs/(float)tex->ys), sy = min(1.0f, tex->ys/(float)tex->xs);
-				int x = w*1800/h-s-50, r = s;
 				vec2 tc[4] = { vec2(0, 0), vec2(1, 0), vec2(1, 1), vec2(0, 1) };
 				float xoff = vslot.offset.x, yoff = vslot.offset.y;
 				if(vslot.rotation)
diff --git a/src/engine/octarender.cpp b/src/engine/octarender.cpp
index 9253379..6b8a5b5 100644
--- a/src/engine/octarender.cpp
+++ b/src/engine/octarender.cpp
@@ -1106,8 +1106,7 @@ int genmergedfaces(cube &c, const ivec &co, int size, int minlevel = -1)
 			while(tj >= 0 && tjoints[tj].edge < i*(MAXFACEVERTS+1)) tj = tjoints[tj].next;
 			if(tj >= 0 && tjoints[tj].edge < (i+1)*(MAXFACEVERTS+1)) mf.tjoints = tj;
 
-			VSlot &vslot = lookupvslot(mf.tex, true),
-				  *layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, true) : NULL;
+			VSlot &vslot = lookupvslot(mf.tex, true);
 
 			if(surf.numverts&LAYER_TOP) vamerges[level].add(mf);
 			if(surf.numverts&LAYER_BOTTOM)
diff --git a/src/engine/ragdoll.h b/src/engine/ragdoll.h
index 1e51c81..4dac48c 100644
--- a/src/engine/ragdoll.h
+++ b/src/engine/ragdoll.h
@@ -446,7 +446,6 @@ void ragdolldata::move(dynent *pl, float ts)
 	extern const float GRAVITY;
 	if(collidemillis && lastmillis > collidemillis) return;
 
-	int material = lookupmaterial(vec(center.x, center.y, center.z + radius/2));
 	pl->inwater = MAT_AIR;
 
 	calcrotfriction();
diff --git a/src/engine/rendergl.cpp b/src/engine/rendergl.cpp
index 08766a6..7489ff5 100644
--- a/src/engine/rendergl.cpp
+++ b/src/engine/rendergl.cpp
@@ -579,8 +579,6 @@ void setcamprojmatrix(bool init = true, bool flush = false)
 
 	GLOBALPARAM(camprojmatrix, camprojmatrix);
 
-	vec2 lineardepthscale = projmatrix.lineardepthscale();
-
 	if(flush && Shader::lastshader) Shader::lastshader->flushparams();
 }
 
@@ -1026,22 +1024,6 @@ void hudquad(float x, float y, float w, float h, float tx, float ty, float tw, f
 	HUDQUAD(x, y, x+w, y+h, tx, ty, tx+tw, ty+th);
 }
 
-static float findsurface(const vec &v, int &abovemat)
-{
-	ivec o(v), co;
-	int csize;
-	do
-	{
-		cube &c = lookupcube(o, 0, co, csize);
-		abovemat = (int) MAT_AIR;
-		return o.z;
-		o.z = co.z + csize;
-	}
-	while(o.z < worldsize);
-	abovemat = MAT_AIR;
-	return worldsize;
-}
-
 bool renderedgame = false;
 
 void rendergame(bool mainpass)
diff --git a/src/engine/renderva.cpp b/src/engine/renderva.cpp
index 854f569..1e33702 100644
--- a/src/engine/renderva.cpp
+++ b/src/engine/renderva.cpp
@@ -1176,20 +1176,6 @@ void cleanupgeom(renderstate &cur)
 	if(cur.vbuf) disablevbuf(cur);
 }
 
-static void rendergeommultipass(renderstate &cur, int pass)
-{
-	if(cur.vbuf) disablevbuf(cur);
-	if(!cur.vattribs) enablevattribs(cur, false);
-	cur.texgendim = -1;
-	for(vtxarray *va = visibleva; va; va = va->next)
-	{
-		if(!va->texs) continue;
-		if(va->occluded >= OCCLUDE_GEOM) continue;
-		renderva(cur, va, pass);
-	}
-	if(geombatches.length()) renderbatches(cur, pass);
-}
-
 VAR(oqgeom, 0, 1, 1);
 
 void rendergeom(void)
diff --git a/src/engine/shader.cpp b/src/engine/shader.cpp
index 5e56e81..67b9e42 100644
--- a/src/engine/shader.cpp
+++ b/src/engine/shader.cpp
@@ -399,31 +399,6 @@ void GlobalShaderParamState::resetversions()
 	});
 }
 
-static float *findslotparam(Slot &s, const char *name, float *noval = NULL)
-{
-	loopv(s.params)
-	{
-		SlotShaderParam &param = s.params[i];
-		if(name == param.name) return param.val;
-	}
-	loopv(s.shader->defaultparams)
-	{
-		SlotShaderParamState &param = s.shader->defaultparams[i];
-		if(name == param.name) return param.val;
-	}
-	return noval;
-}
-
-static float *findslotparam(VSlot &s, const char *name, float *noval = NULL)
-{
-	loopv(s.params)
-	{
-		SlotShaderParam &param = s.params[i];
-		if(name == param.name) return param.val;
-	}
-	return findslotparam(*s.slot, name, noval);
-}
-
 static inline void setslotparam(SlotShaderParamState &l, const float *val)
 {
 	switch(l.format)
diff --git a/src/engine/texture.cpp b/src/engine/texture.cpp
index 77eac65..7f391a9 100644
--- a/src/engine/texture.cpp
+++ b/src/engine/texture.cpp
@@ -2040,7 +2040,6 @@ int findslottex(const char *name)
 void texture(char *type, char *name, int *rot, int *xoffset, int *yoffset, float *scale)
 {
 	if(slots.length()>=0x10000) return;
-	static int lastmatslot = -1;
 	int tnum = findslottex(type);
 	if(tnum<0) tnum = atoi(type);
 	Slot &s = *(tnum!=TEX_DIFFUSE ? slots.last() : slots.add(new Slot(slots.length())));
diff --git a/src/engine/worldio.cpp b/src/engine/worldio.cpp
index 4d5e178..4e309a8 100644
--- a/src/engine/worldio.cpp
+++ b/src/engine/worldio.cpp
@@ -70,22 +70,12 @@ bool loadents(const char *fname, vector<entity> &ents, uint *crc)
 
 	string gametype;
 	copystring(gametype, "fps");
-	bool samegame = true;
 	int eif = 0;
-	{
-		int len = f->getchar();
-		f->read(gametype, len+1);
-	}
-	if(strcmp(gametype, game::gameident()))
-	{
-		samegame = false;
-		conoutf(CON_WARN, "WARNING: loading map from %s game, ignoring entities except for lights/mapmodels", gametype);
-	}
-	{
-		eif = f->getlil<ushort>();
-		int extrasize = f->getlil<ushort>();
-		f->seek(extrasize, SEEK_CUR);
-	}
+	int len = f->getchar();
+	f->read(gametype, len+1);
+	eif = f->getlil<ushort>();
+	int extrasize = f->getlil<ushort>();
+	f->seek(extrasize, SEEK_CUR);
 
 	ushort nummru = f->getlil<ushort>();
 	f->seek(nummru*sizeof(ushort), SEEK_CUR);
@@ -803,24 +793,14 @@ bool load_world(const char *mname, const char *cname)		// still supports all map
 
 	string gametype;
 	copystring(gametype, "fps");
-	bool samegame = true;
 	int eif = 0;
-	{
-		int len = f->getchar();
-		f->read(gametype, len+1);
-	}
-	if(strcmp(gametype, game::gameident())!=0)
-	{
-		samegame = false;
-		conoutf(CON_WARN, "WARNING: loading map from %s game, ignoring entities except for lights/mapmodels", gametype);
-	}
-	{
-		eif = f->getlil<ushort>();
-		int extrasize = f->getlil<ushort>();
-		vector<char> extras;
-		f->read(extras.pad(extrasize), extrasize);
-		if(samegame) game::readgamedata(extras);
-	}
+	int len = f->getchar();
+	f->read(gametype, len+1);
+	eif = f->getlil<ushort>();
+	int extrasize = f->getlil<ushort>();
+	vector<char> extras;
+	f->read(extras.pad(extrasize), extrasize);
+	game::readgamedata(extras);
 
 	texmru.shrink(0);
 	ushort nummru = f->getlil<ushort>();
@@ -838,19 +818,7 @@ bool load_world(const char *mname, const char *cname)		// still supports all map
 		f->read(&e, sizeof(entity));
 		lilswap(&e.o.x, 3);
 		lilswap(&e.attr1, 5);
-		if(samegame)
-		{
-			if(einfosize > 0) f->read(ebuf, einfosize);
-		}
-		else
-		{
-			if(eif > 0) f->seek(eif, SEEK_CUR);
-			if(e.type>=ET_GAMESPECIFIC)
-			{
-				entities::deleteentity(ents.pop());
-				continue;
-			}
-		}
+		if(einfosize > 0) f->read(ebuf, einfosize);
 		if(!insideworld(e.o))
 		{
 			if(e.type != ET_LIGHT && e.type != ET_SPOTLIGHT)
@@ -864,7 +832,7 @@ bool load_world(const char *mname, const char *cname)		// still supports all map
 	if(hdr.numents > MAXENTS)
 	{
 		conoutf(CON_WARN, "warning: map has %d entities", hdr.numents);
-		f->seek((hdr.numents-MAXENTS)*(samegame ? sizeof(entity) + einfosize : eif), SEEK_CUR);
+		f->seek((hdr.numents-MAXENTS)*(sizeof(entity) + einfosize), SEEK_CUR);
 	}
 
 	renderprogress(0, "loading slots...");
diff --git a/src/fpsgame/waypoint.cpp b/src/fpsgame/waypoint.cpp
index 22e48d0..30a1403 100644
--- a/src/fpsgame/waypoint.cpp
+++ b/src/fpsgame/waypoint.cpp
@@ -19,7 +19,7 @@ namespace ai
 		vec pos = o; pos.z += ai::JUMPMIN;
 		if(!insideworld(vec(pos.x, pos.y, min(pos.z, getworldsize() - 1e-3f)))) return -2;
 		float dist = raycube(pos, vec(0, 0, -1), 0, RAY_CLIPMAT);
-		int posmat = lookupmaterial(pos), weight = 1;
+		int weight = 1;
 		if(dist >= 0)
 		{
 			weight = int(dist/ai::JUMPMIN);
diff --git a/src/shared/geom.h b/src/shared/geom.h
index e01acc2..a0ef7c8 100644
--- a/src/shared/geom.h
+++ b/src/shared/geom.h
@@ -1761,11 +1761,6 @@ struct matrix4
 	vec4 roww() const { return vec4(a.w, b.w, c.w, d.w); }
 
 	bool invert(const matrix4 &m, double mindet = 1.0e-12);
-
-	vec2 lineardepthscale() const
-	{
-		return vec2(d.w, -d.z).div(c.z*d.w - d.z*c.w);
-	}
 };
 
 inline matrix3::matrix3(const matrix4 &m)