/// <summary>
/// Combines the surface values.
/// </summary>
/// <returns>The combined surface value.</returns>
/// <param name="surfaceA">Surface a.</param>
/// <param name="surfaceB">Surface b.</param>
/// <param name="combine">Combine.</param>
public static float Combine(float surfaceA, float surfaceB, PhysicMaterialCombine combine)
{
switch (combine)
{
case PhysicMaterialCombine.Average:
return((surfaceA + surfaceB) / 2.0f);
case PhysicMaterialCombine.Maximum:
return(HydraMathUtils.Max(surfaceA, surfaceB));
case PhysicMaterialCombine.Minimum:
return(HydraMathUtils.Min(surfaceA, surfaceB));
case PhysicMaterialCombine.Multiply:
return(surfaceA * surfaceB);
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Returns the maximum value that can be returned given the const/curve settings.
/// Note, in the case of curves, this will be inaccurate because there is no
/// nice way of getting the bounding box for an animation curve.
/// </summary>
/// <returns>The max value.</returns>
public float GetMaxValue()
{
switch (rangeMode)
{
case RangeMode.Constant:
return(m_ConstValueA);
case RangeMode.Curve:
return(m_CurveA.GetMaxValue());
case RangeMode.RandomBetweenTwoConstants:
return(HydraMathUtils.Max(m_ConstValueA, m_ConstValueB));
case RangeMode.RandomBetweenTwoCurves:
return(HydraMathUtils.Max(m_CurveA.GetMaxValue(), m_CurveB.GetMaxValue()));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Returns an approximation for the greatest value along the curve.
///
/// Unity doesn't provide a way to get the bounding box, so
/// we'll cheat and just check a certain number of samples.
/// </summary>
/// <returns>The max value.</returns>
/// <param name="extends">Extends.</param>
public static float GetMaxValue(this AnimationCurve extends)
{
float max = extends[0].value;
if (extends.length == 1)
{
return(max);
}
float startTime = extends.GetStartTime();
float lengthTime = extends.GetTimeLength();
float delta = CURVE_BOUNDS_DELTA * lengthTime;
for (int index = 1; index < CURVE_BOUNDS_SAMPLES; index++)
{
float time = startTime + delta * index;
max = HydraMathUtils.Max(max, extends.Evaluate(time));
}
return(max);
}
/// <summary>
/// Draws a cone size handle.
/// </summary>
/// <returns>The radius, angle and length in a Vector3 tuple.</returns>
/// <param name="rotation">Rotation.</param>
/// <param name="position">Position.</param>
/// <param name="radius">Radius.</param>
/// <param name="angle">Angle.</param>
/// <param name="length">Length.</param>
public static Vector3 ConeSizeHandle(Quaternion rotation, Vector3 position, float radius, float angle, float length)
{
// Base circle
radius = CircleRadiusHandle(rotation, position, radius);
// Now we need to do some maths to get the radius of the secondary circle
float secondaryRadius = radius + Mathf.Tan(Mathf.Deg2Rad * angle) * length;
// Draw the struts
Vector3 secondaryCirclePosition = position + rotation * Vector3.forward * length;
Handles.DrawLine(position + rotation * Vector3.up * radius,
secondaryCirclePosition + rotation * Vector3.up * secondaryRadius);
Handles.DrawLine(position + rotation * Vector3.down * radius,
secondaryCirclePosition + rotation * Vector3.down * secondaryRadius);
Handles.DrawLine(position + rotation * Vector3.left * radius,
secondaryCirclePosition + rotation * Vector3.left * secondaryRadius);
Handles.DrawLine(position + rotation * Vector3.right * radius,
secondaryCirclePosition + rotation * Vector3.right * secondaryRadius);
// Draw the secondary circle
float newSecondaryRadius = CircleRadiusHandle(rotation, secondaryCirclePosition, secondaryRadius);
newSecondaryRadius = HydraMathUtils.Max(newSecondaryRadius, radius);
if (!HydraMathUtils.Approximately(newSecondaryRadius, secondaryRadius))
{
float delta = newSecondaryRadius - radius;
angle = Mathf.Rad2Deg * Mathf.Atan(delta / length);
}
// Draw the dot in the middle of the secondary circle
length += NormalMoveHandle(secondaryCirclePosition, rotation, rotation * Vector3.forward);
return(new Vector3(radius, angle, length));
}
/// <summary>
/// Validates the start delay.
/// </summary>
/// <returns>The start delay.</returns>
/// <param name="delay">Delay.</param>
public static float ValidateStartDelay(float delay)
{
return(HydraMathUtils.Max(delay, 0.0f));
}
