-- GLSL Lua shaders for CubeCreate

local function lazyshader(stype, name, v, f)
    Shader.defer(stype, name, "Shader.normal([[" .. v .. "]],[[" .. f .. "]])")
end

lmcoordscale = 1.0 / 32767.0

---------------------------------------------------
--
-- used for any textured polys that don't have a shader set
--
---------------------------------------------------

Shader.normal(4, "default",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = gl_MultiTexCoord0;
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        uniform sampler2D tex0;
        void main(void)
        {
            gl_FragColor = gl_Color * texture2D(tex0, gl_TexCoord[0].xy);
        }
    ]]
)

Shader.normal(4, "rect",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = gl_MultiTexCoord0;
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        #extension GL_ARB_texture_rectangle : enable
        uniform sampler2DRect tex0;
        void main(void)
        {
            gl_FragColor = gl_Color * texture2DRect(tex0, gl_TexCoord[0].xy);
        }
    ]]
)

Shader.normal(4, "cubemap",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = gl_MultiTexCoord0;
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        uniform samplerCube tex0;
        void main(void)
        {
            gl_FragColor = gl_Color * textureCube(tex0, gl_TexCoord[0].xyz);
        }
    ]]
)

Shader.normal(4, "rgbonly",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = gl_MultiTexCoord0;
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        uniform sampler2D tex0;
        void main(void)
        {
            gl_FragColor.rgb = gl_Color.rgb * texture2D(tex0, gl_TexCoord[0].xy).rgb;
            gl_FragColor.a   = gl_Color.a;
        }
    ]]
)

----------------------------------------------------------------------
--
-- same, but now without texture sampling (some HUD stuff needs this)
--
----------------------------------------------------------------------

Shader.normal(4, "notexture",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = gl_Color;
        }
    ]]
)

Shader.normal(4, "notextureglsl",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = gl_Color;
        }
    ]]
)

----------------------------------------------------------------------
--
-- fogged variants of default shaders
--
----------------------------------------------------------------------

Shader.normal(4, "fogged",
    [[
        #pragma CUBE2_fog
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = gl_MultiTexCoord0;
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        uniform sampler2D tex0;
        void main(void)
        {
            gl_FragColor = gl_Color * texture2D(tex0, gl_TexCoord[0].xy);
        }
    ]]
)

Shader.normal(4, "foggednotexture",
    [[
        #pragma CUBE2_fog
        void main(void)
        {
            gl_Position = ftransform();
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = gl_Color;
        }
    ]]
)

Shader.normal(4, "foggednotextureglsl",
    [[
        #pragma CUBE2_fog
        void main(void)
        {
            gl_Position = ftransform();
            gl_FrontColor = gl_Color;
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = gl_Color;
        }
    ]]
)

----------------------------------------------------------------------
--
-- for filling the z-buffer only (i.e. multi-pass rendering, OQ)
--
----------------------------------------------------------------------

Shader.normal(4, "nocolor",
    [[
        void main() { gl_Position = ftransform(); }
    ]],
    [[
        void main() {}
    ]]
)

Shader.normal(4, "nocolorglsl",
    [[
        void main() { gl_Position = ftransform(); }
    ]],
    [[
        void main() {}
    ]]
)

--------------------------------------------------------
--
-- default lightmapped world shader.. does texcoord gen
--
-------------------------------------------------------

-- yay for cubescript-port hacks >.>
sworldargs = {}
gworldargs = {}

function worldshader(...)
    sworldargs = { ... }
    local stype = 4
    if not string.find(sworldargs[1], "env") then stype = stype + 2 end
    Shader.normal(stype, sworldargs[1],
        [[
            #pragma CUBE2_fog
            <% if #sworldargs >= 5 then return sworldargs[5] end %>
            uniform vec4 texgenscroll;
            void main(void)
            {
                gl_Position = ftransform();
                gl_TexCoord[0].xy = gl_MultiTexCoord0.xy + texgenscroll.xy;
                gl_TexCoord[1].xy = gl_MultiTexCoord1.xy * <%=lmcoordscale%>;

                <%=sworldargs[2]%>

                #pragma CUBE2_shadowmap
                #pragma CUBE2_dynlight
                #pragma CUBE2_water
            }
        ]],
        [[
            <% if #sworldargs >= 5 then return sworldargs[5] end %>
            <% if #sworldargs >= 6 then return sworldargs[6] end %>
            uniform vec4 colorparams;
            uniform sampler2D diffusemap, lightmap;
            void main(void)
            {
                vec4 diffuse = texture2D(diffusemap, gl_TexCoord[0].xy);
                vec4 lm = texture2D(lightmap, gl_TexCoord[1].xy);

                #pragma CUBE2_shadowmap lm
                #pragma CUBE2_dynlight lm

                <%=sworldargs[3]%>

                diffuse *= colorparams;
                <% if #sworldargs < 4 or sworldargs[4] == "" then return 'gl_FragColor = diffuse * lm;' else return sworldargs[4] end %>

                #pragma CUBE2_water
            }
        ]]
    )
    sworldargs = nil
