Misaki/Misaki.HighPerformance
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor and enhance math and utility libraries
Some checks failed
Publish NuGet Packages / publish (push) Failing after 3m12s
Details

Browse Source 
Refactored `sincos` usage across `quaternion` and `random` to use `out` parameters for improved performance. Enhanced `random` struct with updated random direction generation methods.

Added new benchmarks in `MathematicsBenchmark` for vector operations, including SIMD-based `f4` struct. Downgraded target framework to `net9.0` for compatibility.

Introduced `ReadOnlyUnsafeCollection` for low-level memory management. Added utility methods in `CollectionUtility` for span creation and optimized list operations.

Renamed `MemoryUtilities` to `MemoryUtility` and updated all references. Enhanced `ObjectPool` with `Rent` and `TryRent` methods. Enabled `AllowUnsafeBlocks` and AOT compatibility in project configuration.

Performed general code cleanup, including removal of unused methods, improved formatting, and alignment with modern coding practices.
This commit is contained in:
Misaki
2025-11-04 14:53:01 +09:00
parent 081103372f
commit 49e1171781
38 changed files with 5149 additions and 1259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
Misaki.HighPerformance.Mathematics/quaternion.cs
View File

@@ -106,8 +106,8 @@ public partial struct quaternion : IEquatable<quaternion>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static quaternion AxisAngle(float3 axis, float angle)
{
var (sina, cosa) = sincos(0.5f * angle);
return new quaternion(new float4(axis * sina, cosa));
sincos(0.5f * angle, out var s, out var c);
return new quaternion(new float4(axis * s, c));
}
/// <summary>
@@ -120,7 +120,7 @@ public partial struct quaternion : IEquatable<quaternion>
public static quaternion EulerXYZ(float3 xyz)
{
// return mul(rotateZ(xyz.z), mul(rotateY(xyz.y), rotateX(xyz.x)));
var (s, c) = sincos(0.5f * xyz);
sincos(0.5f * xyz, out var s, out var c);
return new quaternion(
// s.x * c.y * c.z - s.y * s.z * c.x,
// s.y * c.x * c.z + s.x * s.z * c.y,
@@ -139,7 +139,7 @@ public partial struct quaternion : IEquatable<quaternion>
public static quaternion EulerXZY(float3 xyz)
{
// return mul(rotateY(xyz.y), mul(rotateZ(xyz.z), rotateX(xyz.x)));
var (s, c) = sincos(0.5f * xyz);
sincos(0.5f * xyz, out var s, out var c);
return new quaternion(
// s.x * c.y * c.z + s.y * s.z * c.x,
// s.y * c.x * c.z + s.x * s.z * c.y,
@@ -158,7 +158,7 @@ public partial struct quaternion : IEquatable<quaternion>
public static quaternion EulerYXZ(float3 xyz)
{
// return mul(rotateZ(xyz.z), mul(rotateX(xyz.x), rotateY(xyz.y)));
var (s, c) = sincos(0.5f * xyz);
sincos(0.5f * xyz, out var s, out var c);
return new quaternion(
// s.x * c.y * c.z - s.y * s.z * c.x,
// s.y * c.x * c.z + s.x * s.z * c.y,
@@ -177,7 +177,7 @@ public partial struct quaternion : IEquatable<quaternion>
public static quaternion EulerYZX(float3 xyz)
{
// return mul(rotateX(xyz.x), mul(rotateZ(xyz.z), rotateY(xyz.y)));
var (s, c) = sincos(0.5f * xyz);
sincos(0.5f * xyz, out var s, out var c);
return new quaternion(
// s.x * c.y * c.z - s.y * s.z * c.x,
// s.y * c.x * c.z - s.x * s.z * c.y,
@@ -197,7 +197,7 @@ public partial struct quaternion : IEquatable<quaternion>
public static quaternion EulerZXY(float3 xyz)
{
// return mul(rotateY(xyz.y), mul(rotateX(xyz.x), rotateZ(xyz.z)));
var (s, c) = sincos(0.5f * xyz);
sincos(0.5f * xyz, out var s, out var c);
return new quaternion(
// s.x * c.y * c.z + s.y * s.z * c.x,
// s.y * c.x * c.z - s.x * s.z * c.y,
@@ -216,7 +216,7 @@ public partial struct quaternion : IEquatable<quaternion>
public static quaternion EulerZYX(float3 xyz)
{
// return mul(rotateX(xyz.x), mul(rotateY(xyz.y), rotateZ(xyz.z)));
var (s, c) = sincos(0.5f * xyz);
sincos(0.5f * xyz, out var s, out var c);
return new quaternion(
// s.x * c.y * c.z + s.y * s.z * c.x,
// s.y * c.x * c.z - s.x * s.z * c.y,
@@ -364,8 +364,8 @@ public partial struct quaternion : IEquatable<quaternion>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static quaternion RotateX(float angle)
{
var (sina, cosa) = sincos(0.5f * angle);
return new quaternion(sina, 0.0f, 0.0f, cosa);
sincos(0.5f * angle, out var s, out var c);
return new quaternion(s, 0.0f, 0.0f, c);
}
/// <summary>Returns a quaternion that rotates around the y-axis by a given number of radians.</summary>
@@ -374,8 +374,8 @@ public partial struct quaternion : IEquatable<quaternion>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static quaternion RotateY(float angle)
{
var (sina, cosa) = sincos(0.5f * angle);
return new quaternion(0.0f, sina, 0.0f, cosa);
sincos(0.5f * angle, out var s, out var c);
return new quaternion(0.0f, s, 0.0f, c);
}
/// <summary>Returns a quaternion that rotates around the z-axis by a given number of radians.</summary>
@@ -384,8 +384,8 @@ public partial struct quaternion : IEquatable<quaternion>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static quaternion RotateZ(float angle)
{
var (sina, cosa) = sincos(0.5f * angle);
return new quaternion(0.0f, 0.0f, sina, cosa);
sincos(0.5f * angle, out var s, out var c);
return new quaternion(0.0f, 0.0f, s, c);
}
/// <summary>
@@ -585,8 +585,8 @@ public static partial class math
{
var v_rcp_len = rsqrt(dot(q.value.xyz, q.value.xyz));
var v_len = rcp(v_rcp_len);
var (sin_v_len, cos_v_len) = sincos(v_len);
return quaternion(new float4(q.value.xyz * v_rcp_len * sin_v_len, cos_v_len));
sincos(v_len, out var s, out var c);
return quaternion(new float4(q.value.xyz * v_rcp_len * s, c));
}
/// <summary>Returns the natural exponent of a quaternion.</summary>
@@ -597,8 +597,8 @@ public static partial class math
{
var v_rcp_len = rsqrt(dot(q.value.xyz, q.value.xyz));
var v_len = rcp(v_rcp_len);
var (sin_v_len, cos_v_len) = sincos(v_len);
return quaternion(new float4(q.value.xyz * v_rcp_len * sin_v_len, cos_v_len) * exp(q.value.w));
sincos(v_len, out var s, out var c);
return quaternion(new float4(q.value.xyz * v_rcp_len * s, c) * exp(q.value.w));
}
/// <summary>Returns the natural logarithm of a unit length quaternion.</summary>