niko
594 lines
15 KiB
C#
594 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
|
|
namespace ProBuilder2.Common
|
|
{
|
|
// Token: 0x02000003 RID: 3
|
|
public static class pbUtil
|
|
{
|
|
// Token: 0x06000004 RID: 4 RVA: 0x000020FC File Offset: 0x000004FC
|
|
public static T[] GetComponents<T>(this GameObject[] _gameObjects) where T : Component
|
|
{
|
|
List<T> list = new List<T>();
|
|
for (int i = 0; i < _gameObjects.Length; i++)
|
|
{
|
|
list.AddRange(_gameObjects[i].transform.GetComponentsInChildren<T>());
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x06000005 RID: 5 RVA: 0x0000213C File Offset: 0x0000053C
|
|
public static T[] GetComponents<T>(GameObject go) where T : Component
|
|
{
|
|
return new Transform[] { go.transform }.GetComponents<T>();
|
|
}
|
|
|
|
// Token: 0x06000006 RID: 6 RVA: 0x00002154 File Offset: 0x00000554
|
|
public static T[] GetComponents<T>(this Transform[] _transforms) where T : Component
|
|
{
|
|
List<T> list = new List<T>();
|
|
foreach (Transform transform in _transforms)
|
|
{
|
|
list.AddRange(transform.GetComponentsInChildren<T>());
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x06000007 RID: 7 RVA: 0x00002194 File Offset: 0x00000594
|
|
public static Vector3[] ToWorldSpace(this Transform t, Vector3[] v)
|
|
{
|
|
Vector3[] array = new Vector3[v.Length];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
array[i] = t.TransformPoint(v[i]);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000008 RID: 8 RVA: 0x000021E0 File Offset: 0x000005E0
|
|
public static GameObject EmptyGameObjectWithTransform(Transform t)
|
|
{
|
|
return new GameObject
|
|
{
|
|
transform =
|
|
{
|
|
position = t.position,
|
|
localRotation = t.localRotation,
|
|
localScale = t.localScale
|
|
}
|
|
};
|
|
}
|
|
|
|
// Token: 0x06000009 RID: 9 RVA: 0x00002228 File Offset: 0x00000628
|
|
public static T[] ValuesWithIndices<T>(this T[] arr, int[] indices)
|
|
{
|
|
T[] array = new T[indices.Length];
|
|
for (int i = 0; i < indices.Length; i++)
|
|
{
|
|
array[i] = arr[indices[i]];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600000A RID: 10 RVA: 0x00002264 File Offset: 0x00000664
|
|
public static List<T> ValuesWithIndices<T>(this IList<T> arr, IList<int> indices)
|
|
{
|
|
List<T> list = new List<T>();
|
|
foreach (int num in indices)
|
|
{
|
|
list.Add(arr[num]);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// Token: 0x0600000B RID: 11 RVA: 0x000022C8 File Offset: 0x000006C8
|
|
public static int[] AllIndexesOf<T>(T[] arr, T instance)
|
|
{
|
|
List<int> list = new List<int>();
|
|
for (int i = 0; i < arr.Length; i++)
|
|
{
|
|
if (arr[i].Equals(instance))
|
|
{
|
|
list.Add(i);
|
|
}
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x0600000C RID: 12 RVA: 0x0000231C File Offset: 0x0000071C
|
|
public static bool IsEqual<T>(T[] a, T[] b)
|
|
{
|
|
if (a == null && b == null)
|
|
{
|
|
return true;
|
|
}
|
|
if ((a == null && b != null) || (a != null && b == null))
|
|
{
|
|
return false;
|
|
}
|
|
if (a.Length != b.Length)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 0; i < a.Length; i++)
|
|
{
|
|
if (!a[i].Equals(b[i]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600000D RID: 13 RVA: 0x0000239C File Offset: 0x0000079C
|
|
public static T[] Add<T>(this T[] arr, T val)
|
|
{
|
|
T[] array = new T[arr.Length + 1];
|
|
Array.ConstrainedCopy(arr, 0, array, 0, arr.Length);
|
|
array[arr.Length] = val;
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600000E RID: 14 RVA: 0x000023CC File Offset: 0x000007CC
|
|
public static T[] AddRange<T>(this T[] arr, T[] val)
|
|
{
|
|
T[] array = new T[arr.Length + val.Length];
|
|
Array.ConstrainedCopy(arr, 0, array, 0, arr.Length);
|
|
Array.ConstrainedCopy(val, 0, array, arr.Length, val.Length);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600000F RID: 15 RVA: 0x00002404 File Offset: 0x00000804
|
|
public static T[] Remove<T>(this T[] arr, T val)
|
|
{
|
|
List<T> list = new List<T>(arr);
|
|
list.Remove(val);
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x06000010 RID: 16 RVA: 0x00002426 File Offset: 0x00000826
|
|
public static T[] Remove<T>(this T[] arr, IEnumerable<T> val)
|
|
{
|
|
return arr.Except(val).ToArray<T>();
|
|
}
|
|
|
|
// Token: 0x06000011 RID: 17 RVA: 0x00002434 File Offset: 0x00000834
|
|
public static T[] RemoveAt<T>(this T[] arr, int index)
|
|
{
|
|
T[] array = new T[arr.Length - 1];
|
|
int num = 0;
|
|
for (int i = 0; i < arr.Length; i++)
|
|
{
|
|
if (i != index)
|
|
{
|
|
array[num] = arr[i];
|
|
num++;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000012 RID: 18 RVA: 0x0000247C File Offset: 0x0000087C
|
|
public static T[] RemoveAt<T>(this IList<T> list, IEnumerable<int> indices)
|
|
{
|
|
List<int> list2 = new List<int>(indices);
|
|
list2.Sort();
|
|
return list.SortedRemoveAt(list2);
|
|
}
|
|
|
|
// Token: 0x06000013 RID: 19 RVA: 0x000024A0 File Offset: 0x000008A0
|
|
public static T[] SortedRemoveAt<T>(this IList<T> list, IList<int> sorted_indices)
|
|
{
|
|
int count = sorted_indices.Count;
|
|
int count2 = list.Count;
|
|
T[] array = new T[count2 - count];
|
|
int num = 0;
|
|
for (int i = 0; i < count2; i++)
|
|
{
|
|
if (num < count && sorted_indices[num] == i)
|
|
{
|
|
while (num < count && sorted_indices[num] == i)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
array[i - num] = list[i];
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000014 RID: 20 RVA: 0x00002528 File Offset: 0x00000928
|
|
public static int NearestIndexPriorToValue<T>(IList<T> sorted_list, T value) where T : IComparable<T>
|
|
{
|
|
int count = sorted_list.Count;
|
|
if (count < 1)
|
|
{
|
|
return -1;
|
|
}
|
|
pbUtil.SearchRange searchRange = new pbUtil.SearchRange(0, count - 1);
|
|
if (value.CompareTo(sorted_list[0]) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
if (value.CompareTo(sorted_list[count - 1]) > 0)
|
|
{
|
|
return count - 1;
|
|
}
|
|
while (searchRange.Valid())
|
|
{
|
|
T t = sorted_list[searchRange.Center()];
|
|
if (t.CompareTo(value) > 0)
|
|
{
|
|
searchRange.end = searchRange.Center();
|
|
}
|
|
else
|
|
{
|
|
searchRange.begin = searchRange.Center();
|
|
T t2 = sorted_list[searchRange.begin + 1];
|
|
if (t2.CompareTo(value) >= 0)
|
|
{
|
|
return searchRange.begin;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06000015 RID: 21 RVA: 0x0000260D File Offset: 0x00000A0D
|
|
public static T[] Fill<T>(T val, int length)
|
|
{
|
|
return pbUtil.FilledArray<T>(val, length);
|
|
}
|
|
|
|
// Token: 0x06000016 RID: 22 RVA: 0x00002618 File Offset: 0x00000A18
|
|
public static List<T> Fill<T>(Func<int, T> ctor, int length)
|
|
{
|
|
List<T> list = new List<T>(length);
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
list.Add(ctor(i));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// Token: 0x06000017 RID: 23 RVA: 0x0000264C File Offset: 0x00000A4C
|
|
public static T[] FilledArray<T>(T val, int length)
|
|
{
|
|
T[] array = new T[length];
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
array[i] = val;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000018 RID: 24 RVA: 0x0000267C File Offset: 0x00000A7C
|
|
public static bool ContainsMatch<T>(this T[] a, T[] b)
|
|
{
|
|
for (int i = 0; i < a.Length; i++)
|
|
{
|
|
int num = Array.IndexOf<T>(b, a[i]);
|
|
if (num > -1)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000019 RID: 25 RVA: 0x000026B7 File Offset: 0x00000AB7
|
|
public static bool ContainsMatch<T>(this T[] a, T[] b, out int index_a, out int index_b)
|
|
{
|
|
index_b = -1;
|
|
for (index_a = 0; index_a < a.Length; index_a++)
|
|
{
|
|
index_b = Array.IndexOf<T>(b, a[index_a]);
|
|
if (index_b > -1)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x0600001A RID: 26 RVA: 0x000026F0 File Offset: 0x00000AF0
|
|
public static T[] Concat<T>(this T[] x, T[] y)
|
|
{
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
int num = x.Length;
|
|
Array.Resize<T>(ref x, x.Length + y.Length);
|
|
Array.Copy(y, 0, x, num, y.Length);
|
|
return x;
|
|
}
|
|
|
|
// Token: 0x0600001B RID: 27 RVA: 0x00002740 File Offset: 0x00000B40
|
|
public static int IndexOf<T>(this List<List<T>> InList, T InValue)
|
|
{
|
|
for (int i = 0; i < InList.Count; i++)
|
|
{
|
|
for (int j = 0; j < InList[i].Count; j++)
|
|
{
|
|
T t = InList[i][j];
|
|
if (t.Equals(InValue))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Token: 0x0600001C RID: 28 RVA: 0x000027AC File Offset: 0x00000BAC
|
|
public static T[] Fill<T>(int count, Func<int, T> ctor)
|
|
{
|
|
T[] array = new T[count];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
array[i] = ctor(i);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600001D RID: 29 RVA: 0x000027E4 File Offset: 0x00000BE4
|
|
public static void AddOrAppend<T, K>(this Dictionary<T, List<K>> dictionary, T key, K value)
|
|
{
|
|
List<K> list;
|
|
if (dictionary.TryGetValue(key, out list))
|
|
{
|
|
list.Add(value);
|
|
}
|
|
else
|
|
{
|
|
dictionary.Add(key, new List<K> { value });
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001E RID: 30 RVA: 0x00002820 File Offset: 0x00000C20
|
|
public static void AddOrAppendRange<T, K>(this Dictionary<T, List<K>> dictionary, T key, List<K> value)
|
|
{
|
|
List<K> list;
|
|
if (dictionary.TryGetValue(key, out list))
|
|
{
|
|
list.AddRange(value);
|
|
}
|
|
else
|
|
{
|
|
dictionary.Add(key, value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001F RID: 31 RVA: 0x00002850 File Offset: 0x00000C50
|
|
public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
|
|
{
|
|
HashSet<TKey> knownKeys = new HashSet<TKey>();
|
|
return source.Where((TSource x) => knownKeys.Add(keySelector(x)));
|
|
}
|
|
|
|
// Token: 0x06000020 RID: 32 RVA: 0x00002887 File Offset: 0x00000C87
|
|
[Obsolete]
|
|
public static string ToFormattedString<T>(this T[] t, string _delimiter)
|
|
{
|
|
return t.ToFormattedString(_delimiter, 0, -1);
|
|
}
|
|
|
|
// Token: 0x06000021 RID: 33 RVA: 0x00002894 File Offset: 0x00000C94
|
|
[Obsolete]
|
|
public static string ToFormattedString<T>(this T[] t, string _delimiter, int entriesPerLine, int maxEntries)
|
|
{
|
|
int num = ((maxEntries <= 0) ? t.Length : Mathf.Min(t.Length, maxEntries));
|
|
if (t == null || num < 1)
|
|
{
|
|
return "Empty Array.";
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < num - 1; i++)
|
|
{
|
|
if (entriesPerLine > 0 && (i + 1) % entriesPerLine == 0)
|
|
{
|
|
stringBuilder.AppendLine(((t[i] != null) ? t[i].ToString() : "null") + _delimiter);
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(((t[i] != null) ? t[i].ToString() : "null") + _delimiter);
|
|
}
|
|
}
|
|
stringBuilder.Append((t[num - 1] != null) ? t[num - 1].ToString() : "null");
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x06000022 RID: 34 RVA: 0x000029B5 File Offset: 0x00000DB5
|
|
[Obsolete]
|
|
public static string ToFormattedString<T>(this List<T> t, string _delimiter)
|
|
{
|
|
return t.ToArray().ToFormattedString(_delimiter);
|
|
}
|
|
|
|
// Token: 0x06000023 RID: 35 RVA: 0x000029C3 File Offset: 0x00000DC3
|
|
[Obsolete]
|
|
public static string ToFormattedString<T>(this HashSet<T> t, string _delimiter)
|
|
{
|
|
return t.ToArray<T>().ToFormattedString(_delimiter);
|
|
}
|
|
|
|
// Token: 0x06000024 RID: 36 RVA: 0x000029D4 File Offset: 0x00000DD4
|
|
public static string ToString<TKey, TValue>(this Dictionary<TKey, TValue> dict)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (KeyValuePair<TKey, TValue> keyValuePair in dict)
|
|
{
|
|
stringBuilder.AppendLine(string.Format("Key: {0} Value: {1}", keyValuePair.Key, keyValuePair.Value));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x06000025 RID: 37 RVA: 0x00002A5C File Offset: 0x00000E5C
|
|
public static string ToString<T>(this IEnumerable<T> arr, string separator = ", ")
|
|
{
|
|
return string.Join(separator, arr.Select((T x) => x.ToString()).ToArray<string>());
|
|
}
|
|
|
|
// Token: 0x06000026 RID: 38 RVA: 0x00002A7C File Offset: 0x00000E7C
|
|
public static string ControlKeyString(char character)
|
|
{
|
|
if (character == '⌘')
|
|
{
|
|
return "Control";
|
|
}
|
|
if (character == '⇧')
|
|
{
|
|
return "Shift";
|
|
}
|
|
if (character == '⌥')
|
|
{
|
|
return "Alt";
|
|
}
|
|
if (character == '⎇')
|
|
{
|
|
return "Alt";
|
|
}
|
|
if (character == '⌫')
|
|
{
|
|
return "Delete";
|
|
}
|
|
return character.ToString();
|
|
}
|
|
|
|
// Token: 0x06000027 RID: 39 RVA: 0x00002AEB File Offset: 0x00000EEB
|
|
[Obsolete("ColorWithString is deprecated. Use TryParseColor.")]
|
|
public static bool ColorWithString(string value, out Color col)
|
|
{
|
|
col = Color.white;
|
|
return pbUtil.TryParseColor(value, ref col);
|
|
}
|
|
|
|
// Token: 0x06000028 RID: 40 RVA: 0x00002B00 File Offset: 0x00000F00
|
|
public static bool TryParseColor(string value, ref Color col)
|
|
{
|
|
string valid = "01234567890.,";
|
|
value = new string(value.Where((char c) => valid.Contains(c)).ToArray<char>());
|
|
string[] array = value.Split(new char[] { ',' });
|
|
if (array.Length < 4)
|
|
{
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
float num = float.Parse(array[0]);
|
|
float num2 = float.Parse(array[1]);
|
|
float num3 = float.Parse(array[2]);
|
|
float num4 = float.Parse(array[3]);
|
|
col.r = num;
|
|
col.g = num2;
|
|
col.b = num3;
|
|
col.a = num4;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000029 RID: 41 RVA: 0x00002BC0 File Offset: 0x00000FC0
|
|
public static Vector3[] StringToVector3Array(string str)
|
|
{
|
|
List<Vector3> list = new List<Vector3>();
|
|
str = str.Replace(" ", string.Empty);
|
|
string[] array = str.Split(new char[] { '\n' });
|
|
foreach (string text in array)
|
|
{
|
|
if (!text.Contains("//"))
|
|
{
|
|
string[] array3 = text.Split(new char[] { ',' });
|
|
if (array3.Length >= 3)
|
|
{
|
|
float num;
|
|
if (float.TryParse(array3[0], NumberStyles.Any, CultureInfo.InvariantCulture, out num))
|
|
{
|
|
float num2;
|
|
if (float.TryParse(array3[1], NumberStyles.Any, CultureInfo.InvariantCulture, out num2))
|
|
{
|
|
float num3;
|
|
if (float.TryParse(array3[2], NumberStyles.Any, CultureInfo.InvariantCulture, out num3))
|
|
{
|
|
list.Add(new Vector3(num, num2, num3));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x0600002A RID: 42 RVA: 0x00002CC1 File Offset: 0x000010C1
|
|
public static Vector2 DivideBy(this Vector2 v, Vector2 o)
|
|
{
|
|
return new Vector2(v.x / o.x, v.y / o.y);
|
|
}
|
|
|
|
// Token: 0x0600002B RID: 43 RVA: 0x00002CE6 File Offset: 0x000010E6
|
|
public static Vector3 DivideBy(this Vector3 v, Vector3 o)
|
|
{
|
|
return new Vector3(v.x / o.x, v.y / o.y, v.z / o.z);
|
|
}
|
|
|
|
// Token: 0x02000004 RID: 4
|
|
private struct SearchRange
|
|
{
|
|
// Token: 0x0600002D RID: 45 RVA: 0x00002D29 File Offset: 0x00001129
|
|
public SearchRange(int begin, int end)
|
|
{
|
|
this.begin = begin;
|
|
this.end = end;
|
|
}
|
|
|
|
// Token: 0x0600002E RID: 46 RVA: 0x00002D39 File Offset: 0x00001139
|
|
public bool Valid()
|
|
{
|
|
return this.end - this.begin > 1;
|
|
}
|
|
|
|
// Token: 0x0600002F RID: 47 RVA: 0x00002D4B File Offset: 0x0000114B
|
|
public int Center()
|
|
{
|
|
return this.begin + (this.end - this.begin) / 2;
|
|
}
|
|
|
|
// Token: 0x06000030 RID: 48 RVA: 0x00002D64 File Offset: 0x00001164
|
|
public override string ToString()
|
|
{
|
|
return string.Concat(new object[]
|
|
{
|
|
"{",
|
|
this.begin,
|
|
", ",
|
|
this.end,
|
|
"} : ",
|
|
this.Center()
|
|
});
|
|
}
|
|
|
|
// Token: 0x04000002 RID: 2
|
|
public int begin;
|
|
|
|
// Token: 0x04000003 RID: 3
|
|
public int end;
|
|
}
|
|
}
|
|
}
|