735 lines
18 KiB
C#
735 lines
18 KiB
C#
//======= Copyright (c) Valve Corporation, All rights reserved. ===============
|
|
//
|
|
// Purpose: Utility functions used in several places
|
|
//
|
|
//=============================================================================
|
|
|
|
using UnityEngine;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
|
|
namespace Valve.VR.InteractionSystem
|
|
{
|
|
//-------------------------------------------------------------------------
|
|
public static class Util
|
|
{
|
|
public const float FeetToMeters = 0.3048f;
|
|
public const float FeetToCentimeters = 30.48f;
|
|
public const float InchesToMeters = 0.0254f;
|
|
public const float InchesToCentimeters = 2.54f;
|
|
public const float MetersToFeet = 3.28084f;
|
|
public const float MetersToInches = 39.3701f;
|
|
public const float CentimetersToFeet = 0.0328084f;
|
|
public const float CentimetersToInches = 0.393701f;
|
|
public const float KilometersToMiles = 0.621371f;
|
|
public const float MilesToKilometers = 1.60934f;
|
|
|
|
//-------------------------------------------------
|
|
// Remap num from range 1 to range 2
|
|
//-------------------------------------------------
|
|
public static float RemapNumber( float num, float low1, float high1, float low2, float high2 )
|
|
{
|
|
return low2 + ( num - low1 ) * ( high2 - low2 ) / ( high1 - low1 );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static float RemapNumberClamped( float num, float low1, float high1, float low2, float high2 )
|
|
{
|
|
return Mathf.Clamp( RemapNumber( num, low1, high1, low2, high2 ), Mathf.Min( low2, high2 ), Mathf.Max( low2, high2 ) );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static float Approach( float target, float value, float speed )
|
|
{
|
|
float delta = target - value;
|
|
|
|
if ( delta > speed )
|
|
value += speed;
|
|
else if ( delta < -speed )
|
|
value -= speed;
|
|
else
|
|
value = target;
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector3 BezierInterpolate3( Vector3 p0, Vector3 c0, Vector3 p1, float t )
|
|
{
|
|
Vector3 p0c0 = Vector3.Lerp( p0, c0, t );
|
|
Vector3 c0p1 = Vector3.Lerp( c0, p1, t );
|
|
|
|
return Vector3.Lerp( p0c0, c0p1, t );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector3 BezierInterpolate4( Vector3 p0, Vector3 c0, Vector3 c1, Vector3 p1, float t )
|
|
{
|
|
Vector3 p0c0 = Vector3.Lerp( p0, c0, t );
|
|
Vector3 c0c1 = Vector3.Lerp( c0, c1, t );
|
|
Vector3 c1p1 = Vector3.Lerp( c1, p1, t );
|
|
|
|
Vector3 x = Vector3.Lerp( p0c0, c0c1, t );
|
|
Vector3 y = Vector3.Lerp( c0c1, c1p1, t );
|
|
|
|
//Debug.DrawRay(p0, Vector3.forward);
|
|
//Debug.DrawRay(c0, Vector3.forward);
|
|
//Debug.DrawRay(c1, Vector3.forward);
|
|
//Debug.DrawRay(p1, Vector3.forward);
|
|
|
|
//Gizmos.DrawSphere(p0c0, 0.5F);
|
|
//Gizmos.DrawSphere(c0c1, 0.5F);
|
|
//Gizmos.DrawSphere(c1p1, 0.5F);
|
|
//Gizmos.DrawSphere(x, 0.5F);
|
|
//Gizmos.DrawSphere(y, 0.5F);
|
|
|
|
return Vector3.Lerp( x, y, t );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector3 Vector3FromString( string szString )
|
|
{
|
|
string[] szParseString = szString.Substring( 1, szString.Length - 1 ).Split( ',' );
|
|
|
|
float x = float.Parse( szParseString[0] );
|
|
float y = float.Parse( szParseString[1] );
|
|
float z = float.Parse( szParseString[2] );
|
|
|
|
Vector3 vReturn = new Vector3( x, y, z );
|
|
|
|
return vReturn;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector2 Vector2FromString( string szString )
|
|
{
|
|
string[] szParseString = szString.Substring( 1, szString.Length - 1 ).Split( ',' );
|
|
|
|
float x = float.Parse( szParseString[0] );
|
|
float y = float.Parse( szParseString[1] );
|
|
|
|
Vector3 vReturn = new Vector2( x, y );
|
|
|
|
return vReturn;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static float Normalize( float value, float min, float max )
|
|
{
|
|
float normalizedValue = ( value - min ) / ( max - min );
|
|
|
|
return normalizedValue;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector3 Vector2AsVector3( Vector2 v )
|
|
{
|
|
return new Vector3( v.x, 0.0f, v.y );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector2 Vector3AsVector2( Vector3 v )
|
|
{
|
|
return new Vector2( v.x, v.z );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static float AngleOf( Vector2 v )
|
|
{
|
|
float fDist = v.magnitude;
|
|
|
|
if ( v.y >= 0.0f )
|
|
{
|
|
return Mathf.Acos( v.x / fDist );
|
|
}
|
|
else
|
|
{
|
|
return Mathf.Acos( -v.x / fDist ) + Mathf.PI;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static float YawOf( Vector3 v )
|
|
{
|
|
float fDist = v.magnitude;
|
|
|
|
if ( v.z >= 0.0f )
|
|
{
|
|
return Mathf.Acos( v.x / fDist );
|
|
}
|
|
else
|
|
{
|
|
return Mathf.Acos( -v.x / fDist ) + Mathf.PI;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void Swap<T>( ref T lhs, ref T rhs )
|
|
{
|
|
T temp = lhs;
|
|
lhs = rhs;
|
|
rhs = temp;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void Shuffle<T>( T[] array )
|
|
{
|
|
for ( int i = array.Length - 1; i > 0; i-- )
|
|
{
|
|
int r = UnityEngine.Random.Range( 0, i );
|
|
Swap( ref array[i], ref array[r] );
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void Shuffle<T>( List<T> list )
|
|
{
|
|
for ( int i = list.Count - 1; i > 0; i-- )
|
|
{
|
|
int r = UnityEngine.Random.Range( 0, i );
|
|
T temp = list[i];
|
|
list[i] = list[r];
|
|
list[r] = temp;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static int RandomWithLookback( int min, int max, List<int> history, int historyCount )
|
|
{
|
|
int index = UnityEngine.Random.Range( min, max - history.Count );
|
|
|
|
for ( int i = 0; i < history.Count; i++ )
|
|
{
|
|
if ( index >= history[i] )
|
|
{
|
|
index++;
|
|
}
|
|
}
|
|
|
|
history.Add( index );
|
|
|
|
if ( history.Count > historyCount )
|
|
{
|
|
history.RemoveRange( 0, history.Count - historyCount );
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Transform FindChild( Transform parent, string name )
|
|
{
|
|
if ( parent.name == name )
|
|
return parent;
|
|
|
|
foreach ( Transform child in parent )
|
|
{
|
|
var found = FindChild( child, name );
|
|
if ( found != null )
|
|
return found;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static bool IsNullOrEmpty<T>( T[] array )
|
|
{
|
|
if ( array == null )
|
|
return true;
|
|
|
|
if ( array.Length == 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static bool IsValidIndex<T>( T[] array, int i )
|
|
{
|
|
if ( array == null )
|
|
return false;
|
|
|
|
return ( i >= 0 ) && ( i < array.Length );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static bool IsValidIndex<T>( List<T> list, int i )
|
|
{
|
|
if ( list == null || list.Count == 0 )
|
|
return false;
|
|
|
|
return ( i >= 0 ) && ( i < list.Count );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static int FindOrAdd<T>( List<T> list, T item )
|
|
{
|
|
int index = list.IndexOf( item );
|
|
|
|
if ( index == -1 )
|
|
{
|
|
list.Add( item );
|
|
index = list.Count - 1;
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static List<T> FindAndRemove<T>( List<T> list, System.Predicate<T> match )
|
|
{
|
|
List<T> retVal = list.FindAll( match );
|
|
list.RemoveAll( match );
|
|
return retVal;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static T FindOrAddComponent<T>( GameObject gameObject ) where T : Component
|
|
{
|
|
T component = gameObject.GetComponent<T>();
|
|
if ( component )
|
|
return component;
|
|
|
|
return gameObject.AddComponent<T>();
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void FastRemove<T>( List<T> list, int index )
|
|
{
|
|
list[index] = list[list.Count - 1];
|
|
list.RemoveAt( list.Count - 1 );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void ReplaceGameObject<T, U>( T replace, U replaceWith )
|
|
where T : MonoBehaviour
|
|
where U : MonoBehaviour
|
|
{
|
|
replace.gameObject.SetActive( false );
|
|
replaceWith.gameObject.SetActive( true );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void SwitchLayerRecursively( Transform transform, int fromLayer, int toLayer )
|
|
{
|
|
if ( transform.gameObject.layer == fromLayer )
|
|
transform.gameObject.layer = toLayer;
|
|
|
|
int childCount = transform.childCount;
|
|
for ( int i = 0; i < childCount; i++ )
|
|
{
|
|
SwitchLayerRecursively( transform.GetChild( i ), fromLayer, toLayer );
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void DrawCross( Vector3 origin, Color crossColor, float size )
|
|
{
|
|
Vector3 line1Start = origin + ( Vector3.right * size );
|
|
Vector3 line1End = origin - ( Vector3.right * size );
|
|
|
|
Debug.DrawLine( line1Start, line1End, crossColor );
|
|
|
|
Vector3 line2Start = origin + ( Vector3.up * size );
|
|
Vector3 line2End = origin - ( Vector3.up * size );
|
|
|
|
Debug.DrawLine( line2Start, line2End, crossColor );
|
|
|
|
Vector3 line3Start = origin + ( Vector3.forward * size );
|
|
Vector3 line3End = origin - ( Vector3.forward * size );
|
|
|
|
Debug.DrawLine( line3Start, line3End, crossColor );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void ResetTransform( Transform t, bool resetScale = true )
|
|
{
|
|
t.localPosition = Vector3.zero;
|
|
t.localRotation = Quaternion.identity;
|
|
if ( resetScale )
|
|
{
|
|
t.localScale = new Vector3( 1f, 1f, 1f );
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Vector3 ClosestPointOnLine( Vector3 vA, Vector3 vB, Vector3 vPoint )
|
|
{
|
|
var vVector1 = vPoint - vA;
|
|
var vVector2 = ( vB - vA ).normalized;
|
|
|
|
var d = Vector3.Distance( vA, vB );
|
|
var t = Vector3.Dot( vVector2, vVector1 );
|
|
|
|
if ( t <= 0 )
|
|
return vA;
|
|
|
|
if ( t >= d )
|
|
return vB;
|
|
|
|
var vVector3 = vVector2 * t;
|
|
|
|
var vClosestPoint = vA + vVector3;
|
|
|
|
return vClosestPoint;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void AfterTimer( GameObject go, float _time, System.Action callback, bool trigger_if_destroyed_early = false )
|
|
{
|
|
AfterTimer_Component afterTimer_component = go.AddComponent<AfterTimer_Component>();
|
|
afterTimer_component.Init( _time, callback, trigger_if_destroyed_early );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void SendPhysicsMessage( Collider collider, string message, SendMessageOptions sendMessageOptions )
|
|
{
|
|
Rigidbody rb = collider.attachedRigidbody;
|
|
if ( rb && rb.gameObject != collider.gameObject )
|
|
{
|
|
rb.SendMessage( message, sendMessageOptions );
|
|
}
|
|
|
|
collider.SendMessage( message, sendMessageOptions );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void SendPhysicsMessage( Collider collider, string message, object arg, SendMessageOptions sendMessageOptions )
|
|
{
|
|
Rigidbody rb = collider.attachedRigidbody;
|
|
if ( rb && rb.gameObject != collider.gameObject )
|
|
{
|
|
rb.SendMessage( message, arg, sendMessageOptions );
|
|
}
|
|
|
|
collider.SendMessage( message, arg, sendMessageOptions );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void IgnoreCollisions( GameObject goA, GameObject goB )
|
|
{
|
|
Collider[] goA_colliders = goA.GetComponentsInChildren<Collider>();
|
|
Collider[] goB_colliders = goB.GetComponentsInChildren<Collider>();
|
|
|
|
if ( goA_colliders.Length == 0 || goB_colliders.Length == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach ( Collider cA in goA_colliders )
|
|
{
|
|
foreach ( Collider cB in goB_colliders )
|
|
{
|
|
if ( cA.enabled && cB.enabled )
|
|
{
|
|
Physics.IgnoreCollision( cA, cB, true );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static IEnumerator WrapCoroutine( IEnumerator coroutine, System.Action onCoroutineFinished )
|
|
{
|
|
while ( coroutine.MoveNext() )
|
|
{
|
|
yield return coroutine.Current;
|
|
}
|
|
|
|
onCoroutineFinished();
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static Color ColorWithAlpha( this Color color, float alpha )
|
|
{
|
|
color.a = alpha;
|
|
return color;
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// Exits the application if running standalone, or stops playback if running in the editor.
|
|
//-------------------------------------------------
|
|
public static void Quit()
|
|
{
|
|
#if UNITY_EDITOR
|
|
UnityEditor.EditorApplication.isPlaying = false;
|
|
#else
|
|
// NOTE: The recommended call for exiting a Unity app is UnityEngine.Application.Quit(), but as
|
|
// of 5.1.0f3 this was causing the application to crash. The following works without crashing:
|
|
System.Diagnostics.Process.GetCurrentProcess().Kill();
|
|
#endif
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// Truncate floats to the specified # of decimal places when you want easier-to-read numbers without clamping to an int
|
|
//-------------------------------------------------
|
|
public static decimal FloatToDecimal( float value, int decimalPlaces = 2 )
|
|
{
|
|
return Math.Round( (decimal)value, decimalPlaces );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static T Median<T>( this IEnumerable<T> source )
|
|
{
|
|
if ( source == null )
|
|
{
|
|
throw new ArgumentException( "Argument cannot be null.", "source" );
|
|
}
|
|
|
|
int count = source.Count();
|
|
if ( count == 0 )
|
|
{
|
|
throw new InvalidOperationException( "Enumerable must contain at least one element." );
|
|
}
|
|
|
|
return source.OrderBy( x => x ).ElementAt( count / 2 );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void ForEach<T>( this IEnumerable<T> source, Action<T> action )
|
|
{
|
|
if ( source == null )
|
|
{
|
|
throw new ArgumentException( "Argument cannot be null.", "source" );
|
|
}
|
|
|
|
foreach ( T value in source )
|
|
{
|
|
action( value );
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
// In some cases Unity/C# don't correctly interpret the newline control character (\n).
|
|
// This function replaces every instance of "\\n" with the actual newline control character.
|
|
//-------------------------------------------------
|
|
public static string FixupNewlines( string text )
|
|
{
|
|
bool newLinesRemaining = true;
|
|
|
|
while ( newLinesRemaining )
|
|
{
|
|
int CIndex = text.IndexOf( "\\n" );
|
|
|
|
if ( CIndex == -1 )
|
|
{
|
|
newLinesRemaining = false;
|
|
}
|
|
else
|
|
{
|
|
text = text.Remove( CIndex - 1, 3 );
|
|
text = text.Insert( CIndex - 1, "\n" );
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
#if ( UNITY_5_4 )
|
|
public static float PathLength( NavMeshPath path )
|
|
#else
|
|
public static float PathLength( UnityEngine.AI.NavMeshPath path )
|
|
#endif
|
|
{
|
|
if ( path.corners.Length < 2 )
|
|
return 0;
|
|
|
|
Vector3 previousCorner = path.corners[0];
|
|
float lengthSoFar = 0.0f;
|
|
int i = 1;
|
|
while ( i < path.corners.Length )
|
|
{
|
|
Vector3 currentCorner = path.corners[i];
|
|
lengthSoFar += Vector3.Distance( previousCorner, currentCorner );
|
|
previousCorner = currentCorner;
|
|
i++;
|
|
}
|
|
return lengthSoFar;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static bool HasCommandLineArgument( string argumentName )
|
|
{
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
for ( int i = 0; i < args.Length; i++ )
|
|
{
|
|
if ( args[i].Equals( argumentName ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static int GetCommandLineArgValue( string argumentName, int nDefaultValue )
|
|
{
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
for ( int i = 0; i < args.Length; i++ )
|
|
{
|
|
if ( args[i].Equals( argumentName ) )
|
|
{
|
|
if ( i == ( args.Length - 1 ) ) // Last arg, return default
|
|
{
|
|
return nDefaultValue;
|
|
}
|
|
|
|
return System.Int32.Parse( args[i + 1] );
|
|
}
|
|
}
|
|
|
|
return nDefaultValue;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static float GetCommandLineArgValue( string argumentName, float flDefaultValue )
|
|
{
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
for ( int i = 0; i < args.Length; i++ )
|
|
{
|
|
if ( args[i].Equals( argumentName ) )
|
|
{
|
|
if ( i == ( args.Length - 1 ) ) // Last arg, return default
|
|
{
|
|
return flDefaultValue;
|
|
}
|
|
|
|
return (float)Double.Parse( args[i + 1] );
|
|
}
|
|
}
|
|
|
|
return flDefaultValue;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
public static void SetActive( GameObject gameObject, bool active )
|
|
{
|
|
if ( gameObject != null )
|
|
{
|
|
gameObject.SetActive( active );
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
// The version of Path.Combine() included with Unity can only combine two paths.
|
|
// This version mimics the modern .NET version, which allows for any number of
|
|
// paths to be combined.
|
|
//-------------------------------------------------
|
|
public static string CombinePaths( params string[] paths )
|
|
{
|
|
if ( paths.Length == 0 )
|
|
{
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
string combinedPath = paths[0];
|
|
for ( int i = 1; i < paths.Length; i++ )
|
|
{
|
|
combinedPath = Path.Combine( combinedPath, paths[i] );
|
|
}
|
|
|
|
return combinedPath;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//Component used by the static AfterTimer function
|
|
//-------------------------------------------------------------------------
|
|
[System.Serializable]
|
|
public class AfterTimer_Component : MonoBehaviour
|
|
{
|
|
private System.Action callback;
|
|
private float triggerTime;
|
|
private bool timerActive = false;
|
|
private bool triggerOnEarlyDestroy = false;
|
|
|
|
//-------------------------------------------------
|
|
public void Init( float _time, System.Action _callback, bool earlydestroy )
|
|
{
|
|
triggerTime = _time;
|
|
callback = _callback;
|
|
triggerOnEarlyDestroy = earlydestroy;
|
|
timerActive = true;
|
|
StartCoroutine( Wait() );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
private IEnumerator Wait()
|
|
{
|
|
yield return new WaitForSeconds( triggerTime );
|
|
timerActive = false;
|
|
callback.Invoke();
|
|
Destroy( this );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
void OnDestroy()
|
|
{
|
|
if ( timerActive )
|
|
{
|
|
//If the component or its GameObject get destroyed before the timer is complete, clean up
|
|
StopCoroutine( Wait() );
|
|
timerActive = false;
|
|
|
|
if ( triggerOnEarlyDestroy )
|
|
{
|
|
callback.Invoke();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|