omath/tests/lua/source_engine_tests.lua

local function approx(a, b, eps) return math.abs(a - b) < (eps or 1e-4) end

local function make_camera()
    local pos    = omath.Vec3.new(0, 0, 0)
    local pitch  = omath.source.PitchAngle.from_degrees(0)
    local yaw    = omath.source.YawAngle.from_degrees(0)
    local roll   = omath.source.RollAngle.from_degrees(0)
    local angles = omath.source.ViewAngles.new(pitch, yaw, roll)
    local vp     = omath.opengl.ViewPort.new(1920, 1080)
    local fov    = omath.source.FieldOfView.from_degrees(90)
    return omath.source.Camera.new(pos, angles, vp, fov, 0.1, 1000)
end

-- PitchAngle
function Source_PitchAngle_from_degrees()
    assert(omath.source.PitchAngle.from_degrees(45):as_degrees() == 45)
end

function Source_PitchAngle_clamping_max()
    assert(omath.source.PitchAngle.from_degrees(100):as_degrees() == 89)
end

function Source_PitchAngle_clamping_min()
    assert(omath.source.PitchAngle.from_degrees(-100):as_degrees() == -89)
end

function Source_PitchAngle_from_radians()
    assert(approx(omath.source.PitchAngle.from_radians(math.pi / 4):as_degrees(), 45))
end

function Source_PitchAngle_as_radians()
    assert(approx(omath.source.PitchAngle.from_degrees(0):as_radians(), 0))
end

function Source_PitchAngle_sin()
    assert(approx(omath.source.PitchAngle.from_degrees(30):sin(), 0.5))
end

function Source_PitchAngle_cos()
    assert(approx(omath.source.PitchAngle.from_degrees(60):cos(), 0.5))
end

function Source_PitchAngle_tan()
    assert(approx(omath.source.PitchAngle.from_degrees(45):tan(), 1.0))
end

function Source_PitchAngle_addition()
    local c = omath.source.PitchAngle.from_degrees(20) + omath.source.PitchAngle.from_degrees(15)
    assert(c:as_degrees() == 35)
end

function Source_PitchAngle_addition_clamped()
    local c = omath.source.PitchAngle.from_degrees(80) + omath.source.PitchAngle.from_degrees(20)
    assert(c:as_degrees() == 89)
end

function Source_PitchAngle_subtraction()
    local c = omath.source.PitchAngle.from_degrees(50) - omath.source.PitchAngle.from_degrees(20)
    assert(c:as_degrees() == 30)
end

function Source_PitchAngle_unary_minus()
    assert((-omath.source.PitchAngle.from_degrees(45)):as_degrees() == -45)
end

function Source_PitchAngle_equal_to()
    local a = omath.source.PitchAngle.from_degrees(45)
    assert(a == omath.source.PitchAngle.from_degrees(45))
    assert(not (a == omath.source.PitchAngle.from_degrees(30)))
end

function Source_PitchAngle_to_string()
    assert(tostring(omath.source.PitchAngle.from_degrees(45)) == "45deg")
end

-- YawAngle
function Source_YawAngle_from_degrees()
    assert(omath.source.YawAngle.from_degrees(90):as_degrees() == 90)
end

function Source_YawAngle_normalization()
    assert(approx(omath.source.YawAngle.from_degrees(200):as_degrees(), -160))
end

-- RollAngle
function Source_RollAngle_from_degrees()
    assert(omath.source.RollAngle.from_degrees(45):as_degrees() == 45)
end

-- FieldOfView
function Source_FieldOfView_from_degrees()
    assert(omath.source.FieldOfView.from_degrees(90):as_degrees() == 90)
end

function Source_FieldOfView_clamping()
    assert(omath.source.FieldOfView.from_degrees(200):as_degrees() == 180)
end

-- ViewAngles
function Source_ViewAngles_new()
    local angles = omath.source.ViewAngles.new(
        omath.source.PitchAngle.from_degrees(30),
        omath.source.YawAngle.from_degrees(90),
        omath.source.RollAngle.from_degrees(0))
    assert(angles.pitch:as_degrees() == 30)
    assert(angles.yaw:as_degrees() == 90)
    assert(angles.roll:as_degrees() == 0)
end

function Source_ViewAngles_field_mutation()
    local angles = omath.source.ViewAngles.new(
        omath.source.PitchAngle.from_degrees(0),
        omath.source.YawAngle.from_degrees(0),
        omath.source.RollAngle.from_degrees(0))
    angles.pitch = omath.source.PitchAngle.from_degrees(45)
    assert(angles.pitch:as_degrees() == 45)