end

function glareworldshader(...)
    gworldargs = { ... }
    Shader.variant(not string.find(gworldargs[1], "env") and 4 or 6, gworldargs[1], 4,
        [[
            #pragma CUBE2_fog
            <% if #gworldargs >= 4 then return gworldargs[4] end %>
            uniform vec4 texgenscroll;
            void main(void)
            {
                gl_Position = ftransform();
                gl_TexCoord[0].xy = gl_MultiTexCoord0.xy + texgenscroll.xy;
                gl_TexCoord[1].xy = gl_MultiTexCoord1.xy * <%=lmcoordscale%>;

                <%=gworldargs[2]%>
            }
        ]],
        [[
            <% if #gworldargs >= 4 then return gworldargs[4] end %>
            <% if #gworldargs >= 5 then return gworldargs[5] end %>
            uniform vec4 colorparams;
            uniform sampler2D diffusemap, lightmap;
            void main(void)
            {
                <%=gworldargs[3]%>
            }
        ]]
    )
    gworldargs = nil
end

worldshader("stdworld", "", "")

Shader.defer(4, "decalworld",
    [[
        worldshader("decalworld", "",
            [=[
                vec4 diffuse2 = texture2D(decal, gl_TexCoord[0].xy);
                diffuse.rgb = mix(diffuse.rgb, diffuse2.rgb, diffuse2.a);
            ]=], "", "", "uniform sampler2D decal;"
        )
    ]]
)

Shader.defer(4, "glowworld",
    [[
        Shader.defUniformParam("glowcolor", 1, 1, 1) -- glow color
        worldshader("glowworld", "", "",
            [=[
                vec3 glow = texture2D(glowmap, gl_TexCoord[0].xy).rgb;
                glow *= glowcolor.rgb;
                gl_FragColor = diffuse*lm + vec4(glow, 0.0);
            ]=], "", "uniform sampler2D glowmap;"
        )
        glareworldshader("glowworld", "",
            [=[
                vec3 glow = texture2D(glowmap, gl_TexCoord[0].xy).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;
                #pragma CUBE2_variantoverride gl_FragColor.a = texture2D(lightmap, gl_TexCoord[1].xy).a; --
                gl_FragColor.a = colorparams.a;
            ]=], "",
            [=[
                uniform sampler2D glowmap;
                #pragma CUBE2_variant uniform sampler2D lightmap;
            ]=]
        )
    ]]
)

Shader.defer(4, "pulseworld",
    [[
        Shader.defUniformParam("pulsespeed", 1) -- pulsefrequency (Hz)
        worldshader("pulseworld",
            "pulse = abs(fract(millis.x * pulsespeed.x)*2.0 - 1.0);",
            [=[
                vec3 diffuse2 = texture2D(decal, gl_TexCoord[0].xy).rgb;
                diffuse.rgb = mix(diffuse.rgb, diffuse2, pulse);
            ]=], "",
            "uniform vec4 millis; varying float pulse;",
            "uniform sampler2D decal;"
        )
    ]]
)

