UGCProjects/SoloKing/Script/Global/Tool/VectorHelper.lua

VectorHelper = {}

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.Dot(v1, v2)
    return v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z
end

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.Mul(v1, v2)
    if type(v1) == 'number' and type(v2) == 'number' then
        return nil
    elseif type(v1) == 'number' then
        return VectorHelper.Mul(v2, v1)
    else
        return VectorHelper.ToLuaTable(Vector.New(v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z))
    end
end

---@param v1 FVector
---@param S float
---@return FVector
function VectorHelper.MulScalar(v1, S)
    return VectorHelper.ToLuaTable(Vector.New(v1.X * S, v1.Y * S, v1.Z * S))
end

---@param v1 FVector2D
---@param S float
---@return FVector
function VectorHelper.MulScalar2D(v1, S)
    return VectorHelper.ToLuaTable(Vector2D.New(v1.X * S, v1.Y * S))
end

---@param v1 FVector
---@param number float
---@return FVector
function VectorHelper.MulNumber(v1, number)
    return VectorHelper.ToLuaTable(Vector.New(v1.X * number, v1.Y * number, v1.Z * number))
end

function VectorHelper.MulNumber2D(v, n)
    return VectorHelper.ToLuaTable(Vector2D.New(v.X * n, v.Y * n));
end

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.Sub(v1, v2)
    return VectorHelper.ToLuaTable(Vector.New(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z))
end

---@param v FVector|table<int32, float>
function VectorHelper.MakeVector(v)
    --if type(v) == 'number' then return { X = v, Y = v, Z = v, }; end
    if table.isEmpty(v) then return {}; end
    if v.X == nil and v.Y == nil and v.Z == nil then
        -- 此时是 table
        return { X = v[1], Y = v[2], Z = v[3] };
    else
        return VectorHelper.ToLuaTable(v);
    end
end

function VectorHelper.MakeVector1(v)
    return { X = v, Y = v, Z = v, }
end

function VectorHelper.MakeVector(v1, v2, ...)
    return { X = v1, Y = v2, Z = ... };
end

---@param v FVector|table<int32, float>|FRotator
function VectorHelper.MakeRotator(v)
    if table.isEmpty(v) then return {}; end
    if v.X == nil and v.Y == nil and v.Z == nil and v.Pitch == nil and v.Roll == nil and v.Yaw == nil then
        -- 此时是 table
        return { Pitch = v[1], Roll = v[2], Yaw = v[3] };
    elseif v.X ~= nil or v.Y ~= nil or v.Z ~= nil then
        return VectorHelper.VecToRot(v);
    else
        return { Pitch = v.Pitch, Roll = v.Roll, Yaw = v.Yaw };
    end
end

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.Sub2D(v1, v2)
    return VectorHelper.ToLuaTable(Vector2D.New(v1.X - v2.X, v1.Y - v2.Y));
end

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.Add(v1, v2)
    return VectorHelper.ToLuaTable(Vector.New(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z));
end

---@param v FVector
---@param c number
---@return FVector
function VectorHelper.AddNum(v, c)
    return VectorHelper.ToLuaTable(Vector.New(v.X + c, v.Y + c, v.Z + c));
end

---@param v1 FVector2D
---@param v2 FVector2D
---@return FVector2D
function VectorHelper.Add2D(v1, v2)
    return VectorHelper.ToLuaTable(Vector2D.New(v1.X + v2.X, v1.Y + v2.Y));
end

---@param v1 FVector2D
---@param s float
---@return FVector2D
function VectorHelper.Div2DScalar(v1, s)
    return VectorHelper.ToLuaTable(Vector2D.New(v1.X / s , v1.Y / s));
end

---@param v FVector
---@return string
function VectorHelper.ToString(v)
    return string.format("(%.2f,%.2f,%.2f)", v.X, v.Y, v.Z);
end

---@param v FVector2D
---@return string
function VectorHelper.ToStringInt2D(v)
    if v == nil then return "[X=Nil,Y=Nil]"; end
    return string.format("[%d, %d]", v.X, v.Y);
end

---@param v FVector
---@return string
function VectorHelper.ToIntString(v)
    return "(" .. tostring(math.floor(v.X)) .. "," .. tostring( math.floor(v.Y)) .. "," .. tostring(math.floor(v.Z)) .. ")";
end

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.Cross(v1, v2)
    return Vector.New(v1.Y * v2.Z - v2.Y * v1.Z,
        v1.Z * v2.X - v2.Z * v1.X,
        v1.X * v2.Y - v2.X * v1.Y)
end

---@param v1 FVector
---@param v2 FVector
---@return float
function VectorHelper.GetDistance(v1, v2)
    if v1 == nil or v2 == nil then return 0 end
    if v1.X == nil or v2.X == nil then return 0 end
    if v1.Y == nil or v2.Y == nil then return 0 end
    local disZ = v1.Z - v2.Z
    if (v1.Z == nil and v2.Z == nil) then
        disZ = 0;
    elseif v1.Z ~= nil and v2.Z ~= nil then
        disZ = v1.Z - v2.Z
    else
        return 0;
    end
    return math.sqrt((v1.X - v2.X) ^ 2 + (v1.Y - v2.Y) ^ 2 + disZ ^ 2)
end

