Game/Fishing2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

设置相关功能

Browse Source
This commit is contained in:
BobSong
2025-05-30 20:38:41 +08:00
parent e9ad74b3ea
commit d152b5d000
223 changed files with 793 additions and 38907 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
Assets/Scripts/Utils/Extends/Extensions.cs Normal file
View File

@@ -0,0 +1,263 @@
using UnityEngine;
namespace NBF
{
public static class Extensions
{
/// <summary>
/// Return the square of the given value.
/// </summary>
public static int square(this int value)
{
return value * value;
}
/// <summary>
/// Return the square of the given value.
/// </summary>
public static float square(this float value)
{
return value * value;
}
/// <summary>
/// Checks whether value is near to zero within a tolerance.
/// </summary>
public static bool isZero(this float value)
{
const float kTolerance = 0.0000000001f;
return Mathf.Abs(value) < kTolerance;
}
/// <summary>
/// Returns a copy of given vector with only X component of the vector.
/// </summary>
public static Vector3 onlyX(this Vector3 vector3)
{
vector3.y = 0.0f;
vector3.z = 0.0f;
return vector3;
}
/// <summary>
/// Returns a copy of given vector with only Y component of the vector.
/// </summary>
public static Vector3 onlyY(this Vector3 vector3)
{
vector3.x = 0.0f;
vector3.z = 0.0f;
return vector3;
}
/// <summary>
/// Returns a copy of given vector with only Z component of the vector.
/// </summary>
public static Vector3 onlyZ(this Vector3 vector3)
{
vector3.x = 0.0f;
vector3.y = 0.0f;
return vector3;
}
/// <summary>
/// Returns a copy of given vector with only X and Y components of the vector.
/// </summary>
public static Vector3 onlyXY(this Vector3 vector3)
{
vector3.z = 0.0f;
return vector3;
}
/// <summary>
/// Returns a copy of given vector with only X and Z components of the vector.
/// </summary>
public static Vector3 onlyXZ(this Vector3 vector3)
{
vector3.y = 0.0f;
return vector3;
}
/// <summary>
/// Checks whether vector is near to zero within a tolerance.
/// </summary>
public static bool isZero(this Vector2 vector2)
{
return vector2.sqrMagnitude < 9.99999943962493E-11;
}
/// <summary>
/// Checks whether vector is near to zero within a tolerance.
/// </summary>
public static bool isZero(this Vector3 vector3)
{
return vector3.sqrMagnitude < 9.99999943962493E-11;
}
/// <summary>
/// Checks whether vector is exceeding the magnitude within a small error tolerance.
/// </summary>
public static bool isExceeding(this Vector3 vector3, float magnitude)
{
// Allow 1% error tolerance, to account for numeric imprecision.
const float kErrorTolerance = 1.01f;
return vector3.sqrMagnitude > magnitude * magnitude * kErrorTolerance;
}
/// <summary>
/// Returns a copy of given vector with a magnitude of 1,
/// and outs its magnitude before normalization.
///
/// If the vector is too small to be normalized a zero vector will be returned.
/// </summary>
public static Vector3 normalized(this Vector3 vector3, out float magnitude)
{
magnitude = vector3.magnitude;
if (magnitude > 9.99999974737875E-06)
return vector3 / magnitude;
magnitude = 0.0f;
return Vector3.zero;
}
/// <summary>
/// Dot product of two vectors.
/// </summary>
public static float dot(this Vector3 vector3, Vector3 otherVector3)
{
return Vector3.Dot(vector3, otherVector3);
}
/// <summary>
/// Returns a copy of given vector projected onto normal vector.
/// </summary>
public static Vector3 projectedOn(this Vector3 thisVector, Vector3 normal)
{
return Vector3.Project(thisVector, normal);
}
/// <summary>
/// Returns a copy of given vector projected onto a plane defined by a normal orthogonal to the plane.
/// </summary>
public static Vector3 projectedOnPlane(this Vector3 thisVector, Vector3 planeNormal)
{
return Vector3.ProjectOnPlane(thisVector, planeNormal);
}
/// <summary>
/// Returns a copy of given vector with its magnitude clamped to maxLength.
/// </summary>
public static Vector3 clampedTo(this Vector3 vector3, float maxLength)
{
return Vector3.ClampMagnitude(vector3, maxLength);
}
/// <summary>
/// Returns a copy of given vector perpendicular to other vector.
/// </summary>
public static Vector3 perpendicularTo(this Vector3 thisVector, Vector3 otherVector)
{
return Vector3.Cross(thisVector, otherVector).normalized;
}
/// <summary>
/// Returns a copy of given vector adjusted to be tangent to a specified surface normal relatively to given up axis.
/// </summary>
public static Vector3 tangentTo(this Vector3 thisVector, Vector3 normal, Vector3 up)
{
Vector3 r = thisVector.perpendicularTo(up);
Vector3 t = normal.perpendicularTo(r);
return t * thisVector.magnitude;
}
/// <summary>
/// Transforms a vector to be relative to given transform.
/// If isPlanar == true, the transform will be applied on the plane defined by world up axis.
/// </summary>
public static Vector3 relativeTo(this Vector3 vector3, Transform relativeToThis, bool isPlanar = true)
{
Vector3 forward = relativeToThis.forward;
if (isPlanar)
{
Vector3 upAxis = Vector3.up;
forward = forward.projectedOnPlane(upAxis);
if (forward.isZero())
forward = Vector3.ProjectOnPlane(relativeToThis.up, upAxis);
}
Quaternion q = Quaternion.LookRotation(forward);
return q * vector3;
}
/// <summary>
/// Transforms a vector to be relative to given transform.
/// If isPlanar == true, the transform will be applied on the plane defined by upAxis.
/// </summary>
public static Vector3 relativeTo(this Vector3 vector3, Transform relativeToThis, Vector3 upAxis, bool isPlanar = true)
{
Vector3 forward = relativeToThis.forward;
if (isPlanar)
{
forward = Vector3.ProjectOnPlane(forward, upAxis);
if (forward.isZero())
forward = Vector3.ProjectOnPlane(relativeToThis.up, upAxis);
}
Quaternion q = Quaternion.LookRotation(forward, upAxis);
return q * vector3;
}
/// <summary>
/// Clamps the given quaternion pitch rotation between the given minPitchAngle and maxPitchAngle.
/// </summary>
public static Quaternion clampPitch(this Quaternion quaternion, float minPitchAngle, float maxPitchAngle)
{
quaternion.x /= quaternion.w;
quaternion.y /= quaternion.w;
quaternion.z /= quaternion.w;
quaternion.w = 1.0f;
float pitch = Mathf.Clamp(2.0f * Mathf.Rad2Deg * Mathf.Atan(quaternion.x), minPitchAngle, maxPitchAngle);
quaternion.x = Mathf.Tan(pitch * 0.5f * Mathf.Deg2Rad);
return quaternion;
}
}
}