Shader.defer(4, "pulseglowworld",
    [[
        Shader.defUniformParam("glowcolor", 1, 1, 1) -- glow color
        Shader.defUniformParam("pulseglowspeed", 1) -- pulse frequency (Hz)
        Shader.defUniformParam("pulseglowcolor", 0, 0, 0) -- pulse glow color
        worldshader("pulseglowworld",
            [=[
                pulse = mix(glowcolor.rgb, pulseglowcolor.rgb, abs(fract(millis.x * pulseglowspeed.x)*2.0 - 1.0));
            ]=], "",
            [=[
                vec3 glow = texture2D(glowmap, gl_TexCoord[0].xy).rgb;
                gl_FragColor = diffuse*lm + vec4(glow*pulse, 0.0);
            ]=], "uniform vec4 millis; varying vec3 pulse;", "uniform sampler2D glowmap;"
        )
        glareworldshader("pulseglowworld",
            [=[
                pulse = mix(glowcolor.rgb, pulseglowcolor.rgb, abs(fract(millis.x * pulseglowspeed.x)*2.0 - 1.0));
            ]=],
            [=[
                vec3 glow = texture2D(glowmap, gl_TexCoord[0].xy).rgb;
                glow *= pulse;
                float k = max(glow.r, max(glow.g, glow.b));
                gl_FragColor.rgb = min(k*k*32.0, 1.0) * glow;
                #pragma CUBE2_variantoverride gl_FragColor.a = texture2D(lightmap, gl_TexCoord[1].xy).a; --
                gl_FragColor.a = colorparams.a;
            ]=], "uniform vec4 millis; varying vec3 pulse;",
            [=[
                uniform sampler2D glowmap;
                #pragma CUBE2_variant uniform sampler2D lightmap;
            ]=]
        )
    ]]
)

Shader.normal(4, "fogworld",
    [[
        void main(void)
        {
            gl_Position = ftransform();
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = gl_Fog.color;
        }
    ]]
)

Shader.normal(4, "noglareworld",
    [[
        void main(void)
        {
            gl_Position = ftransform();
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = vec4(0.0);
        }
    ]]
)

Shader.normal(4, "noglareblendworld",
    [[
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0].xy = gl_MultiTexCoord1.xy * <%=lmcoordscale%>;
        }
    ]],
    [[
        uniform sampler2D lightmap;
        void main(void)
        {
            gl_FragColor.rgb = vec3(0.0);
            gl_FragColor.a = texture2D(lightmap, gl_TexCoord[0].xy).a;
        }
    ]]
)

Shader.normal(4, "noglarealphaworld",
    [[
        void main(void)
        {
            gl_Position = ftransform();
        }
    ]],
    [[
        uniform vec4 colorparams;
        uniform sampler2D lightmap;
        void main(void)
        {
            gl_FragColor.rgb = vec3(0.0);
            gl_FragColor.a = colorparams.a;
        }
    ]]
)

Shader.defer(6, "envworld",
    [[
        Shader.defUniformParam("envscale", 0.2, 0.2, 0.2) -- reflectivity
        worldshader("envworld",
            [=[
                normal = gl_Normal;
                camvec = camera.xyz - gl_Vertex.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 vec4 camera; varying vec3 normal, camvec;", "uniform samplerCube envmap;"
        )

        Shader.defUniformParam("envscale", 0.2, 0.2, 0.2) -- reflectivity
        worldshader("envworldfast",
            [=[
                vec3 camvec = camera.xyz - gl_Vertex.xyz;
                rvec = 2.0*gl_Normal*dot(camvec, gl_Normal) - camvec;
            ]=],
            [=[
                vec3 reflect = textureCube(envmap, rvec).rgb;
            ]=],
            [=[
                diffuse *= lm;
                gl_FragColor.rgb = mix(diffuse.rgb, reflect, envscale.rgb);
                gl_FragColor.a = diffuse.a;
            ]=], "uniform vec4 camera; varying vec3 rvec;", "uniform samplerCube envmap;"
        )

        Shader.defUniformParam("envscale", 0.2, 0.2, 0.2) -- reflectivity
        worldshader("envworldalt", "", "")

        Shader.alt("envworld", "envworldalt")
        Shader.fast("envworld", "envworldfast", 2)
        Shader.fast("envworld", "envworldalt", 1)
    ]]
)

Shader.normal(4, "depthfxworld",
    [[
        uniform vec4 depthscale, depthoffsets;
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = depthoffsets - (gl_ModelViewMatrix * gl_Vertex).z*depthscale;
        }
    ]],
    [[
        void main(void)
        {
            gl_FragColor = gl_TexCoord[0];
        }
    ]]
)

Shader.normal(4, "depthfxsplitworld",
    [[
        uniform vec4 depthscale, depthoffsets;
        void main(void)
        {
            gl_Position = ftransform();
            gl_TexCoord[0] = depthoffsets - (gl_ModelViewMatrix * gl_Vertex).z*depthscale;
        }
    ]],
    [[
        void main(void)
        {
            vec4 ranges = vec4(gl_TexCoord[0].x, fract(gl_TexCoord[0].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