LiRuochen_WorkFlow/XericLibrary-OLD
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Emergency backup

Browse Source
This commit is contained in:
lrss3
2023-11-28 09:20:50 +08:00
parent f67b26667b
commit 1910b0e3f7
6 changed files with 849 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Runtime/CollisionLOD/LodBoxCollider.cs
+35 -7
View File
@@ -1,20 +1,19 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.XR;
using XericLibrary.Runtime.Type;
namespace XericLibrary.Runtime.CollisionLOD
{
/// <summary>
/// 盒体的AABB碰撞器
/// </summary>
public class LodBoxCollider : LodColliderBase
{
#region 字段属性
/// <summary>
/// 启用轴向
/// </summary>
public Bool3 EnableCollisionAxis = new Bool3(1,0,1);
#endregion
#region 生命周期
@@ -25,9 +24,38 @@ namespace XericLibrary.Runtime.CollisionLOD
#region 碰撞检测
private bool CheckCollision()
private static bool CheckCollision(LodBoxCollider box1, LodBoxCollider box2)
{
return false;
var box1max = box1.BoundSize.max;
var box1min = box1.BoundSize.min;
var box2max = box2.BoundSize.max;
var box2min = box2.BoundSize.min;
bool collidX = box1max.x >= box2min.x
&& box2max.x >= box1min.x;
bool collidY = box1max.y >= box2min.y
&& box2max.y >= box1min.y;
bool collidZ = box1max.z >= box2min.z
&& box2max.z >= box1min.z;
bool enableCollidX = box1.EnableCollisionAxis.x
&& box2.EnableCollisionAxis.x;
bool enableCollidY = box1.EnableCollisionAxis.y
&& box2.EnableCollisionAxis.y;
bool enableCollidZ = box1.EnableCollisionAxis.z
&& box2.EnableCollisionAxis.z;
if(!(enableCollidX && enableCollidY && enableCollidZ))
return false;
bool rescollidX = enableCollidX && collidX
|| (!enableCollidX && (collidY || collidZ));
bool rescollidY = enableCollidY && collidY
|| (!enableCollidY && (collidX || collidZ));
bool rescollidZ = enableCollidZ && collidZ
|| (!enableCollidZ && (collidX || collidY));
return rescollidX && rescollidY && rescollidZ;
}
#endregion
Runtime/CollisionLOD/LodSphereCollider.cs
+35 -2
View File
@@ -2,11 +2,44 @@ using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XericLibrary.Runtime.MacroLibrary;
namespace XericLibrary.Runtime.CollisionLOD
{
public class LodSphereCollider : LodColliderBase
{
}
#region 字段属性
/// <summary>
/// 半径
/// </summary>
private float radius;
#endregion
#region 碰撞检测
private static bool CheckCollision(LodSphereCollider sphere1, LodSphereCollider sphere2)
{
return Vector3.Distance(sphere1.BoundSize.center, sphere2.BoundSize.center)
< sphere1.radius + sphere2.radius;
}
private static bool CheckCollision(LodSphereCollider sphere, LodBoxCollider box)
{
/*
* 对于任意AABB和圆的最近点的计算：
* 获取圆心C与AABB中心B的偏移量D
* 用AABB的范围去限制这个偏移量
* 此时矢量总是位于AABB的边缘处
*/
return (sphere.BoundSize.center - box.BoundSize.center)
.Clamp(box.BoundSize.min, box.BoundSize.max)
.Add(box.BoundSize.center)
.Distance(sphere.BoundSize.center) <= sphere.radius;
}
#endregion
}
}
Runtime/CollisionLOD/base/LodColliderBase.cs
+6 -1
View File
@@ -57,6 +57,11 @@ namespace XericLibrary.Runtime.CollisionLOD
/// </summary>
public Bounds BoundSize;
/// <summary>
/// 启用轴向
/// </summary>
public Bool3 EnableCollisionAxis = new Bool3(1,0,1);
/// <summary>
/// 碰撞器集合
/// </summary>
@@ -98,7 +103,7 @@ namespace XericLibrary.Runtime.CollisionLOD
private void MakeLevelLinearArray(List<LodColliderBase> genList)
{
genList.Sort();
int seqIndex = 0;
int seqIndex = 1;
foreach(var item in genList)
item.SeqLevels = seqIndex++;
}
Runtime/MicroLibrary/MacroMath.cs
+190
View File
@@ -170,6 +170,196 @@ namespace XericLibrary.Runtime.MacroLibrary
public static int MinPositive(int a, int b)
=> Math.Min(Math.Max(0, a), Math.Max(0, b));
/// <summary>
/// Interpolates t between a and b to a value between 0 and 1 using a Hermite polynomial.
/// </summary>
/// <param name="a">The first value</param>
/// <param name="b">The second value</param>
/// <param name="t">The position value</param>
/// <returns>A smoothed value between 0 and 1</returns>
public static float SmoothStep(float a, float b, float t)
{
t = Mathf.Clamp01((t - a) / (b - a));
return t * t * (3f - 2f * t);
}
/// <summary>
/// Interpolates t between a and b to a value between 0 and 1.
/// </summary>
/// <param name="a">The first value</param>
/// <param name="b">The second value</param>
/// <param name="t">The position value</param>
/// <returns>Linear value between 0 and 1</returns>
public static float LinearStep(float a, float b, float t)
{
return Mathf.Clamp01((t - a) / (b - a));
}
/// <summary>
/// Wraps a value between min and max.
/// </summary>
/// <param name="value">The value to wrap</param>
/// <param name="min">The minimum value</param>
/// <param name="max">The maximum value</param>
/// <returns></returns>
public static double Wrap(double value, double min, double max)
{
double num = max - min;
num = ((num < 0.0) ? (0.0 - num) : num);
if(value < min)
{
return value + num * Math.Ceiling(Math.Abs(value / num));
}
if(value >= max)
{
return value - num * Math.Floor(Math.Abs(value / num));
}
return value;
}
/// <summary>
/// Wraps a value between min and max.
/// </summary>
/// <param name="value">The value to wrap</param>
/// <param name="min">The minimum value</param>
/// <param name="max">The maximum value</param>
/// <returns></returns>
public static float Wrap(float value, float min, float max)
{
float num = max - min;
num = (((double)num < 0.0) ? (0f - num) : num);
if(value < min)
{
return value + num * (float)Math.Ceiling(Math.Abs(value / num));
}
if(value >= max)
{
return value - num * (float)Math.Floor(Math.Abs(value / num));
}
return value;
}
/// <summary>
/// Wraps a value between min and max.
/// </summary>
/// <param name="value">The value to wrap</param>
/// <param name="min">The minimum value</param>
/// <param name="max">The maximum value</param>
/// <returns></returns>
public static int Wrap(int value, int min, int max)
{
int num = max - min;
num = ((num < 0) ? (-num) : num);
if(value < min)
{
return value + num * (Math.Abs(value / num) + 1);
}
if(value >= max)
{
return value - num * Math.Abs(value / num);
}
return value;
}
/// <summary>
/// Rounds a number based on a mininum difference.
/// </summary>
/// <param name="valueToRound">The value to round</param>
/// <param name="minDifference">The min difference</param>
/// <returns>The rounded value.</returns>
public static double RoundBasedOnMinimumDifference(double valueToRound, double minDifference)
{
if(minDifference == 0.0)
{
return DiscardLeastSignificantDecimal(valueToRound);
}
return (float)Math.Round(valueToRound, MacroMath.GetNumberOfDecimalsForMinimumDifference(minDifference), MidpointRounding.AwayFromZero);
}
/// <summary>
/// Discards the least significant demicals.
/// </summary>
/// <param name="v">The value of insignificant decimals</param>
/// <returns>Value with significant decimals</returns>
public static double DiscardLeastSignificantDecimal(double v)
{
int digits = Math.Max(0, (int)(5.0 - Math.Log10(Math.Abs(v))));
try
{
return Math.Round(v, digits);
}
catch(ArgumentOutOfRangeException)
{
return 0.0;
}
}
/// <summary>
/// Clamps and wraps an angle between two values.
/// </summary>
/// <param name="angle"></param>
/// <param name="min"></param>
/// <param name="max"></param>
/// <returns></returns>
public static float ClampWrapAngle(float angle, float min, float max)
{
float num = 360f;
float num2 = min;
float num3 = max;
float num4 = angle;
if(num2 < 0f)
{
num2 = num2 % num + num;
}
if(num3 < 0f)
{
num3 = num3 % num + num;
}
if(num4 < 0f)
{
num4 = num4 % num + num;
}
float num5 = (float)(int)(Math.Abs(min - max) / num) * num;
num3 += num5;
num4 += num5;
if(min > max)
{
num3 += num;
}
if(num4 < num2)
{
num4 = num2;
}
if(num4 > num3)
{
num4 = num3;
}
return num4;
}
/// <summary>
/// 获取最小差值的小数个数
/// </summary>
/// <param name="minDifference"></param>
/// <returns></returns>
public static int GetNumberOfDecimalsForMinimumDifference(double minDifference)
{
return Mathf.Clamp(-Mathf.FloorToInt(Mathf.Log10(Mathf.Abs((float)minDifference))), 0, 15);
}
#endregion
#region 字节控制
Runtime/MicroLibrary/Vector3Extend.cs
+583 -74
View File
@@ -113,79 +113,7 @@ namespace XericLibrary.Runtime.MacroLibrary
#endregion
#region 扩展运算
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Xonly(this Vector3 a)
=> new Vector3(
a.x,
0f,
0f
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Yonly(this Vector3 a)
=> new Vector3(
0f,
a.y,
0f
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Zonly(this Vector3 a)
=> new Vector3(
0f,
0f,
a.z
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Mode(this Vector3 a, Vector3 b)
{
return new Vector3(a.x % b.x, a.y % b.y, a.z % b.z);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Mode(this Vector3 a, float b)
{
return new Vector3(a.x % b, a.y % b, a.z % b);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Sign(this Vector3 vec)
=> new Vector3(
Math.Sign(vec.x),
Math.Sign(vec.y),
Math.Sign(vec.z)
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3Int CeilToInt(this Vector3 vec)
=> new Vector3Int((int)Mathf.Ceil(vec.x), (int)Mathf.Ceil(vec.y), (int)Mathf.Ceil(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Ceil(this Vector3 vec)
=> new Vector3(Mathf.Ceil(vec.x), Mathf.Ceil(vec.y), Mathf.Ceil(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3Int RoundToInt(this Vector3 vec)
=> new Vector3Int((int)Mathf.Round(vec.x), (int)Mathf.Round(vec.y), (int)Mathf.Round(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Round(this Vector3 vec)
=> new Vector3(Mathf.Round(vec.x), Mathf.Round(vec.y), Mathf.Round(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3Int FloorToInt(this Vector3 vec)
=> new Vector3Int((int)vec.x, (int)vec.y, (int)vec.z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Floor(this Vector3 vec)
=> new Vector3((int)vec.x, (int)vec.y, (int)vec.z);
#endregion
#region 高级运算
#region 破坏运算
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Min(this Vector3 a, Vector3 b)
@@ -256,6 +184,101 @@ namespace XericLibrary.Runtime.MacroLibrary
#endregion
#region 扩展运算
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Xonly(this Vector3 a)
=> new Vector3(
a.x,
0f,
0f
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Yonly(this Vector3 a)
=> new Vector3(
0f,
a.y,
0f
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Zonly(this Vector3 a)
=> new Vector3(
0f,
0f,
a.z
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Mode(this Vector3 a, Vector3 b)
{
return new Vector3(a.x % b.x, a.y % b.y, a.z % b.z);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Mode(this Vector3 a, float b)
{
return new Vector3(a.x % b, a.y % b, a.z % b);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Sign(this Vector3 vec)
=> new Vector3(
Math.Sign(vec.x),
Math.Sign(vec.y),
Math.Sign(vec.z)
);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3Int CeilToInt(this Vector3 vec)
=> new Vector3Int((int)Mathf.Ceil(vec.x), (int)Mathf.Ceil(vec.y), (int)Mathf.Ceil(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Ceil(this Vector3 vec)
=> new Vector3(Mathf.Ceil(vec.x), Mathf.Ceil(vec.y), Mathf.Ceil(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3Int RoundToInt(this Vector3 vec)
=> new Vector3Int((int)Mathf.Round(vec.x), (int)Mathf.Round(vec.y), (int)Mathf.Round(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Round(this Vector3 vec)
=> new Vector3(Mathf.Round(vec.x), Mathf.Round(vec.y), Mathf.Round(vec.z));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3Int FloorToInt(this Vector3 vec)
=> new Vector3Int((int)vec.x, (int)vec.y, (int)vec.z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 Floor(this Vector3 vec)
=> new Vector3((int)vec.x, (int)vec.y, (int)vec.z);
/// <summary>
/// Pows each element of the vector.
/// </summary>
/// <param name="v"></param>
/// <param name="p"></param>
/// <returns></returns>
public static Vector3 Pow(this Vector3 v, float p)
{
v.x = Mathf.Pow(v.x, p);
v.y = Mathf.Pow(v.y, p);
v.z = Mathf.Pow(v.z, p);
return v;
}
public static float Distance(this Vector3 a, Vector3 b)
=> Vector3.Distance(a, b);
#endregion
#region 特殊运算
/// <summary>
@@ -341,7 +364,493 @@ namespace XericLibrary.Runtime.MacroLibrary
#endregion
}
#region 未整理
private const float ZERO_TOLERANCE = 1E-06f;
//
// 摘要:
// Distance from a point to a line.
public static float PointDistanceToLine(Vector3 point, Vector3 a, Vector3 b)
{
return Mathf.Abs((b.x - a.x) * (a.y - point.y) - (a.x - point.x) * (b.y - a.y)) / Mathf.Sqrt(Mathf.Pow(b.x - a.x, 2f) + Mathf.Pow(b.y - a.y, 2f));
}
//
// 摘要:
// Returns a smooth value between start and end based on t.
//
// 参数:
// start:
// First point.
//
// end:
// Second point.
//
// t:
// Position between 0 and 1.
public static float Hermite(float start, float end, float t)
{
return Mathf.Lerp(start, end, t * t * (3f - 2f * t));
}
//
// 摘要:
// Returns a smooth value between start and end based on t.
//
// 参数:
// start:
// First point.
//
// end:
// Second point.
//
// t:
// Position between 0 and 1.
//
// count:
// Number of interpolations to make.
public static float StackHermite(float start, float end, float t, int count)
{
for(int i = 0; i < count; i++)
{
t = Hermite(start, end, t);
}
return t;
}
//
// 摘要:
// Returns the fractional of the value.
//
// 参数:
// value:
// The value to get the fractional of.
public static float Fract(float value)
{
return value - (float)Math.Truncate(value);
}
//
// 摘要:
// Returns the fractional of the value.
//
// 参数:
// value:
// The value to get the fractional of.
public static Vector2 Fract(Vector2 value)
{
return new Vector3(Fract(value.x), Fract(value.y));
}
//
// 摘要:
// Returns the fractional of the value.
//
// 参数:
// value:
// The value to get the fractional of.
public static Vector3 Fract(Vector3 value)
{
return new Vector3(Fract(value.x), Fract(value.y), Fract(value.z));
}
//
// 摘要:
// Returns a value based on t, that bounces faster and faster.
//
// 参数:
// t:
// The value to bounce.
public static float BounceEaseInFastOut(float t)
{
return Mathf.Cos(t * t * (float)Math.PI * 2f) * -0.5f + 0.5f;
}
//
// 摘要:
// Returns a smooth value between 0 and 1 based on t.
//
// 参数:
// t:
// Position between 0 and 1.
public static float Hermite01(float t)
{
return Mathf.Lerp(0f, 1f, t * t * (3f - 2f * t));
}
//
// 摘要:
// Returns a smooth value between 0 and 1 based on t.
//
// 参数:
// t:
// Position between 0 and 1.
//
// count:
// Number of interpolations to make.
public static float StackHermite01(float t, int count)
{
for(int i = 0; i < count; i++)
{
t = Hermite01(t);
}
return t;
}
//
// 摘要:
// Returns an unclamped linear interpolation of two vectors.
//
// 参数:
// from:
// The first vector.
//
// to:
// The second vector.
//
// amount:
// The interpolation factor.
public static Vector3 LerpUnclamped(Vector3 from, Vector3 to, float amount)
{
return from + (to - from) * amount;
}
//
// 摘要:
// Returns an unclamped linear interpolation of two vectors.
//
// 参数:
// from:
// The first vector.
//
// to:
// The second vector.
//
// amount:
// The interpolation factor.
public static Vector2 LerpUnclamped(Vector2 from, Vector2 to, float amount)
{
return from + (to - from) * amount;
}
//
// 摘要:
// Returns a value that bounces between 0 and 1 based on value.
//
// 参数:
// value:
// The value to bounce.
public static float Bounce(float value)
{
return Mathf.Abs(Mathf.Sin(value % 1f * (float)Math.PI));
}
//
// 摘要:
// Returns a value that eases in elasticly.
//
// 参数:
// value:
// The value to ease in elasticly.
//
// amplitude:
// The amplitude.
//
// length:
// The length.
public static float EaseInElastic(float value, float amplitude = 0.25f, float length = 0.6f)
{
value = Mathf.Clamp01(value);
float num = Mathf.Clamp01(value * 7.5f);
float num2 = 1f - num * num * (3f - 2f * num);
float num3 = Mathf.Pow(1f - Mathf.Sin(Mathf.Min(value * (1f - length), 0.5f) * (float)Math.PI), 2f);
float num4 = Mathf.Cos((float)Math.PI + value * 23f) * amplitude + num2 * (0f - (1f - amplitude));
return 1f + num4 * num3;
}
//
// 摘要:
// Returns a value that eases out elasticly.
//
// 参数:
// value:
// The value to ease out elasticly.
//
// amplitude:
// The amplitude.
//
// length:
// The length.
public static float EaseOutElastic(float value, float amplitude = 0.25f, float length = 0.6f)
{
return 1f - EaseInElastic(1f - value, amplitude, length);
}
//
// 摘要:
// Returns a smooth value betweeen that peaks at t=0.5 and then comes back down
// again.
//
// 参数:
// t:
// A value between 0 and 1.
public static float EaseInOut(float t)
{
t = 1f - Mathf.Abs(Mathf.Clamp01(t) * 2f - 1f);
t = t * t * (3f - 2f * t);
return t;
}
//
// 摘要:
// Clamps the value of a Vector3.
//
// 参数:
// value:
// The vector to clamp.
//
// min:
// The min value.
//
// max:
// The max value.
public static Vector3 Clamp(this Vector3 value, Vector3 min, Vector3 max)
{
return new Vector3(Mathf.Clamp(value.x, min.x, max.x), Mathf.Clamp(value.y, min.y, max.y), Mathf.Clamp(value.z, min.z, max.z));
}
//
// 摘要:
// Clamps the value of a Vector2.
//
// 参数:
// value:
// The vector to clamp.
//
// min:
// The min value.
//
// max:
// The max value.
public static Vector2 Clamp(this Vector2 value, Vector2 min, Vector2 max)
{
return new Vector2(Mathf.Clamp(value.x, min.x, max.x), Mathf.Clamp(value.y, min.y, max.y));
}
//
// 摘要:
// Computes a hash for a byte array.
//
// 参数:
// data:
// The byte array.
public static int ComputeByteArrayHash(byte[] data)
{
int num = -2128831035;
for(int i = 0; i < data.Length; i++)
{
num = (num ^ data[i]) * 16777619;
}
num += num << 13;
num ^= num >> 7;
num += num << 3;
num ^= num >> 17;
return num + (num << 5);
}
//
// 摘要:
// Gives a smooth path between a collection of points.
//
// 参数:
// path:
// The collection of point.
//
// t:
// The current position in the path. 0 is at the start of the path, 1 is at the
// end of the path.
public static Vector3 InterpolatePoints(Vector3[] path, float t)
{
t = Mathf.Clamp01(t * (1f - 1f / (float)path.Length));
int b = path.Length - 1;
int num = Mathf.FloorToInt(t * (float)path.Length);
float num2 = t * (float)path.Length - (float)num;
Vector3 vector = path[Mathf.Max(0, --num)];
Vector3 vector2 = path[Mathf.Min(num + 1, b)];
Vector3 vector3 = path[Mathf.Min(num + 2, b)];
Vector3 vector4 = path[Mathf.Min(num + 3, b)];
return 0.5f * ((-vector + 3f * vector2 - 3f * vector3 + vector4) * (num2 * num2 * num2) + (2f * vector - 5f * vector2 + 4f * vector3 - vector4) * (num2 * num2) + (-vector + vector3) * num2 + 2f * vector2);
}
//
// 摘要:
// Checks if two given lines intersect with one another and returns the intersection
// point (if any) in an out parameter. Source: http://stackoverflow.com/questions/3746274/line-intersection-with-aabb-rectangle.
// Edited to implement Cohen-Sutherland type pruning for efficiency.
//
// 参数:
// a1:
// Starting point of line a.
//
// a2:
// Ending point of line a.
//
// b1:
// Starting point of line b.
//
// b2:
// Ending point of line b.
//
// intersection:
// The out parameter which contains the intersection point if there was any.
//
// 返回结果:
// True if the two lines intersect, otherwise false.
public static bool LineIntersectsLine(Vector2 a1, Vector2 a2, Vector2 b1, Vector2 b2, out Vector2 intersection)
{
intersection = Vector2.zero;
Vector2 vector = new Vector2((b1.x < b2.x) ? b1.x : b2.x, (b1.y > b2.y) ? b1.y : b2.y);
Vector2 vector2 = new Vector2((b1.x > b2.x) ? b1.x : b2.x, (b1.y < b2.y) ? b1.y : b2.y);
if((a1.x < vector.x && a2.x < vector.x) || (a1.y > vector.y && a2.y > vector.y) || (a1.x > vector2.x && a2.x > vector2.x) || (a1.y < vector2.y && a2.y < vector2.y))
{
return false;
}
Vector2 vector3 = a2 - a1;
Vector2 vector4 = b2 - b1;
float num = vector3.x * vector4.y - vector3.y * vector4.x;
if(num == 0f)
{
return false;
}
Vector2 vector5 = b1 - a1;
float num2 = (vector5.x * vector4.y - vector5.y * vector4.x) / num;
if(num2 < 0f || num2 > 1f)
{
return false;
}
float num3 = (vector5.x * vector3.y - vector5.y * vector3.x) / num;
if(num3 < 0f || num3 > 1f)
{
return false;
}
intersection = a1 + num2 * vector3;
return true;
}
//
// 摘要:
// Returns the collision point between two infinite lines.
public static Vector2 InfiniteLineIntersect(Vector2 ps1, Vector2 pe1, Vector2 ps2, Vector2 pe2)
{
float num = pe1.y - ps1.y;
float num2 = ps1.x - pe1.x;
float num3 = num * ps1.x + num2 * ps1.y;
float num4 = pe2.y - ps2.y;
float num5 = ps2.x - pe2.x;
float num6 = num4 * ps2.x + num5 * ps2.y;
float num7 = num * num5 - num4 * num2;
if(num7 == 0f)
{
throw new Exception("Lines are parallel");
}
return new Vector2((num5 * num3 - num2 * num6) / num7, (num * num6 - num4 * num3) / num7);
}
//
// 摘要:
// Distance from line to plane.
//
// 参数:
// planeOrigin:
// Position of the plane.
//
// planeNormal:
// Surface normal of the plane.
//
// lineOrigin:
// Origin of the line.
//
// lineDirectionNormalized:
// Line direction normal.
public static float LineDistToPlane(Vector3 planeOrigin, Vector3 planeNormal, Vector3 lineOrigin, Vector3 lineDirectionNormalized)
{
return Vector3.Dot(lineDirectionNormalized, planeNormal) * Vector3.Distance(planeOrigin, lineOrigin);
}
//
// 摘要:
// Distance from ray to plane.
//
// 参数:
// ray:
// The ray.
//
// plane:
// The plane.
public static float RayDistToPlane(Ray ray, Plane plane)
{
float num = Vector3.Dot(plane.normal, ray.direction);
if(Mathf.Abs(num) < 1E-06f)
{
return 0f;
}
float num2 = Vector3.Dot(plane.normal, ray.origin);
return (0f - plane.distance - num2) / num;
}
//
// 摘要:
// Rotates a Vector2 by an angle.
//
// 参数:
// point:
// The point to rotate.
//
// degrees:
// The angle to rotate.
public static Vector2 RotatePoint(Vector2 point, float degrees)
{
float f = degrees * ((float)Math.PI / 180f);
float num = Mathf.Cos(f);
float num2 = Mathf.Sin(f);
return new Vector2(num * point.x - num2 * point.y, num2 * point.x + num * point.y);
}
//
// 摘要:
// Rotates a Vector2 around a point by an angle..
//
// 参数:
// point:
// The point to rotate.
//
// around:
// The point to rotate around.
//
// degrees:
// The angle to rotate.
public static Vector2 RotatePoint(Vector2 point, Vector2 around, float degrees)
{
float f = degrees * ((float)Math.PI / 180f);
float num = Mathf.Cos(f);
float num2 = Mathf.Sin(f);
return new Vector2(num * (point.x - around.x) - num2 * (point.y - around.y) + around.x, num2 * (point.x - around.x) + num * (point.y - around.y) + around.y);
}
#endregion
}
Runtime/Type/Enum/Orientation.cs
-30
View File
@@ -1,30 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace XericLibrary.Runtime.Type
{
/// <summary>
/// 矢量方位
/// </summary>
public enum Vector3Orientation
{
Front,
Back,
Up,
Down,
Left,
Right,
}
/// <summary>
/// 矢量方位
/// </summary>
public enum Vector2Orientation
{
UpFront,
DownBack,
Left,
Right,
}
}