end

-- Camera
function Source_Camera_constructor()
    assert(make_camera() ~= nil)
end

function Source_Camera_get_set_origin()
    local cam = make_camera()
    cam:set_origin(omath.Vec3.new(1, 2, 3))
    local o = cam:get_origin()
    assert(approx(o.x, 1) and approx(o.y, 2) and approx(o.z, 3))
end

function Source_Camera_get_set_near_plane()
    local cam = make_camera()
    cam:set_near_plane(0.5)
    assert(approx(cam:get_near_plane(), 0.5))
end

function Source_Camera_get_set_far_plane()
    local cam = make_camera()
    cam:set_far_plane(500)
    assert(approx(cam:get_far_plane(), 500))
end

function Source_Camera_get_set_fov()
    local cam = make_camera()
    cam:set_field_of_view(omath.source.FieldOfView.from_degrees(60))
    assert(approx(cam:get_field_of_view():as_degrees(), 60))
end

function Source_Camera_get_set_view_angles()
    local cam = make_camera()
    cam:set_view_angles(omath.source.ViewAngles.new(
        omath.source.PitchAngle.from_degrees(30),
        omath.source.YawAngle.from_degrees(90),
        omath.source.RollAngle.from_degrees(0)))
    assert(approx(cam:get_view_angles().pitch:as_degrees(), 30))
    assert(approx(cam:get_view_angles().yaw:as_degrees(), 90))
end

function Source_Camera_look_at()
    local cam = make_camera()
    cam:look_at(omath.Vec3.new(10, 0, 0))
    assert(cam:get_view_angles() ~= nil)
end

function Source_Camera_get_forward()
    local fwd = make_camera():get_forward()
    assert(approx(fwd:length(), 1.0))
end

function Source_Camera_get_right()
    assert(approx(make_camera():get_right():length(), 1.0))
end

function Source_Camera_get_up()
    assert(approx(make_camera():get_up():length(), 1.0))
end

function Source_Camera_get_view_matrix()
    local view = make_camera():get_view_matrix()
    assert(view ~= nil)
    assert(view:row_count() == 4 and view:columns_count() == 4)
end

function Source_Camera_get_projection_matrix()
    local projection = make_camera():get_projection_matrix()
    assert(projection ~= nil)
    assert(projection:at(0, 0) > 0 and projection:at(1, 1) > 0)
end

function Source_Camera_get_view_projection_matrix()
    local view_projection = make_camera():get_view_projection_matrix()
    assert(view_projection ~= nil)
    assert(view_projection:row_count() == 4 and view_projection:columns_count() == 4)
end

function Source_Camera_extract_projection_params()
    local projection = make_camera():get_projection_matrix()
    local fov, aspect_ratio = omath.source.Camera.extract_projection_params(projection)
    assert(fov ~= nil)
    assert(approx(aspect_ratio, 1920 / 1080))
end

function Source_Camera_calc_view_angles_from_view_matrix()
    local cam = make_camera()
    local view = cam:get_view_matrix()
    local angles = omath.source.Camera.calc_view_angles_from_view_matrix(view)
    assert(approx(angles.pitch:as_degrees(), 0))
    assert(approx(angles.yaw:as_degrees(), 0))
end

function Source_Camera_calc_origin_from_view_matrix()
    local cam = make_camera()
    cam:set_origin(omath.Vec3.new(1, 2, 3))
    local origin = omath.source.Camera.calc_origin_from_view_matrix(cam:get_view_matrix())
    assert(approx(origin.x, 1) and approx(origin.y, 2) and approx(origin.z, 3))
end

function Source_Camera_world_to_screen_success()
    local cam = make_camera()
    cam:look_at(omath.Vec3.new(1, 0, 0))
    local screen, err = cam:world_to_screen(omath.Vec3.new(5, 0, 0))
    assert(screen ~= nil, "expected screen pos, got: " .. tostring(err))
end

function Source_Camera_world_to_screen_error()
    local cam = make_camera()
    cam:look_at(omath.Vec3.new(1, 0, 0))
    local screen, err = cam:world_to_screen(omath.Vec3.new(-100, 0, 0))
    assert(screen == nil and err ~= nil)
end

function Source_Camera_screen_to_world()
    local cam = make_camera()
    cam:look_at(omath.Vec3.new(1, 0, 0))
    local world, err = cam:screen_to_world(omath.Vec3.new(960, 540, 1))
    assert(world ~= nil, "expected world pos, got: " .. tostring(err))
end