---@param v1 FVector2D
---@param v2 FVector2D
---@return float
function VectorHelper.GetDistance2D(v1, v2)
    if v1 == nil or v2 == nil then return 0 end
    if v1.X == nil or v2.X == nil then return 0 end
    if v1.Y == nil or v2.Y == nil then return 0 end
    return math.sqrt((v1.X - v2.X) ^ 2 + (v1.Y - v2.Y) ^ 2);
end

---@param a1 AActor
---@param a2 AActor
function VectorHelper.GetActorDis(a1, a2)
    return VectorHelper.GetDistance(a1:K2_GetActorLocation(), a2:K2_GetActorLocation());
end

---@param a1 AActor
---@param a2 AActor
function VectorHelper.GetActorDis2D(a1, a2)
    return VectorHelper.GetDistance2D(a1:K2_GetActorLocation(), a2:K2_GetActorLocation());
end

--- 归一化方法
---@param v FVector
function VectorHelper.Normalize(v)
    local Len = VectorHelper.Length(v)
    return VectorHelper.MulNumber(v, 1./VectorHelper.Length(v));
end

--- 归一化方法
---@param v FVector2D
function VectorHelper.Normalize2D(v)
    return VectorHelper.MulNumber2D(v, 1./VectorHelper.Length2D(v));
end

---@param v FVector
---@return FVector
function VectorHelper.LengthSquared(v)
    return v.X ^ 2 + v.Y ^ 2 + v.Z ^ 2;
end

---@param v FVector2D
---@return float
function VectorHelper.LengthSquared2D(v)
    return v.X ^ 2 + v.Y ^ 2;
end

---@param v FVector
---@return FVector
function VectorHelper.Length(v)
    return math.sqrt(VectorHelper.LengthSquared(v));
end

---@param v FVector2D
---@return FVector
function VectorHelper.Length2D(v)
    return math.sqrt(VectorHelper.LengthSquared2D(v));
end

---@param v FVector
---@return FVector
function VectorHelper.ToLuaTable(v)
    return { X = v.X, Y = v.Y, Z = v.Z };
end

---@param v FVector2D
---@return FVector
function VectorHelper.ToLuaTable2D(v)
    return { X = v.X, Y = v.Y, };
end

---@param v FRotator
---@return FRotator
function VectorHelper.RotToLuaTable(v)
    return { Roll=v.Roll, Pitch=v.Pitch, Yaw=v.Yaw };
end

---@param v FVector
---@return FRotator
function VectorHelper.VecToRot(v)
    return { Roll = v.X, Pitch = v.Y, Yaw = v.Z };
end

---@param v FRotator
---@param v1 FRotator
function VectorHelper.RotAdd(v, v1)
    return { Roll = v.Roll + v1.Roll, Pitch = v.Pitch + v1.Pitch, Yaw = v.Yaw + v1.Yaw, };
end

---@param v FRotator
---@return string
function VectorHelper.RotToString(v)
    return string.format("Roll=%.2f, Pitch=%.2f, Yaw=%.2f", v.Roll, v.Pitch, v.Yaw);
end

---@param v1 FVector
---@param v2 FVector
---@return FVector
function VectorHelper.GetMiddlePoint(v1, v2)
    return {X = (v1.X + v2.X) / 2, Y = (v1.Y + v2.Y) / 2,Z = (v1.Z + v2.Z) / 2};
end

---@param v1 FVector
---@param v2 FVector
---@return boolean
function VectorHelper.Equal(v1, v2)
    return (v1.X == v2.X and v1.Y == v2.Y and v1.Z == v2.Z);
end

---@param v table
function VectorHelper.Copy(v)
    if v == nil then return nil; end
    return { X = v.X, Y = v.Y, Z = v.Z, Roll = v.Roll, Yaw = v.Raw, Pitch = v.Pitch };
end


--- 计算两点之间连线与Y轴的夹角
---@param PosA FVector
---@param PosB FVector
---@return float
function VectorHelper.GetAngleByPos(PosA,PosB)
    local P = { X = PosB.X - PosA.X, X = PosB.X - PosA.X, };
    local Dis = VectorHelper.GetDistance2D(PosA, PosB);
    local FAngle = math.acos (P.Y/ Dis);
    if( P.X < 0) then FAngle = 2 * math.pi - FAngle; end
    local Angle = FAngle * 180 / math.pi;
    Angle = Angle > 0 and (90 - Angle) or (90 + math.abs(Angle));
    return Angle;
end

---@return FRotator
function VectorHelper.RotZero()
    return { Roll = 0, Pitch = 0, Yaw = 0, };
end

---@return FVector
function VectorHelper.VectorZero()
    return VectorHelper.MakeVector1(0)
end

---@return FVector
function VectorHelper.ScaleOne()
    return VectorHelper.MakeVector1(1);
end

---@param InActor AActor
---@return FVector
function VectorHelper.GetActorLocation(InActor)
    local Loc = InActor:K2_GetActorLocation();
    return VectorHelper.ToLuaTable(Loc);
end

---@param InActor AActor
---@return FRotator
function VectorHelper.GetActorRotation(InActor)
    local Rot = InActor:K2_GetActorRotation();
    return VectorHelper.RotToLuaTable(Rot);
end

function VectorHelper.ArrToColor(v)
    if v[4] == nil then
        return { R = v[1], G = v[2], B = v[3], A = 1 };
    else
        return { R = v[1], G = v[2], B = v[3], A = v[4] };
    end
end

function VectorHelper:VecToColor(v)
    return { R = v.X, G = v.Y, B = v.Z, A = 1 };
end

return VectorHelper;