--!native
--!optimize 2
-- Compiled with roblox-ts v3.0.0
local TS = _G[script]
local ArrayTools = TS.import(script, script.Parent, "array_tools").ArrayTools
local Vector3Tools = {}
do
	local _container = Vector3Tools
	local clamp = math.clamp
	local min = math.min
	--[[
		*
			 * clamps the vector between the numbers
			 
	]]
	local function Clamp(vector, min, max)
		return Vector3.new(clamp(vector.X, min, max), clamp(vector.Y, min, max), clamp(vector.Z, min, max))
	end
	_container.Clamp = Clamp
	local function ClampWithVector(vector, min_vector, max_vector)
		return Vector3.new(math.clamp(vector.X, min_vector.X, max_vector.X), math.clamp(vector.Y, min_vector.Y, max_vector.Y), math.clamp(vector.Z, min_vector.Z, max_vector.Z))
	end
	_container.ClampWithVector = ClampWithVector
	local function LerpWithMagnitude(start_vector, target_vector, step)
		local _target_vector = target_vector
		local _start_vector = start_vector
		local difference = _target_vector - _start_vector
		--if difference is 0 return the target;
		if difference.Magnitude == 0 then
			return target_vector
		end
		step = min(difference.Magnitude, step)
		--add difference with magnitude of step;
		local _start_vector_1 = start_vector
		local _unit = difference.Unit
		local _step = step
		return _start_vector_1 + (_unit * _step)
	end
	_container.LerpWithMagnitude = LerpWithMagnitude
	local function ClampMagnitude(vector, min, max)
		if vector.Magnitude > max or vector.Magnitude < min then
			--sets the magnitude to clamped value;
			local _unit = vector.Unit
			local _arg0 = clamp(vector.Magnitude, min, max)
			vector = _unit * _arg0
		end
		return vector
	end
	_container.ClampMagnitude = ClampMagnitude
	--[[
		*
			 * @returns mirrors a around b
			 
	]]
	local function Mirror(a, b)
		local _b = b
		local _b_1 = b
		local _a = a
		return _b + (_b_1 - _a)
	end
	_container.Mirror = Mirror
	--[[
		*
			 * will not return nan if Vector3.zero is normalized
			 
	]]
	local function Normalize(vector)
		return if vector:FuzzyEq(Vector3.zero, 1e-5) then Vector3.zero else vector.Unit
	end
	_container.Normalize = Normalize
	local function Slerp(start, finish, alpha)
		start = Normalize(start)
		finish = Normalize(finish)
		local dot = math.clamp(start:Dot(finish), -1, 1)
		local theta = math.acos(dot) * alpha
		local _finish = finish
		local _arg0 = start * dot
		local relative_vector = Normalize(_finish - _arg0)
		local _start = start
		local _arg0_1 = math.cos(theta)
		local _arg0_2 = math.sin(theta)
		local _arg0_3 = relative_vector * _arg0_2
		return _start * _arg0_1 + _arg0_3
	end
	_container.Slerp = Slerp
	local function InverseSlerp(a, b, x)
		local a_dot_b = a:Dot(b)
		local a_cross_b = a:Cross(b)
		local a_dot_c = a:Dot(x)
		local a_cross_c = a:Cross(x)
		local projection_angle = math.atan2(a_cross_b:Dot(a_cross_c), a_cross_b.Magnitude * a_dot_c)
		local full_angle = math.atan2(a_cross_b.Magnitude, a_dot_b)
		return projection_angle / full_angle
	end
	_container.InverseSlerp = InverseSlerp
	local function InverseLerp(a, b, x)
		local _a = a
		local _x = x
		local a_1 = _a - _x
		local _b = b
		local _a_1 = a
		local b_1 = _b - _a_1
		local t = a_1:Dot(b_1) / b_1:Dot(b_1)
		return t
	end
	_container.InverseLerp = InverseLerp
	--[[
		*
			 *
			 * @param vector
			 * @returns turns every nan component into 0
			 
	]]
	local function FixVector3(vector)
		if vector == vector then
			return vector
		end
		return Vector3.new(if vector.X == vector.X then vector.X else 0, if vector.Y == vector.Y then vector.Y else 0, if vector.Z == vector.Z then vector.Z else 0)
	end
	_container.FixVector3 = FixVector3
	local vector3_inf = Vector3.new(math.huge, math.huge, math.huge)
	_container.vector3_inf = vector3_inf
	local vector3_neg_inf = vector3_inf * (-1)
	_container.vector3_neg_inf = vector3_neg_inf
	local vector_list_split_size = 1000
	--[[
		*
			 * same as Vector3.Min but not limited by limitation of unpack
			 * @param vector
			 
	]]
	local function Min(vectors)
		if #vectors == 0 then
			return Vector3.zero
		end
		if #vectors <= vector_list_split_size then
			return vector3_inf:Min(unpack(vectors))
		end
		local splitted_vector_arrays = ArrayTools.SplitArray(vectors, vector_list_split_size)
		local min = vector3_inf
		for _, vector_array in splitted_vector_arrays do
			min = min:Min(unpack(vector_array))
		end
		return min
	end
	_container.Min = Min
	--[[
		*
			 * same as Vector3.Min but not limited by limitation of unpack
			 * @param vectors
			 * @returns
			 
	]]
	local function Max(vectors)
		if #vectors == 0 then
			return Vector3.zero
		end
		if #vectors <= vector_list_split_size then
			return vector3_neg_inf:Max(unpack(vectors))
		end
		local splitted_vector_arrays = ArrayTools.SplitArray(vectors, vector_list_split_size)
		local max = vector3_neg_inf
		for _, vector_array in splitted_vector_arrays do
			max = max:Max(unpack(vector_array))
		end
		return max
	end
	_container.Max = Max
	local random = Random.new()
	local function RandomVector(min, max)
		if min ~= nil or max ~= nil then
			local _arg0 = min ~= nil
			assert(_arg0, "Min is nil")
			local _arg0_1 = max ~= nil
			assert(_arg0_1, "Max is nil")
		end
		if min == nil then
			return random:NextUnitVector()
		end
		local _max = max
		local _min = min
		local size = _max - _min
		local _min_1 = min
		local _vector3 = Vector3.new(math.random(), math.random(), math.random())
		local _arg0 = size * _vector3
		return _min_1 + _arg0
	end
	_container.RandomVector = RandomVector
end
return {
	Vector3Tools = Vector3Tools,
}