3
Assets/Scripts/Utils/Extends/Extensions.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 3308733cfb774828bac0a5740bedd645
timeCreated: 1748527846

163
Assets/Scripts/Utils/VectorUtil.cs Normal file
View File

@@ -0,0 +1,163 @@
using UnityEngine;
namespace NBF
{
public static class VectorUtil
{
/// <summary>
/// Returns Value mapped from one range into another.
/// </summary>
public static float Remap(float inA, float inB, float outA, float outB, float value)
{
float t = Mathf.InverseLerp(inA, inB, value);
return Mathf.Lerp(outA, outB, t);
}
/// <summary>
/// Return the square of the given value.
/// </summary>
public static float Square(float value)
{
return value * value;
}
/// <summary>
/// Returns the direction adjusted to be tangent to a specified surface normal relatively to given up axis.
/// </summary>
public static Vector3 GetTangent(Vector3 direction, Vector3 normal, Vector3 up)
{
Vector3 right = direction.perpendicularTo(up);
return normal.perpendicularTo(right);
}
/// <summary>
/// Projects a given point onto the plane defined by plane origin and plane normal.
/// </summary>
public static Vector3 ProjectPointOnPlane(Vector3 point, Vector3 planeOrigin, Vector3 planeNormal)
{
Vector3 toPoint = point - planeOrigin;
Vector3 toPointProjected = Vector3.Project(toPoint, planeNormal);
return point - toPointProjected;
}
/// <summary>
/// Clamps given angle within min - max range.
/// </summary>
public static float ClampAngle(float a, float min, float max)
{
while (max < min)
max += 360.0f;
while (a > max)
a -= 360.0f;
while (a < min)
a += 360.0f;
return a > max ? a - (max + min) * 0.5f < 180.0f ? max : min : a;
}
/// <summary>
/// Returns Angle in the range (0, 360)
/// </summary>
public static float ClampAngle(float angle)
{
// returns angle in the range (-360, 360)
angle = angle % 360.0f;
if (angle < 0.0f)
{
// shift to (0, 360) range
angle += 360.0f;
}
return angle;
}
/// <summary>
/// Return angle in range -180 to 180
/// </summary>
public static float NormalizeAngle(float angle)
{
// returns angle in the range (0, 360)
angle = ClampAngle(angle);
if (angle > 180.0f)
{
// shift to (-180,180)
angle -= 360.0f;
}
return angle;
}
/// <summary>
/// Clamps the given angle into 0 - 360 degrees range.
/// </summary>
private static float Clamp0360(float eulerAngles)
{
float result = eulerAngles - Mathf.CeilToInt(eulerAngles / 360f) * 360f;
if (result < 0) result += 360f;
return result;
}
/// <summary>
/// Returns a new rotation angle (interpolated) clamped in the range (0.0f , 360.0f)
/// </summary>
public static float FixedTurn(float current, float target, float maxDegreesDelta)
{
if (maxDegreesDelta == 0.0f)
return Clamp0360(current);
if (maxDegreesDelta >= 360.0f)
return Clamp0360(target);
float result = Clamp0360(current);
current = result;
target = Clamp0360(target);
if (current > target)
{
if (current - target < 180.0f)
result -= Mathf.Min(current - target, Mathf.Abs(maxDegreesDelta));
else
result += Mathf.Min(target + 360.0f - current, Mathf.Abs(maxDegreesDelta));
}
else
{
if (target - current < 180.0f)
result += Mathf.Min(target - current, Mathf.Abs(maxDegreesDelta));
else
result -= Mathf.Min(current + 360.0f - target, Mathf.Abs(maxDegreesDelta));
}
return Clamp0360(result);
}
/// <summary>
/// Frame Rate Independent Damping.
/// Source: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
/// </summary>
public static float Damp(float a, float b, float lambda, float dt)
{
return Mathf.Lerp(a, b, 1.0f - Mathf.Exp(-lambda * dt));
}
/// <summary>
/// Frame Rate Independent Damping.
/// Source: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
/// </summary>
public static Vector3 Damp(Vector3 a, Vector3 b, float lambda, float dt)
{
return Vector3.Lerp(a, b, 1.0f - Mathf.Exp(-lambda * dt));
}
}
}

3
Assets/Scripts/Utils/VectorUtil.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 8f5057ebeaca4f7bbcf90011280b93b8
timeCreated: 1748528114