/// <summary>
/// Makes vectors normalized and orthognal to each other.
/// </summary>
/// <param name="normal">Vector to normalize</param>
/// <param name="tangent">Tangent to make orthogonal to normal</param>
public static void OrthoNormalize(ref Vector3 normal, ref DebugVector3 tangent)
{
DebugVector3 n = (DebugVector3)normal;
OrthoNormalize(ref n, ref tangent);
normal = n.v3;
}
/// <summary>
/// Makes vectors normalized and orthognal to each other.
/// </summary>
/// <param name="normal">Vector to normalize</param>
/// <param name="tangent">Tangent to make orthogonal to normal</param>
public static void OrthoNormalize(ref DebugVector3 normal, ref Vector3 tangent)
{
DebugVector3 t = (DebugVector3)tangent;
OrthoNormalize(ref normal, ref t);
tangent = t.v3;
}
/// <summary>
/// Makes vectors normalized and orthognal to each other.
/// </summary>
/// <param name="normal">Vector to normalize</param>
/// <param name="tangent">Tangent to make orthogonal to normal</param>
public static void OrthoNormalize(ref DebugVector3 normal, ref DebugVector3 tangent)
{
DrawVector(origin, origin + normal, DrawVectorColorA, DrawPermanentChangeTime);
DrawVector(origin, origin + tangent, DrawVectorColorB, DrawPermanentChangeTime);
Vector3.OrthoNormalize(ref normal.v3, ref tangent.v3);
DrawVector(origin, origin + normal, DrawResultColor, DrawPermanentChangeTime);
DrawVector(origin, origin + tangent, DrawResultColor, DrawPermanentChangeTime);
}
// Update is called once per frame
void Update()
{
DebugVector3.ShowOperatorResult = ShowOperatorResult;
DebugVector3.ShowOperatorInputs = ShowOperatorInputs;
DebugVector3.ShowMethodInputs = ShowMethodInputs;
DebugVector3.ShowMethodResult = ShowMethodResult;
DebugVector3.origin = transform.position;
Vector3 t = Vector3.one;
DebugVector3 result = DebugVector3.zero;
float f = 0.0f;
if (DoDebugAdd)
{
result = vector1 + vector2;
}
if (DoDebugMinus)
{
result = vector1 - vector2;
}
if (DoDebugMultiply)
{
result = vector1 * MultiplierDivider;
}
if (DoDebugDivide)
{
result = vector1 / MultiplierDivider;
}
if (DoAngle)
{
f = DebugVector3.Angle(vector1, vector2);
}
if (DoClampMagnitude)
{
result = DebugVector3.ClampMagnitude(vector1, MaxMagnitude);
}
if (DoDebugCross)
{
result = DebugVector3.Cross(vector1, vector2);
}
if (DoDebugDistance)
{
f = DebugVector3.Distance(vector1, vector2);
}
if (DoDebugDot)
{
f = DebugVector3.Dot(vector1, vector2);
}
if (DoDebugLerp)
{
result = DebugVector3.Lerp(vector1, vector2, Lerp);
}
if (DoDebugLerpUnclamped)
{
result = DebugVector3.LerpUnclamped(vector1, vector2, Lerp);
}
if (DoDebugMax)
{
result = DebugVector3.Max(vector1, vector2);
}
if (DoDebugMin)
{
result = DebugVector3.Min(vector1, vector2);
}
if (DoDebugMoveTowards)
{
result = DebugVector3.MoveTowards(vector1, vector2, MoveTowardsDistance);
}
if (DoDebugStaticNormalize)
{
result = DebugVector3.Normalize(vector1);
}
if (DoDebugInstNormalize)
{
vector1.Normalize();
DoDebugInstNormalize = false;
}
if (DoOrthoNormalize)
{
DebugVector3.OrthoNormalize(ref vector1, ref vector2);
DoOrthoNormalize = false;
}
if (DoDebugProject)
{
result = DebugVector3.Project(vector1, vector2);
}
if (DoDebugProjectOnPlane)
{
result = (DebugVector3)DebugVector3.ProjectOnPlane(vector1, PlaneNormal);
}
if (DoDebugReflect)
{
result = DebugVector3.Reflect(vector1, PlaneNormal);
}
if (DoDebugRotateTowards)
{
result = DebugVector3.RotateTowards(vector1, vector2, MaxRotateDelta, MaxMagnitudeDelta);
}
if (DoDebugScale)
{
result = DebugVector3.Scale(vector1, vector2);
}
if (DoDebugSignedAngle)
{
f = DebugVector3.SignedAngle(vector1, vector2, signedAngleAxis);
}
if (DoDebugSlerp)
{
result = DebugVector3.Slerp(vector1, vector2, Slerp);
}
if (DoDebugSlerpUnclamped)
{
result = DebugVector3.SlerpUnclamped(vector1, vector2, Slerp);
}
if (DoDebugSmoothDamp)
{
result = DebugVector3.SmoothDamp(vector1, vector2, ref SmoothDampVel, SmoothDampTime);
}
// ignore errors with not using result and f.
if (result != Vector3.zero)
{
}
if (f > 0)
{
}
}
/// <summary>
/// Gradually changes a vector towards a desired goal over time. The vector is smoothed by some spring-damper function which will never overshoot.
/// </summary>
/// <param name="current">Current position</param>
/// <param name="target">Target position</param>
/// <param name="currentVelocity">Current velocity, value is modified by the function every time you call it</param>
/// <param name="smoothTime">Approximately the time it will take to reach the target, smaller reaches target faster</param>
/// <param name="maxSpeed">Optionally allows you to clamp maximum speed</param>
/// <returns>Next smoothed position from current position to target</returns>
public static DebugVector3 SmoothDamp(Vector3 current, Vector3 target,
ref DebugVector3 currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity)
{
return(SmoothDamp(current, target, ref currentVelocity.v3, smoothTime, maxSpeed, Time.deltaTime));
}