deferred = {}

local gbuffershader = love.graphics.newShader
[[
extern Image normaltex;
extern Image materialtex;

void effects( vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords )
{
    love_Canvases[0] = Texel(texture, texture_coords);
    love_Canvases[1] = Texel(normaltex, texture_coords);
    love_Canvases[2] = Texel(materialtex, texture_coords);
}
]]

local directionalshader = love.graphics.newShader
[[
    extern Image colorbuffer;
    extern Image normalbuffer;
    extern Image materialbuffer;

    extern Image ramp;

    extern vec3 lightvec;

    vec4 effect( vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords )
    {
        screen_coords = screen_coords / love_ScreenSize.xy;
        screen_coords.y = 1.0 - screen_coords.y;

        vec4 tcol = Texel(colorbuffer, screen_coords);
        vec4 material = Texel(materialbuffer, screen_coords);

        float emission = material.g;
        float specintensity = material.r;
        float specpower = material.b;

        vec4 lcol = color;

        vec3 E = vec3(0, 0, -1);
        vec3 N = 2 * Texel(normalbuffer, screen_coords).xyz - 1;
        vec3 L = normalize(lightvec);
        vec3 R = reflect(L, N);
        float NdotL = dot(N, L);
        float EdotR = pow(dot(E, R), specpower*255);

        float diffuse = NdotL;
        float specular;
        if(NdotL < 0)
        {
            specular = 0;
        }
        else
        {
            specular = EdotR * specintensity;
        }
        return tcol * lcol * (Texel(ramp, vec2(diffuse, 0)) + Texel(ramp, vec2(specular, 0))) + emission*tcol;
        //return color;
    }
]]

function deferred.initialize()
    deferred.normalbuffer = love.graphics.newCanvas()
    deferred.materialbuffer = love.graphics.newCanvas()
    deferred.colorbuffer = love.graphics.newCanvas()

    deferred.ramp = love.graphics.newImage("ramp.png")
    deferred.ramp:setFilter("nearest", "nearest")
end

function deferred.newImage(path, normalpath, materialpath)
    if not normalpath then
        normalpath = string.gsub(path, "%.", "_normals.")
        materialpath = string.gsub(path, "%.", "_material.")
    end

    dsprite = {}
    table.insert(dsprite, love.graphics.newImage(path))
    table.insert(dsprite, love.graphics.newImage(normalpath))
    table.insert(dsprite, love.graphics.newImage(materialpath))

    dsprite[1]:setFilter("nearest", "nearest")
    dsprite[2]:setFilter("nearest", "nearest")
    dsprite[3]:setFilter("nearest", "nearest")

    return dsprite
end

function deferred.beginSpritePass()
    love.graphics.setShader(gbuffershader)
    love.graphics.setCanvas(deferred.colorbuffer, deferred.normalbuffer, deferred.materialbuffer)
    love.graphics.clear()

end

function deferred.endSpritePass()
    love.graphics.setCanvas()
    love.graphics.setShader()
end

function deferred.beginLightPass()
    love.graphics.setBlendMode("additive")
end

function deferred.endLightPass()
    love.graphics.setBlendMode("alpha")
    love.graphics.setShader()
end

function deferred.draw(image, x, y, r, sx, sy, ox, oy, kx, ky)
    love.graphics.setShader(gbuffershader)
    gbuffershader:send("normaltex", image[2])
    gbuffershader:send("materialtex", image[3])

    love.graphics.draw(image[1], x, y, r, sx, sy, ox, oy, kx, ky)
end

function deferred.drawDirectionalLight(color, vector)
    scw, sch = love.graphics.getDimensions()
    love.graphics.setShader(directionalshader)
    directionalshader:send("colorbuffer", deferred.colorbuffer)
    directionalshader:send("normalbuffer", deferred.normalbuffer)
    directionalshader:send("materialbuffer", deferred.materialbuffer)
    directionalshader:send("ramp", deferred.ramp)
    directionalshader:send("lightvec", vector)

    love.graphics.setColor(color)
    love.graphics.rectangle("fill", 0, 0, scw, sch)
end