Perlin Noise w/ Render

local random, randomseed = math.random, math.randomseed
local floor = math.floor
local max, min = math.max, math.min

local octaves = 3
local persistence = 0.5

function cos_interpolate(a, b, x)
    local ft = x * math.pi
    local f = (1 - math.cos(ft)) * .5

    return  a * (1 - f) + b * f
end

function noise_2d(x, y, i, seed)
    randomseed((x * seed + y * i ^ 1.1 + 14) / 789221 + 33 * x + 15731 * y * seed)

    random()

    return random(-1000, 1000) / 1000
end

function smooth_noise_2d(x, y, i, seed)
    local corners = (noise_2d(x - 1, y - 1, i, seed) + noise_2d(x + 1, y - 1, i, seed) + noise_2d(x - 1, y + 1, i, seed) + noise_2d(x + 1, y + 1, i, seed)) / 16
    local sides = (noise_2d(x - 1, y, i, seed) + noise_2d(x + 1, y, i, seed) + noise_2d(x, y - 1, i, seed) + noise_2d(x, y + 1, i, seed)) / 8
    local center = noise_2d(x, y, i, seed) / 4
    return corners + sides + center
end

function interpolate_noise_2d(x, y, i, seed)
    local int_x = floor(x)
    local frac_x = x - int_x

    local int_y = floor(y)
    local frac_y = y - int_y

    local v1 = smooth_noise_2d(int_x, int_y, i, seed)
    local v2 = smooth_noise_2d(int_x + 1, int_y, i, seed)
    local v3 = smooth_noise_2d(int_x, int_y + 1, i, seed)
    local v4 = smooth_noise_2d(int_x + 1, int_y + 1, i, seed)

    local i1 = cos_interpolate(v1, v2, frac_x)
    local i2 = cos_interpolate(v3, v4, frac_x)

    return cos_interpolate(i1, i2, frac_y)
end

function perlin_2d(x, y, seed)
    local total = 0
    local p = persistence
    local n = octaves - 1

    for i = 0, n do
        local frequency = 2 ^ i
        local amplitude = p ^ i

        total = total + interpolate_noise_2d(x * frequency, y * frequency, i, seed) * amplitude
    end

    return total
end


local points = {}
local size = 150
local scale = 2
local can

function love.load()
    for x = -size, size do
        points[x] = {}
        local ax = points[x]
        for y = -size, size do
            ax[y] = min(max(perlin_2d(x / 16, y / 16, 4923), -1), 1)
        end
    end

    can = love.graphics.newCanvas()
    love.graphics.setCanvas(can)

    love.graphics.translate(512, 384)
    love.graphics.scale(1, -1)
    love.graphics.setPointSize(scale)

    for x = -size, size do
        local ax = points[x]
        for y = -size, size do
            local c = ax[y] * 127.5 + 127.5
            love.graphics.setColor(c, c, c)
            love.graphics.point(x * scale, y * scale)
        end
    end

    love.graphics.setCanvas()
end

function love.draw()
    love.graphics.setColor(255, 255, 255)
    love.graphics.draw(can)
end