Lines!

LINE_CORNER_NONE = 0
LINE_CORNER_MITER = 1
LINE_CORNER_ROUND = 2

do
    local plotting = false
    local plots, quads = {}, {}
    local plot_count, quad_count = 0, 0

    local thickness = 0
    local min_angle = 0
    local corner_type = 0

    function draw.StartLine(_thickness, _min_angle, _corner_type)
        assert(not plotting, "how come your mom lets you have 2 lines")

        plotting = true
        plot_count, quad_count = 0, 0

        thickness = (tonumber(_thickness) or 10) / 2
        min_angle = math.pi - math.rad(tonumber(_min_angle) or 20)
        corner_type = tonumber(_corner_type) or 0
    end

    function draw.AddLinePoint(x, y)
        assert(plotting, "better start a line boy")

        if not y then
            y = x.y
            x = x.x
        end

        plot_count = plot_count + 1
        plots[plot_count] = Vector(x, y)
    end

    function draw.EndLine()
        assert(plotting, "cut me point 2 g fam")
        plotting = false

        assert(plot_count > 1, "A minimum of 2 points are required to draw a line.")

        for i = 1, plot_count - 1 do
            local a, b = plots[i], plots[i + 1]

            local ab = b - a
            ab:Normalize()

            local ab_right = Vector(-ab.y, ab.x)

            quad_count = quad_count + 1
            quads[quad_count] = {
                a + ab_right * thickness,
                a - ab_right * thickness,
                b - ab_right * thickness,
                b + ab_right * thickness,
            }
        end

        if plot_count >= 3 then
            for i = 2, plot_count - 1 do
                local a, b, c = unpack(plots, i - 1, i + 1)

                local left_quad = quads[i - 1]
                local right_quad = quads[i]

                local ab, bc do
                    ab = b - a
                    bc = c - b

                    ab:Normalize()
                    bc:Normalize()
                end

                local angle = math.acos(ab:Dot(bc))
                local bc_right = Vector(-bc.y, bc.x)

                local is_left = false
                if ab:Dot(bc_right) > 0 then
                    is_left = true
                end

                if corner_type == LINE_CORNER_MITER then
                    local height = thickness / math.cos(angle / 2)
                    local joint_direction = bc - ab
                    joint_direction:Normalize()

                    if is_left then
                        joint_direction = -joint_direction
                    end

                    if angle <= min_angle then
                        left_quad[3] = b - joint_direction * height
                        left_quad[4] = b + joint_direction * height

                        right_quad[1] = left_quad[4]
                        right_quad[2] = left_quad[3]
                    end
                elseif corner_type == LINE_CORNER_ROUND then
                    local bd = (is_left and left_quad[4] or right_quad[2]) - b
                    bd:Normalize()

                    local step = 1 / thickness
                    local theta = (0.5 * math.pi - math.atan2(bd.y, bd.x)) % math.tau

                    mesh.Begin(MATERIAL_POLYGON, 1)
                        for a = theta, theta + angle + step, step do
                            local sin, cos = math.sin(a), math.cos(a)
                            local pos = b + Vector(sin, cos) * thickness

                            mesh.Position(pos)
                            mesh.AdvanceVertex()
                        end

                        mesh.Position(b)
                        mesh.AdvanceVertex()
                    mesh.End()
                end
            end
        end

        mesh.Begin(MATERIAL_QUADS, quad_count)
            for i, quad in ipairs(quads) do
                mesh.Quad(unpack(quad))
            end
        mesh.End()
    end
end


--[[

    EXAMPLE

]]--


local plots = {}
for i = 1, 20 do
    if #plots == 0 then
        table.insert(plots, Vector(ScrW() / 2, ScrH() / 2))
    else
        local rand_direction = Vector(math.Rand(-1, 1), math.Rand(-1, 1))
        rand_direction:Normalize()

        local last_plot = plots[#plots]
        table.insert(plots, last_plot + rand_direction * math.random(100, 400))
    end
end

hook.Add("PostRender", "", function()
    cam.Start2D()
        surface.SetDrawColor(255, 255 ,255)
        render.SetMaterial(Material("vgui/white"))

        draw.StartLine(50, 15, math.floor(CurTime() % 3))
            for i, plot in ipairs(plots) do
                draw.AddLinePoint(plot)
            end
        draw.EndLine()
    cam.End2D()
end)