Events:Subscribe("ModuleLoad", function()

    boxes = {
        ['km07.submarine.eez/key014_02-a.lod']  = {Vector3(-66.16, -41.87, -265.63), Vector3(66.14, 69.94, 255.33)}
    }

    -- boxes = {
        -- ['km07.submarine.eez/key014_02-a.lod']   = {Vector3(-45, -42, -280), Vector3(45, 5, 260)}
    -- }

    ellipsoids = {}

    for model,box in pairs(boxes) do

        local a = (box[2].x - box[1].x) / 2
        local b = (box[2].y - box[1].y) / 2
        local c = (box[2].z - box[1].z) / 2

        ellipsoids[model] = {a, b, c}

    end

    Events:Subscribe("Render", Draw)

end)

function Draw()

    for obj in Client:GetStaticObjects() do

        if IsValid(obj) and obj:GetModel() == "km07.submarine.eez/key014_02-a.lod" then

            -- DrawBoundingCorners(obj, Color.Yellow)
            -- DrawBoundingBoxRelative(obj, Color.Yellow)
            -- DrawBoundingEllipsoidRelative(obj, 20, color)
            -- DrawBoundingBox(obj, Color.Yellow)

        end

    end

end

function DrawBoundingCorners(obj, color)

    local u, v = obj:GetBoundingBox()
    Render:DrawCircle(Render:WorldToScreen(u), 10, color)
    Render:DrawCircle(Render:WorldToScreen(v), 10, color)

end

function DrawBoundingBox(obj, color)

    local u, v = obj:GetBoundingBox()

    local corners = {
        Vector3(u.x, u.y, u.z),
        Vector3(u.x, u.y, v.z),
        Vector3(v.x, u.y, v.z),
        Vector3(v.x, u.y, u.z),
        Vector3(u.x, v.y, u.z),
        Vector3(u.x, v.y, v.z),
        Vector3(v.x, v.y, v.z),
        Vector3(v.x, v.y, u.z),
    }

    Render:DrawLine(corners[1], corners[2], color)
    Render:DrawLine(corners[2], corners[3], color)
    Render:DrawLine(corners[3], corners[4], color)
    Render:DrawLine(corners[4], corners[1], color)

    Render:DrawLine(corners[1], corners[5], color)
    Render:DrawLine(corners[2], corners[6], color)
    Render:DrawLine(corners[3], corners[7], color)
    Render:DrawLine(corners[4], corners[8], color)

    Render:DrawLine(corners[5], corners[6], color)
    Render:DrawLine(corners[6], corners[7], color)
    Render:DrawLine(corners[7], corners[8], color)
    Render:DrawLine(corners[8], corners[5], color)

end

function DrawBoundingBoxRelative(obj, color)

    local model = obj:GetModel()
    local position = obj:GetPosition()
    local angle = obj:GetAngle()

    local u = boxes[model][1]
    local v = boxes[model][2]

    local corners = {
        position + angle * Vector3(u.x, u.y, u.z),
        position + angle * Vector3(u.x, u.y, v.z),
        position + angle * Vector3(v.x, u.y, v.z),
        position + angle * Vector3(v.x, u.y, u.z),
        position + angle * Vector3(u.x, v.y, u.z),
        position + angle * Vector3(u.x, v.y, v.z),
        position + angle * Vector3(v.x, v.y, v.z),
        position + angle * Vector3(v.x, v.y, u.z),
    }

    Render:DrawLine(corners[1], corners[2], color)
    Render:DrawLine(corners[2], corners[3], color)
    Render:DrawLine(corners[3], corners[4], color)
    Render:DrawLine(corners[4], corners[1], color)

    Render:DrawLine(corners[1], corners[5], color)
    Render:DrawLine(corners[2], corners[6], color)
    Render:DrawLine(corners[3], corners[7], color)
    Render:DrawLine(corners[4], corners[8], color)

    Render:DrawLine(corners[5], corners[6], color)
    Render:DrawLine(corners[6], corners[7], color)
    Render:DrawLine(corners[7], corners[8], color)
    Render:DrawLine(corners[8], corners[5], color)

end

function DrawBoundingEllipsoidRelative(obj, resolution, color)

    local model = obj:GetModel()
    local position = obj:GetPosition()
    local angle = obj:GetAngle()

    local u = position + angle * boxes[model][1]
    local v = position + angle * boxes[model][2]
    local origin = math.lerp(u, v, 0.5)

    local a = ellipsoids[model][1]
    local b = ellipsoids[model][2]
    local c = ellipsoids[model][3]

    local ellipses = {{}, {}, {}}

    for theta = 0, (2 * math.pi), (2 * math.pi) / resolution do

        table.insert(ellipses[1], origin + angle * Vector3(a * math.cos(theta), b * math.sin(theta), 0))
        table.insert(ellipses[2], origin + angle * Vector3(a * math.cos(theta), 0, c * math.sin(theta)))
        table.insert(ellipses[3], origin + angle * Vector3(0, b * math.sin(theta), c * math.cos(theta)))

        for i,u in ipairs(ellipses) do
            for j,v in ipairs(u) do
                if u[j+1] then Render:DrawLine(v, u[j+1], color) end
            end
        end

    end

end

function PositionIsInsideStaticObject(position, obj)

    local model = obj:GetModel()
    local position = vehicle:GetPosition()
    local angle = vehicle:GetAngle()

    local u = position + angle * boxes[model][1]
    local v = position + angle * boxes[model][2]
    local origin = math.lerp(u, v, 0.5)

    local coord = -angle * (position - origin)

    local x_term = (coord.x / ellipsoids[model][1])^2
    local y_term = (coord.y / ellipsoids[model][2])^2
    local z_term = (coord.z / ellipsoids[model][3])^2

    if x_term + y_term + z_term > 1 then
        return false
    else
        return true
    end

end