mirror of
https://github.com/beefytech/Beef.git
synced 2025-07-04 15:26:00 +02:00
Initial checkin
This commit is contained in:
Brian Fiete
parent
c74712dad9
commit
078564ac9e
3242 changed files with 1616395 additions and 0 deletions
493
BeefLibs/Beefy2D/src/geom/Matrix4.bf
Normal file
493
BeefLibs/Beefy2D/src/geom/Matrix4.bf
Normal file
|
|
@ -0,0 +1,493 @@
|
|||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Beefy.geom;
|
||||
|
||||
namespace Beefy.geom
|
||||
{
|
||||
public struct Matrix4
|
||||
{
|
||||
public float m00;
|
||||
public float m01;
|
||||
public float m02;
|
||||
public float m03;
|
||||
public float m10;
|
||||
public float m11;
|
||||
public float m12;
|
||||
public float m13;
|
||||
public float m20;
|
||||
public float m21;
|
||||
public float m22;
|
||||
public float m23;
|
||||
public float m30;
|
||||
public float m31;
|
||||
public float m32;
|
||||
public float m33;
|
||||
|
||||
public static readonly Matrix4 Identity = Matrix4(1f, 0f, 0f, 0f,
|
||||
0f, 1f, 0f, 0f,
|
||||
0f, 0f, 1f, 0f,
|
||||
0f, 0f, 0f, 1f);
|
||||
|
||||
public this(
|
||||
float m00, float m01, float m02, float m03,
|
||||
float m10, float m11, float m12, float m13,
|
||||
float m20, float m21, float m22, float m23,
|
||||
float m30, float m31, float m32, float m33)
|
||||
{
|
||||
this.m00 = m00;
|
||||
this.m01 = m01;
|
||||
this.m02 = m02;
|
||||
this.m03 = m03;
|
||||
this.m10 = m10;
|
||||
this.m11 = m11;
|
||||
this.m12 = m12;
|
||||
this.m13 = m13;
|
||||
this.m20 = m20;
|
||||
this.m21 = m21;
|
||||
this.m22 = m22;
|
||||
this.m23 = m23;
|
||||
this.m30 = m30;
|
||||
this.m31 = m31;
|
||||
this.m32 = m32;
|
||||
this.m33 = m33;
|
||||
}
|
||||
|
||||
public static Matrix4 CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance)
|
||||
{
|
||||
Matrix4 matrix;
|
||||
if (nearPlaneDistance <= 0f)
|
||||
{
|
||||
Runtime.FatalError("nearPlaneDistance <= 0");
|
||||
}
|
||||
if (farPlaneDistance <= 0f)
|
||||
{
|
||||
Runtime.FatalError("farPlaneDistance <= 0");
|
||||
}
|
||||
if (nearPlaneDistance >= farPlaneDistance)
|
||||
{
|
||||
Runtime.FatalError("nearPlaneDistance >= farPlaneDistance");
|
||||
}
|
||||
/*matrix.M11 = (2f * nearPlaneDistance) / width;
|
||||
matrix.M12 = matrix.M13 = matrix.M14 = 0f;
|
||||
matrix.M22 = (2f * nearPlaneDistance) / height;
|
||||
matrix.M21 = matrix.M23 = matrix.M24 = 0f;
|
||||
matrix.M33 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
|
||||
matrix.M31 = matrix.M32 = 0f;
|
||||
matrix.M34 = -1f;
|
||||
matrix.M41 = matrix.M42 = matrix.M44 = 0f;
|
||||
matrix.M43 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);*/
|
||||
|
||||
/*matrix.m00 = (2f * nearPlaneDistance) / width;
|
||||
matrix.m01 = 0f;
|
||||
matrix.m02 = 0f;
|
||||
matrix.m03 = 0f;
|
||||
|
||||
matrix.m10 = 0f;
|
||||
matrix.m11 = (2f * nearPlaneDistance) / height;
|
||||
matrix.m12 = 0f;
|
||||
matrix.m13 = 0f;
|
||||
|
||||
matrix.m20 = 0f;
|
||||
matrix.m21 = 0f;
|
||||
matrix.m22 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
|
||||
matrix.m23 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
|
||||
|
||||
matrix.m30 = 0f;
|
||||
matrix.m31 = 0f;
|
||||
matrix.m32 = -1f;
|
||||
matrix.m33 = 0f; */
|
||||
|
||||
matrix.m00 = (2f * nearPlaneDistance) / width;
|
||||
matrix.m10 = matrix.m20 = matrix.m30 = 0f;
|
||||
matrix.m11 = (2f * nearPlaneDistance) / height;
|
||||
matrix.m01 = matrix.m21 = matrix.m31 = 0f;
|
||||
matrix.m22 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
|
||||
matrix.m02 = matrix.m12 = 0f;
|
||||
matrix.m32 = -1f;
|
||||
matrix.m03 = matrix.m13 = matrix.m33 = 0f;
|
||||
matrix.m23 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
|
||||
|
||||
return matrix;
|
||||
}
|
||||
|
||||
public static Matrix4 CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance)
|
||||
{
|
||||
Matrix4 result;
|
||||
CreatePerspectiveFieldOfView(fieldOfView, aspectRatio, nearPlaneDistance, farPlaneDistance, out result);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
public static void CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance, out Matrix4 result)
|
||||
{
|
||||
if ((fieldOfView <= 0f) || (fieldOfView >= 3.141593f))
|
||||
{
|
||||
Runtime.FatalError("fieldOfView <= 0 or >= PI");
|
||||
}
|
||||
if (nearPlaneDistance <= 0f)
|
||||
{
|
||||
Runtime.FatalError("nearPlaneDistance <= 0");
|
||||
}
|
||||
if (farPlaneDistance <= 0f)
|
||||
{
|
||||
Runtime.FatalError("farPlaneDistance <= 0");
|
||||
}
|
||||
if (nearPlaneDistance >= farPlaneDistance)
|
||||
{
|
||||
Runtime.FatalError("nearPlaneDistance >= farPlaneDistance");
|
||||
}
|
||||
float num = 1f / ((float)Math.Tan((double)(fieldOfView * 0.5f)));
|
||||
float num9 = num / aspectRatio;
|
||||
result.m00 = num9;
|
||||
result.m10 = result.m20 = result.m30 = 0;
|
||||
result.m11 = num;
|
||||
result.m01 = result.m21 = result.m31 = 0;
|
||||
result.m02 = result.m12 = 0f;
|
||||
result.m22 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
|
||||
result.m32 = -1;
|
||||
result.m03 = result.m13 = result.m33 = 0;
|
||||
result.m23 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
|
||||
}
|
||||
|
||||
|
||||
public static Matrix4 CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance)
|
||||
{
|
||||
Matrix4 result;
|
||||
CreatePerspectiveOffCenter(left, right, bottom, top, nearPlaneDistance, farPlaneDistance, out result);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
public static void CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance, out Matrix4 result)
|
||||
{
|
||||
if (nearPlaneDistance <= 0f)
|
||||
{
|
||||
Runtime.FatalError("nearPlaneDistance <= 0");
|
||||
}
|
||||
if (farPlaneDistance <= 0f)
|
||||
{
|
||||
Runtime.FatalError("farPlaneDistance <= 0");
|
||||
}
|
||||
if (nearPlaneDistance >= farPlaneDistance)
|
||||
{
|
||||
Runtime.FatalError("nearPlaneDistance >= farPlaneDistance");
|
||||
}
|
||||
result.m00 = (2f * nearPlaneDistance) / (right - left);
|
||||
result.m10 = result.m20 = result.m30 = 0;
|
||||
result.m11 = (2f * nearPlaneDistance) / (top - bottom);
|
||||
result.m01 = result.m21 = result.m31 = 0;
|
||||
result.m02 = (left + right) / (right - left);
|
||||
result.m12 = (top + bottom) / (top - bottom);
|
||||
result.m22 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
|
||||
result.m32 = -1;
|
||||
result.m23 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
|
||||
result.m03 = result.m13 = result.m33 = 0;
|
||||
}
|
||||
|
||||
public static Matrix4 Multiply(Matrix4 m1, Matrix4 m2)
|
||||
{
|
||||
Matrix4 r;
|
||||
r.m00 = m1.m00 * m2.m00 + m1.m01 * m2.m10 + m1.m02 * m2.m20 + m1.m03 * m2.m30;
|
||||
r.m01 = m1.m00 * m2.m01 + m1.m01 * m2.m11 + m1.m02 * m2.m21 + m1.m03 * m2.m31;
|
||||
r.m02 = m1.m00 * m2.m02 + m1.m01 * m2.m12 + m1.m02 * m2.m22 + m1.m03 * m2.m32;
|
||||
r.m03 = m1.m00 * m2.m03 + m1.m01 * m2.m13 + m1.m02 * m2.m23 + m1.m03 * m2.m33;
|
||||
|
||||
r.m10 = m1.m10 * m2.m00 + m1.m11 * m2.m10 + m1.m12 * m2.m20 + m1.m13 * m2.m30;
|
||||
r.m11 = m1.m10 * m2.m01 + m1.m11 * m2.m11 + m1.m12 * m2.m21 + m1.m13 * m2.m31;
|
||||
r.m12 = m1.m10 * m2.m02 + m1.m11 * m2.m12 + m1.m12 * m2.m22 + m1.m13 * m2.m32;
|
||||
r.m13 = m1.m10 * m2.m03 + m1.m11 * m2.m13 + m1.m12 * m2.m23 + m1.m13 * m2.m33;
|
||||
|
||||
r.m20 = m1.m20 * m2.m00 + m1.m21 * m2.m10 + m1.m22 * m2.m20 + m1.m23 * m2.m30;
|
||||
r.m21 = m1.m20 * m2.m01 + m1.m21 * m2.m11 + m1.m22 * m2.m21 + m1.m23 * m2.m31;
|
||||
r.m22 = m1.m20 * m2.m02 + m1.m21 * m2.m12 + m1.m22 * m2.m22 + m1.m23 * m2.m32;
|
||||
r.m23 = m1.m20 * m2.m03 + m1.m21 * m2.m13 + m1.m22 * m2.m23 + m1.m23 * m2.m33;
|
||||
|
||||
r.m30 = m1.m30 * m2.m00 + m1.m31 * m2.m10 + m1.m32 * m2.m20 + m1.m33 * m2.m30;
|
||||
r.m31 = m1.m30 * m2.m01 + m1.m31 * m2.m11 + m1.m32 * m2.m21 + m1.m33 * m2.m31;
|
||||
r.m32 = m1.m30 * m2.m02 + m1.m31 * m2.m12 + m1.m32 * m2.m22 + m1.m33 * m2.m32;
|
||||
r.m33 = m1.m30 * m2.m03 + m1.m31 * m2.m13 + m1.m32 * m2.m23 + m1.m33 * m2.m33;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
public static Matrix4 Transpose(Matrix4 m)
|
||||
{
|
||||
return Matrix4(
|
||||
m.m00, m.m10, m.m20, m.m30,
|
||||
m.m01, m.m11, m.m21, m.m31,
|
||||
m.m02, m.m12, m.m22, m.m32,
|
||||
m.m03, m.m13, m.m23, m.m33);
|
||||
}
|
||||
|
||||
public static Matrix4 CreateTranslation(float x, float y, float z)
|
||||
{
|
||||
return Matrix4(
|
||||
1, 0, 0, x,
|
||||
0, 1, 0, y,
|
||||
0, 0, 1, z,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
public static Matrix4 CreateTransform(Vector3 position, Vector3 scale, Quaternion orientation)
|
||||
{
|
||||
// Ordering:
|
||||
// 1. Scale
|
||||
// 2. Rotate
|
||||
// 3. Translate
|
||||
|
||||
Matrix4 rot = orientation.ToMatrix();
|
||||
return Matrix4(
|
||||
scale.mX * rot.m00, scale.mY * rot.m01, scale.mZ * rot.m02, position.mX,
|
||||
scale.mX * rot.m10, scale.mY * rot.m11, scale.mZ * rot.m12, position.mY,
|
||||
scale.mX * rot.m20, scale.mY * rot.m21, scale.mZ * rot.m22, position.mZ,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
|
||||
public static Matrix4 CreateRotationX(float radians)
|
||||
{
|
||||
Matrix4 result = Matrix4.Identity;
|
||||
|
||||
var val1 = (float)Math.Cos(radians);
|
||||
var val2 = (float)Math.Sin(radians);
|
||||
|
||||
result.m11 = val1;
|
||||
result.m21 = val2;
|
||||
result.m12 = -val2;
|
||||
result.m22 = val1;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public static Matrix4 CreateRotationY(float radians)
|
||||
{
|
||||
Matrix4 returnMatrix = Matrix4.Identity;
|
||||
|
||||
var val1 = (float)Math.Cos(radians);
|
||||
var val2 = (float)Math.Sin(radians);
|
||||
|
||||
returnMatrix.m00 = val1;
|
||||
returnMatrix.m20 = -val2;
|
||||
returnMatrix.m02 = val2;
|
||||
returnMatrix.m22 = val1;
|
||||
|
||||
return returnMatrix;
|
||||
}
|
||||
|
||||
public static Matrix4 CreateRotationZ(float radians)
|
||||
{
|
||||
Matrix4 returnMatrix = Matrix4.Identity;
|
||||
|
||||
var val1 = (float)Math.Cos(radians);
|
||||
var val2 = (float)Math.Sin(radians);
|
||||
|
||||
returnMatrix.m00 = val1;
|
||||
returnMatrix.m10 = val2;
|
||||
returnMatrix.m01 = -val2;
|
||||
returnMatrix.m11 = val1;
|
||||
|
||||
return returnMatrix;
|
||||
}
|
||||
|
||||
public static Matrix4 CreateScale(float scale)
|
||||
{
|
||||
Matrix4 result;
|
||||
result.m00 = scale;
|
||||
result.m10 = 0;
|
||||
result.m20 = 0;
|
||||
result.m30 = 0;
|
||||
result.m01 = 0;
|
||||
result.m11 = scale;
|
||||
result.m21 = 0;
|
||||
result.m31 = 0;
|
||||
result.m02 = 0;
|
||||
result.m12 = 0;
|
||||
result.m22 = scale;
|
||||
result.m32 = 0;
|
||||
result.m03 = 0;
|
||||
result.m13 = 0;
|
||||
result.m23 = 0;
|
||||
result.m33 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
public static Matrix4 CreateScale(float xScale, float yScale, float zScale)
|
||||
{
|
||||
Matrix4 result;
|
||||
result.m00 = xScale;
|
||||
result.m10 = 0;
|
||||
result.m20 = 0;
|
||||
result.m30 = 0;
|
||||
result.m01 = 0;
|
||||
result.m11 = yScale;
|
||||
result.m21 = 0;
|
||||
result.m31 = 0;
|
||||
result.m02 = 0;
|
||||
result.m12 = 0;
|
||||
result.m22 = zScale;
|
||||
result.m32 = 0;
|
||||
result.m03 = 0;
|
||||
result.m13 = 0;
|
||||
result.m23 = 0;
|
||||
result.m33 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
public static Matrix4 CreateScale(Vector3 scales)
|
||||
{
|
||||
Matrix4 result;
|
||||
result.m00 = scales.mX;
|
||||
result.m10 = 0;
|
||||
result.m20 = 0;
|
||||
result.m30 = 0;
|
||||
result.m01 = 0;
|
||||
result.m11 = scales.mY;
|
||||
result.m21 = 0;
|
||||
result.m31 = 0;
|
||||
result.m02 = 0;
|
||||
result.m12 = 0;
|
||||
result.m22 = scales.mZ;
|
||||
result.m32 = 0;
|
||||
result.m03 = 0;
|
||||
result.m13 = 0;
|
||||
result.m23 = 0;
|
||||
result.m33 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
public static Matrix4 CreateTranslation(Vector3 position)
|
||||
{
|
||||
Matrix4 result;
|
||||
result.m00 = 1;
|
||||
result.m10 = 0;
|
||||
result.m20 = 0;
|
||||
result.m30 = 0;
|
||||
result.m01 = 0;
|
||||
result.m11 = 1;
|
||||
result.m21 = 0;
|
||||
result.m31 = 0;
|
||||
result.m02 = 0;
|
||||
result.m12 = 0;
|
||||
result.m22 = 1;
|
||||
result.m32 = 0;
|
||||
result.m03 = position.mX;
|
||||
result.m13 = position.mY;
|
||||
result.m23 = position.mZ;
|
||||
result.m33 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
/*public static Matrix4 Inverse()
|
||||
{
|
||||
Real m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
|
||||
Real m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
|
||||
Real m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
|
||||
Real m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
|
||||
|
||||
Real v0 = m20 * m31 - m21 * m30;
|
||||
Real v1 = m20 * m32 - m22 * m30;
|
||||
Real v2 = m20 * m33 - m23 * m30;
|
||||
Real v3 = m21 * m32 - m22 * m31;
|
||||
Real v4 = m21 * m33 - m23 * m31;
|
||||
Real v5 = m22 * m33 - m23 * m32;
|
||||
|
||||
Real t00 = + (v5 * m11 - v4 * m12 + v3 * m13);
|
||||
Real t10 = - (v5 * m10 - v2 * m12 + v1 * m13);
|
||||
Real t20 = + (v4 * m10 - v2 * m11 + v0 * m13);
|
||||
Real t30 = - (v3 * m10 - v1 * m11 + v0 * m12);
|
||||
|
||||
Real invDet = 1 / (t00 * m00 + t10 * m01 + t20 * m02 + t30 * m03);
|
||||
|
||||
Real d00 = t00 * invDet;
|
||||
Real d10 = t10 * invDet;
|
||||
Real d20 = t20 * invDet;
|
||||
Real d30 = t30 * invDet;
|
||||
|
||||
Real d01 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
|
||||
Real d11 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
|
||||
Real d21 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
|
||||
Real d31 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
|
||||
|
||||
v0 = m10 * m31 - m11 * m30;
|
||||
v1 = m10 * m32 - m12 * m30;
|
||||
v2 = m10 * m33 - m13 * m30;
|
||||
v3 = m11 * m32 - m12 * m31;
|
||||
v4 = m11 * m33 - m13 * m31;
|
||||
v5 = m12 * m33 - m13 * m32;
|
||||
|
||||
Real d02 = + (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
|
||||
Real d12 = - (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
|
||||
Real d22 = + (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
|
||||
Real d32 = - (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
|
||||
|
||||
v0 = m21 * m10 - m20 * m11;
|
||||
v1 = m22 * m10 - m20 * m12;
|
||||
v2 = m23 * m10 - m20 * m13;
|
||||
v3 = m22 * m11 - m21 * m12;
|
||||
v4 = m23 * m11 - m21 * m13;
|
||||
v5 = m23 * m12 - m22 * m13;
|
||||
|
||||
Real d03 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
|
||||
Real d13 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
|
||||
Real d23 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
|
||||
Real d33 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
|
||||
|
||||
return Matrix4(
|
||||
d00, d01, d02, d03,
|
||||
d10, d11, d12, d13,
|
||||
d20, d21, d22, d23,
|
||||
d30, d31, d32, d33);
|
||||
}*/
|
||||
|
||||
bool IsAffine()
|
||||
{
|
||||
return m30 == 0 && m31 == 0 && m32 == 0 && m33 == 1;
|
||||
}
|
||||
|
||||
public static Matrix4 InverseAffine(Matrix4 mtx)
|
||||
{
|
||||
Debug.Assert(mtx.IsAffine());
|
||||
|
||||
float m10 = mtx.m10, m11 = mtx.m11, m12 = mtx.m12;
|
||||
float m20 = mtx.m20, m21 = mtx.m21, m22 = mtx.m22;
|
||||
|
||||
float t00 = m22 * m11 - m21 * m12;
|
||||
float t10 = m20 * m12 - m22 * m10;
|
||||
float t20 = m21 * m10 - m20 * m11;
|
||||
|
||||
float m00 = mtx.m00, m01 = mtx.m01, m02 = mtx.m02;
|
||||
|
||||
float invDet = 1 / (m00 * t00 + m01 * t10 + m02 * t20);
|
||||
|
||||
t00 *= invDet; t10 *= invDet; t20 *= invDet;
|
||||
|
||||
m00 *= invDet; m01 *= invDet; m02 *= invDet;
|
||||
|
||||
float r00 = t00;
|
||||
float r01 = m02 * m21 - m01 * m22;
|
||||
float r02 = m01 * m12 - m02 * m11;
|
||||
|
||||
float r10 = t10;
|
||||
float r11 = m00 * m22 - m02 * m20;
|
||||
float r12 = m02 * m10 - m00 * m12;
|
||||
|
||||
float r20 = t20;
|
||||
float r21 = m01 * m20 - m00 * m21;
|
||||
float r22 = m00 * m11 - m01 * m10;
|
||||
|
||||
float m03 = mtx.m03, m13 = mtx.m13, m23 = mtx.m23;
|
||||
|
||||
float r03 = -(r00 * m03 + r01 * m13 + r02 * m23);
|
||||
float r13 = -(r10 * m03 + r11 * m13 + r12 * m23);
|
||||
float r23 = -(r20 * m03 + r21 * m13 + r22 * m23);
|
||||
|
||||
return Matrix4(
|
||||
r00, r01, r02, r03,
|
||||
r10, r11, r12, r13,
|
||||
r20, r21, r22, r23,
|
||||
0, 0, 0, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
18
BeefLibs/Beefy2D/src/geom/Point.bf
Normal file
18
BeefLibs/Beefy2D/src/geom/Point.bf
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace Beefy.geom
|
||||
{
|
||||
public struct Point
|
||||
{
|
||||
public float x;
|
||||
public float y;
|
||||
|
||||
public this(float x, float y)
|
||||
{
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
775
BeefLibs/Beefy2D/src/geom/Quaternion.bf
Normal file
775
BeefLibs/Beefy2D/src/geom/Quaternion.bf
Normal file
|
|
@ -0,0 +1,775 @@
|
|||
using System;
|
||||
using Beefy.gfx;
|
||||
|
||||
namespace Beefy.geom
|
||||
{
|
||||
public struct Quaternion : IHashable, IEquatable<Quaternion>
|
||||
{
|
||||
public float mX;
|
||||
public float mY;
|
||||
public float mZ;
|
||||
public float mW;
|
||||
public static readonly Quaternion Identity = Quaternion(0, 0, 0, 1);
|
||||
|
||||
public this(float x, float y, float z, float w)
|
||||
{
|
||||
mX = x;
|
||||
mY = y;
|
||||
mZ = z;
|
||||
mW = w;
|
||||
}
|
||||
|
||||
public this(Vector3 vectorPart, float scalarPart)
|
||||
{
|
||||
mX = vectorPart.mX;
|
||||
mY = vectorPart.mY;
|
||||
mZ = vectorPart.mZ;
|
||||
mW = scalarPart;
|
||||
}
|
||||
|
||||
public static Quaternion Add(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = quaternion1.mX + quaternion2.mX;
|
||||
quaternion.mY = quaternion1.mY + quaternion2.mY;
|
||||
quaternion.mZ = quaternion1.mZ + quaternion2.mZ;
|
||||
quaternion.mW = quaternion1.mW + quaternion2.mW;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
|
||||
public static void Add(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
|
||||
{
|
||||
result.mX = quaternion1.mX + quaternion2.mX;
|
||||
result.mY = quaternion1.mY + quaternion2.mY;
|
||||
result.mZ = quaternion1.mZ + quaternion2.mZ;
|
||||
result.mW = quaternion1.mW + quaternion2.mW;
|
||||
}
|
||||
|
||||
public static Quaternion Concatenate(Quaternion value1, Quaternion value2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float x = value2.mX;
|
||||
float y = value2.mY;
|
||||
float z = value2.mZ;
|
||||
float w = value2.mW;
|
||||
float num4 = value1.mX;
|
||||
float num3 = value1.mY;
|
||||
float num2 = value1.mZ;
|
||||
float num = value1.mW;
|
||||
float num12 = (y * num2) - (z * num3);
|
||||
float num11 = (z * num4) - (x * num2);
|
||||
float num10 = (x * num3) - (y * num4);
|
||||
float num9 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
quaternion.mX = ((x * num) + (num4 * w)) + num12;
|
||||
quaternion.mY = ((y * num) + (num3 * w)) + num11;
|
||||
quaternion.mZ = ((z * num) + (num2 * w)) + num10;
|
||||
quaternion.mW = (w * num) - num9;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Concatenate(ref Quaternion value1, ref Quaternion value2, out Quaternion result)
|
||||
{
|
||||
float x = value2.mX;
|
||||
float y = value2.mY;
|
||||
float z = value2.mZ;
|
||||
float w = value2.mW;
|
||||
float num4 = value1.mX;
|
||||
float num3 = value1.mY;
|
||||
float num2 = value1.mZ;
|
||||
float num = value1.mW;
|
||||
float num12 = (y * num2) - (z * num3);
|
||||
float num11 = (z * num4) - (x * num2);
|
||||
float num10 = (x * num3) - (y * num4);
|
||||
float num9 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
result.mX = ((x * num) + (num4 * w)) + num12;
|
||||
result.mY = ((y * num) + (num3 * w)) + num11;
|
||||
result.mZ = ((z * num) + (num2 * w)) + num10;
|
||||
result.mW = (w * num) - num9;
|
||||
}
|
||||
|
||||
public void Conjugate() mut
|
||||
{
|
||||
mX = -mX;
|
||||
mY = -mY;
|
||||
mZ = -mZ;
|
||||
}
|
||||
|
||||
public static Quaternion Conjugate(Quaternion value)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = -value.mX;
|
||||
quaternion.mY = -value.mY;
|
||||
quaternion.mZ = -value.mZ;
|
||||
quaternion.mW = value.mW;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Conjugate(ref Quaternion value, out Quaternion result)
|
||||
{
|
||||
result.mX = -value.mX;
|
||||
result.mY = -value.mY;
|
||||
result.mZ = -value.mZ;
|
||||
result.mW = value.mW;
|
||||
}
|
||||
|
||||
public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float num2 = angle * 0.5f;
|
||||
float num = (float)Math.Sin((double)num2);
|
||||
float num3 = (float)Math.Cos((double)num2);
|
||||
quaternion.mX = axis.mX * num;
|
||||
quaternion.mY = axis.mY * num;
|
||||
quaternion.mZ = axis.mZ * num;
|
||||
quaternion.mW = num3;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void CreateFromAxisAngle(ref Vector3 axis, float angle, out Quaternion result)
|
||||
{
|
||||
float num2 = angle * 0.5f;
|
||||
float num = (float)Math.Sin((double)num2);
|
||||
float num3 = (float)Math.Cos((double)num2);
|
||||
result.mX = axis.mX * num;
|
||||
result.mY = axis.mY * num;
|
||||
result.mZ = axis.mZ * num;
|
||||
result.mW = num3;
|
||||
}
|
||||
|
||||
public static Quaternion CreateFromRotationMatrix(Matrix4 matrix)
|
||||
{
|
||||
float num8 = (matrix.m11 + matrix.m22) + matrix.m33;
|
||||
Quaternion quaternion = Quaternion();
|
||||
if (num8 > 0f)
|
||||
{
|
||||
float num = (float)Math.Sqrt((double)(num8 + 1f));
|
||||
quaternion.mW = num * 0.5f;
|
||||
num = 0.5f / num;
|
||||
quaternion.mX = (matrix.m23 - matrix.m32) * num;
|
||||
quaternion.mY = (matrix.m31 - matrix.m13) * num;
|
||||
quaternion.mZ = (matrix.m12 - matrix.m21) * num;
|
||||
return quaternion;
|
||||
}
|
||||
if ((matrix.m11 >= matrix.m22) && (matrix.m11 >= matrix.m33))
|
||||
{
|
||||
float num7 = (float)Math.Sqrt((double)(((1f + matrix.m11) - matrix.m22) - matrix.m33));
|
||||
float num4 = 0.5f / num7;
|
||||
quaternion.mX = 0.5f * num7;
|
||||
quaternion.mY = (matrix.m12 + matrix.m21) * num4;
|
||||
quaternion.mZ = (matrix.m13 + matrix.m31) * num4;
|
||||
quaternion.mW = (matrix.m23 - matrix.m32) * num4;
|
||||
return quaternion;
|
||||
}
|
||||
if (matrix.m22 > matrix.m33)
|
||||
{
|
||||
float num6 = (float)Math.Sqrt((double)(((1f + matrix.m22) - matrix.m11) - matrix.m33));
|
||||
float num3 = 0.5f / num6;
|
||||
quaternion.mX = (matrix.m21 + matrix.m12) * num3;
|
||||
quaternion.mY = 0.5f * num6;
|
||||
quaternion.mZ = (matrix.m32 + matrix.m23) * num3;
|
||||
quaternion.mW = (matrix.m31 - matrix.m13) * num3;
|
||||
return quaternion;
|
||||
}
|
||||
float num5 = (float)Math.Sqrt((double)(((1f + matrix.m33) - matrix.m11) - matrix.m22));
|
||||
float num2 = 0.5f / num5;
|
||||
quaternion.mX = (matrix.m31 + matrix.m13) * num2;
|
||||
quaternion.mY = (matrix.m32 + matrix.m23) * num2;
|
||||
quaternion.mZ = 0.5f * num5;
|
||||
quaternion.mW = (matrix.m12 - matrix.m21) * num2;
|
||||
|
||||
return quaternion;
|
||||
|
||||
}
|
||||
|
||||
public static void CreateFromRotationMatrix(ref Matrix4 matrix, out Quaternion result)
|
||||
{
|
||||
float num8 = (matrix.m11 + matrix.m22) + matrix.m33;
|
||||
if (num8 > 0f)
|
||||
{
|
||||
float num = (float)Math.Sqrt((double)(num8 + 1f));
|
||||
result.mW = num * 0.5f;
|
||||
num = 0.5f / num;
|
||||
result.mX = (matrix.m23 - matrix.m32) * num;
|
||||
result.mY = (matrix.m31 - matrix.m13) * num;
|
||||
result.mZ = (matrix.m12 - matrix.m21) * num;
|
||||
}
|
||||
else if ((matrix.m11 >= matrix.m22) && (matrix.m11 >= matrix.m33))
|
||||
{
|
||||
float num7 = (float)Math.Sqrt((double)(((1f + matrix.m11) - matrix.m22) - matrix.m33));
|
||||
float num4 = 0.5f / num7;
|
||||
result.mX = 0.5f * num7;
|
||||
result.mY = (matrix.m12 + matrix.m21) * num4;
|
||||
result.mZ = (matrix.m13 + matrix.m31) * num4;
|
||||
result.mW = (matrix.m23 - matrix.m32) * num4;
|
||||
}
|
||||
else if (matrix.m22 > matrix.m33)
|
||||
{
|
||||
float num6 = (float)Math.Sqrt((double)(((1f + matrix.m22) - matrix.m11) - matrix.m33));
|
||||
float num3 = 0.5f / num6;
|
||||
result.mX = (matrix.m21 + matrix.m12) * num3;
|
||||
result.mY = 0.5f * num6;
|
||||
result.mZ = (matrix.m32 + matrix.m23) * num3;
|
||||
result.mW = (matrix.m31 - matrix.m13) * num3;
|
||||
}
|
||||
else
|
||||
{
|
||||
float num5 = (float)Math.Sqrt((double)(((1f + matrix.m33) - matrix.m11) - matrix.m22));
|
||||
float num2 = 0.5f / num5;
|
||||
result.mX = (matrix.m31 + matrix.m13) * num2;
|
||||
result.mY = (matrix.m32 + matrix.m23) * num2;
|
||||
result.mZ = 0.5f * num5;
|
||||
result.mW = (matrix.m12 - matrix.m21) * num2;
|
||||
}
|
||||
}
|
||||
|
||||
public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float num9 = roll * 0.5f;
|
||||
float num6 = (float)Math.Sin((double)num9);
|
||||
float num5 = (float)Math.Cos((double)num9);
|
||||
float num8 = pitch * 0.5f;
|
||||
float num4 = (float)Math.Sin((double)num8);
|
||||
float num3 = (float)Math.Cos((double)num8);
|
||||
float num7 = yaw * 0.5f;
|
||||
float num2 = (float)Math.Sin((double)num7);
|
||||
float num = (float)Math.Cos((double)num7);
|
||||
quaternion.mX = ((num * num4) * num5) + ((num2 * num3) * num6);
|
||||
quaternion.mY = ((num2 * num3) * num5) - ((num * num4) * num6);
|
||||
quaternion.mZ = ((num * num3) * num6) - ((num2 * num4) * num5);
|
||||
quaternion.mW = ((num * num3) * num5) + ((num2 * num4) * num6);
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void CreateFromYawPitchRoll(float yaw, float pitch, float roll, out Quaternion result)
|
||||
{
|
||||
float num9 = roll * 0.5f;
|
||||
float num6 = (float)Math.Sin((double)num9);
|
||||
float num5 = (float)Math.Cos((double)num9);
|
||||
float num8 = pitch * 0.5f;
|
||||
float num4 = (float)Math.Sin((double)num8);
|
||||
float num3 = (float)Math.Cos((double)num8);
|
||||
float num7 = yaw * 0.5f;
|
||||
float num2 = (float)Math.Sin((double)num7);
|
||||
float num = (float)Math.Cos((double)num7);
|
||||
result.mX = ((num * num4) * num5) + ((num2 * num3) * num6);
|
||||
result.mY = ((num2 * num3) * num5) - ((num * num4) * num6);
|
||||
result.mZ = ((num * num3) * num6) - ((num2 * num4) * num5);
|
||||
result.mW = ((num * num3) * num5) + ((num2 * num4) * num6);
|
||||
}
|
||||
|
||||
public static Quaternion Divide(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float x = quaternion1.mX;
|
||||
float y = quaternion1.mY;
|
||||
float z = quaternion1.mZ;
|
||||
float w = quaternion1.mW;
|
||||
float num14 = (((quaternion2.mX * quaternion2.mX) + (quaternion2.mY * quaternion2.mY)) + (quaternion2.mZ * quaternion2.mZ)) + (quaternion2.mW * quaternion2.mW);
|
||||
float num5 = 1f / num14;
|
||||
float num4 = -quaternion2.mX * num5;
|
||||
float num3 = -quaternion2.mY * num5;
|
||||
float num2 = -quaternion2.mZ * num5;
|
||||
float num = quaternion2.mW * num5;
|
||||
float num13 = (y * num2) - (z * num3);
|
||||
float num12 = (z * num4) - (x * num2);
|
||||
float num11 = (x * num3) - (y * num4);
|
||||
float num10 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
quaternion.mX = ((x * num) + (num4 * w)) + num13;
|
||||
quaternion.mY = ((y * num) + (num3 * w)) + num12;
|
||||
quaternion.mZ = ((z * num) + (num2 * w)) + num11;
|
||||
quaternion.mW = (w * num) - num10;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Divide(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
|
||||
{
|
||||
float x = quaternion1.mX;
|
||||
float y = quaternion1.mY;
|
||||
float z = quaternion1.mZ;
|
||||
float w = quaternion1.mW;
|
||||
float num14 = (((quaternion2.mX * quaternion2.mX) + (quaternion2.mY * quaternion2.mY)) + (quaternion2.mZ * quaternion2.mZ)) + (quaternion2.mW * quaternion2.mW);
|
||||
float num5 = 1f / num14;
|
||||
float num4 = -quaternion2.mX * num5;
|
||||
float num3 = -quaternion2.mY * num5;
|
||||
float num2 = -quaternion2.mZ * num5;
|
||||
float num = quaternion2.mW * num5;
|
||||
float num13 = (y * num2) - (z * num3);
|
||||
float num12 = (z * num4) - (x * num2);
|
||||
float num11 = (x * num3) - (y * num4);
|
||||
float num10 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
result.mX = ((x * num) + (num4 * w)) + num13;
|
||||
result.mY = ((y * num) + (num3 * w)) + num12;
|
||||
result.mZ = ((z * num) + (num2 * w)) + num11;
|
||||
result.mW = (w * num) - num10;
|
||||
}
|
||||
|
||||
public static float Dot(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
return ((((quaternion1.mX * quaternion2.mX) + (quaternion1.mY * quaternion2.mY)) + (quaternion1.mZ * quaternion2.mZ)) + (quaternion1.mW * quaternion2.mW));
|
||||
}
|
||||
|
||||
public static void Dot(ref Quaternion quaternion1, ref Quaternion quaternion2, out float result)
|
||||
{
|
||||
result = (((quaternion1.mX * quaternion2.mX) + (quaternion1.mY * quaternion2.mY)) + (quaternion1.mZ * quaternion2.mZ)) + (quaternion1.mW * quaternion2.mW);
|
||||
}
|
||||
|
||||
public bool Equals(Quaternion other)
|
||||
{
|
||||
return (mX == other.mX) && (mY == other.mY) && (mZ == other.mZ) && (mW == other.mW);
|
||||
}
|
||||
|
||||
public int GetHashCode()
|
||||
{
|
||||
//return ((mX.GetHashCode() + mY.GetHashCode()) + mZ.GetHashCode()) + mW.GetHashCode();
|
||||
ThrowUnimplemented();
|
||||
}
|
||||
|
||||
public static Quaternion Inverse(Quaternion quaternion)
|
||||
{
|
||||
Quaternion quaternion2;
|
||||
float num2 = (((quaternion.mX * quaternion.mX) + (quaternion.mY * quaternion.mY)) + (quaternion.mZ * quaternion.mZ)) + (quaternion.mW * quaternion.mW);
|
||||
float num = 1f / num2;
|
||||
quaternion2.mX = -quaternion.mX * num;
|
||||
quaternion2.mY = -quaternion.mY * num;
|
||||
quaternion2.mZ = -quaternion.mZ * num;
|
||||
quaternion2.mW = quaternion.mW * num;
|
||||
return quaternion2;
|
||||
}
|
||||
|
||||
public static void Inverse(ref Quaternion quaternion, out Quaternion result)
|
||||
{
|
||||
float num2 = (((quaternion.mX * quaternion.mX) + (quaternion.mY * quaternion.mY)) + (quaternion.mZ * quaternion.mZ)) + (quaternion.mW * quaternion.mW);
|
||||
float num = 1f / num2;
|
||||
result.mX = -quaternion.mX * num;
|
||||
result.mY = -quaternion.mY * num;
|
||||
result.mZ = -quaternion.mZ * num;
|
||||
result.mW = quaternion.mW * num;
|
||||
}
|
||||
|
||||
public float Length()
|
||||
{
|
||||
float num = (((mX * mX) + (mY * mY)) + (mZ * mZ)) + (mW * mW);
|
||||
return (float)Math.Sqrt((double)num);
|
||||
}
|
||||
|
||||
public float LengthSquared()
|
||||
{
|
||||
return ((((mX * mX) + (mY * mY)) + (mZ * mZ)) + (mW * mW));
|
||||
}
|
||||
|
||||
public static Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
|
||||
{
|
||||
float num = amount;
|
||||
float num2 = 1f - num;
|
||||
Quaternion quaternion = Quaternion();
|
||||
float num5 = (((quaternion1.mX * quaternion2.mX) + (quaternion1.mY * quaternion2.mY)) + (quaternion1.mZ * quaternion2.mZ)) + (quaternion1.mW * quaternion2.mW);
|
||||
if (num5 >= 0f)
|
||||
{
|
||||
quaternion.mX = (num2 * quaternion1.mX) + (num * quaternion2.mX);
|
||||
quaternion.mY = (num2 * quaternion1.mY) + (num * quaternion2.mY);
|
||||
quaternion.mZ = (num2 * quaternion1.mZ) + (num * quaternion2.mZ);
|
||||
quaternion.mW = (num2 * quaternion1.mW) + (num * quaternion2.mW);
|
||||
}
|
||||
else
|
||||
{
|
||||
quaternion.mX = (num2 * quaternion1.mX) - (num * quaternion2.mX);
|
||||
quaternion.mY = (num2 * quaternion1.mY) - (num * quaternion2.mY);
|
||||
quaternion.mZ = (num2 * quaternion1.mZ) - (num * quaternion2.mZ);
|
||||
quaternion.mW = (num2 * quaternion1.mW) - (num * quaternion2.mW);
|
||||
}
|
||||
float num4 = (((quaternion.mX * quaternion.mX) + (quaternion.mY * quaternion.mY)) + (quaternion.mZ * quaternion.mZ)) + (quaternion.mW * quaternion.mW);
|
||||
float num3 = 1f / ((float)Math.Sqrt((double)num4));
|
||||
quaternion.mX *= num3;
|
||||
quaternion.mY *= num3;
|
||||
quaternion.mZ *= num3;
|
||||
quaternion.mW *= num3;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Lerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, out Quaternion result)
|
||||
{
|
||||
float num = amount;
|
||||
float num2 = 1f - num;
|
||||
float num5 = (((quaternion1.mX * quaternion2.mX) + (quaternion1.mY * quaternion2.mY)) + (quaternion1.mZ * quaternion2.mZ)) + (quaternion1.mW * quaternion2.mW);
|
||||
if (num5 >= 0f)
|
||||
{
|
||||
result.mX = (num2 * quaternion1.mX) + (num * quaternion2.mX);
|
||||
result.mY = (num2 * quaternion1.mY) + (num * quaternion2.mY);
|
||||
result.mZ = (num2 * quaternion1.mZ) + (num * quaternion2.mZ);
|
||||
result.mW = (num2 * quaternion1.mW) + (num * quaternion2.mW);
|
||||
}
|
||||
else
|
||||
{
|
||||
result.mX = (num2 * quaternion1.mX) - (num * quaternion2.mX);
|
||||
result.mY = (num2 * quaternion1.mY) - (num * quaternion2.mY);
|
||||
result.mZ = (num2 * quaternion1.mZ) - (num * quaternion2.mZ);
|
||||
result.mW = (num2 * quaternion1.mW) - (num * quaternion2.mW);
|
||||
}
|
||||
float num4 = (((result.mX * result.mX) + (result.mY * result.mY)) + (result.mZ * result.mZ)) + (result.mW * result.mW);
|
||||
float num3 = 1f / ((float)Math.Sqrt((double)num4));
|
||||
result.mX *= num3;
|
||||
result.mY *= num3;
|
||||
result.mZ *= num3;
|
||||
result.mW *= num3;
|
||||
}
|
||||
|
||||
public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
|
||||
{
|
||||
float num2;
|
||||
float num3;
|
||||
Quaternion quaternion;
|
||||
float num = amount;
|
||||
float num4 = (((quaternion1.mX * quaternion2.mX) + (quaternion1.mY * quaternion2.mY)) + (quaternion1.mZ * quaternion2.mZ)) + (quaternion1.mW * quaternion2.mW);
|
||||
bool flag = false;
|
||||
if (num4 < 0f)
|
||||
{
|
||||
flag = true;
|
||||
num4 = -num4;
|
||||
}
|
||||
if (num4 > 0.999999f)
|
||||
{
|
||||
num3 = 1f - num;
|
||||
num2 = flag ? -num : num;
|
||||
}
|
||||
else
|
||||
{
|
||||
float num5 = (float)Math.Acos((double)num4);
|
||||
float num6 = (float)(1.0 / Math.Sin((double)num5));
|
||||
num3 = ((float)Math.Sin((double)((1f - num) * num5))) * num6;
|
||||
num2 = flag ? (((float)(-Math.Sin((double)(num * num5))) * num6)) : (((float)Math.Sin((double)(num * num5))) * num6);
|
||||
}
|
||||
quaternion.mX = (num3 * quaternion1.mX) + (num2 * quaternion2.mX);
|
||||
quaternion.mY = (num3 * quaternion1.mY) + (num2 * quaternion2.mY);
|
||||
quaternion.mZ = (num3 * quaternion1.mZ) + (num2 * quaternion2.mZ);
|
||||
quaternion.mW = (num3 * quaternion1.mW) + (num2 * quaternion2.mW);
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Slerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, out Quaternion result)
|
||||
{
|
||||
float num2;
|
||||
float num3;
|
||||
float num = amount;
|
||||
float num4 = (((quaternion1.mX * quaternion2.mX) + (quaternion1.mY * quaternion2.mY)) + (quaternion1.mZ * quaternion2.mZ)) + (quaternion1.mW * quaternion2.mW);
|
||||
bool flag = false;
|
||||
if (num4 < 0f)
|
||||
{
|
||||
flag = true;
|
||||
num4 = -num4;
|
||||
}
|
||||
if (num4 > 0.999999f)
|
||||
{
|
||||
num3 = 1f - num;
|
||||
num2 = flag ? -num : num;
|
||||
}
|
||||
else
|
||||
{
|
||||
float num5 = (float)Math.Acos((double)num4);
|
||||
float num6 = (float)(1.0 / Math.Sin((double)num5));
|
||||
num3 = ((float)Math.Sin((double)((1f - num) * num5))) * num6;
|
||||
num2 = flag ? (((float)(-Math.Sin((double)(num * num5))) * num6)) : (((float)Math.Sin((double)(num * num5))) * num6);
|
||||
}
|
||||
result.mX = (num3 * quaternion1.mX) + (num2 * quaternion2.mX);
|
||||
result.mY = (num3 * quaternion1.mY) + (num2 * quaternion2.mY);
|
||||
result.mZ = (num3 * quaternion1.mZ) + (num2 * quaternion2.mZ);
|
||||
result.mW = (num3 * quaternion1.mW) + (num2 * quaternion2.mW);
|
||||
}
|
||||
|
||||
|
||||
public static Quaternion Subtract(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = quaternion1.mX - quaternion2.mX;
|
||||
quaternion.mY = quaternion1.mY - quaternion2.mY;
|
||||
quaternion.mZ = quaternion1.mZ - quaternion2.mZ;
|
||||
quaternion.mW = quaternion1.mW - quaternion2.mW;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Subtract(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
|
||||
{
|
||||
result.mX = quaternion1.mX - quaternion2.mX;
|
||||
result.mY = quaternion1.mY - quaternion2.mY;
|
||||
result.mZ = quaternion1.mZ - quaternion2.mZ;
|
||||
result.mW = quaternion1.mW - quaternion2.mW;
|
||||
}
|
||||
|
||||
public static Quaternion Multiply(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float x = quaternion1.mX;
|
||||
float y = quaternion1.mY;
|
||||
float z = quaternion1.mZ;
|
||||
float w = quaternion1.mW;
|
||||
float num4 = quaternion2.mX;
|
||||
float num3 = quaternion2.mY;
|
||||
float num2 = quaternion2.mZ;
|
||||
float num = quaternion2.mW;
|
||||
float num12 = (y * num2) - (z * num3);
|
||||
float num11 = (z * num4) - (x * num2);
|
||||
float num10 = (x * num3) - (y * num4);
|
||||
float num9 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
quaternion.mX = ((x * num) + (num4 * w)) + num12;
|
||||
quaternion.mY = ((y * num) + (num3 * w)) + num11;
|
||||
quaternion.mZ = ((z * num) + (num2 * w)) + num10;
|
||||
quaternion.mW = (w * num) - num9;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static Quaternion Multiply(Quaternion quaternion1, float scaleFactor)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = quaternion1.mX * scaleFactor;
|
||||
quaternion.mY = quaternion1.mY * scaleFactor;
|
||||
quaternion.mZ = quaternion1.mZ * scaleFactor;
|
||||
quaternion.mW = quaternion1.mW * scaleFactor;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static void Multiply(ref Quaternion quaternion1, float scaleFactor, out Quaternion result)
|
||||
{
|
||||
result.mX = quaternion1.mX * scaleFactor;
|
||||
result.mY = quaternion1.mY * scaleFactor;
|
||||
result.mZ = quaternion1.mZ * scaleFactor;
|
||||
result.mW = quaternion1.mW * scaleFactor;
|
||||
}
|
||||
|
||||
public static void Multiply(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
|
||||
{
|
||||
float x = quaternion1.mX;
|
||||
float y = quaternion1.mY;
|
||||
float z = quaternion1.mZ;
|
||||
float w = quaternion1.mW;
|
||||
float num4 = quaternion2.mX;
|
||||
float num3 = quaternion2.mY;
|
||||
float num2 = quaternion2.mZ;
|
||||
float num = quaternion2.mW;
|
||||
float num12 = (y * num2) - (z * num3);
|
||||
float num11 = (z * num4) - (x * num2);
|
||||
float num10 = (x * num3) - (y * num4);
|
||||
float num9 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
result.mX = ((x * num) + (num4 * w)) + num12;
|
||||
result.mY = ((y * num) + (num3 * w)) + num11;
|
||||
result.mZ = ((z * num) + (num2 * w)) + num10;
|
||||
result.mW = (w * num) - num9;
|
||||
}
|
||||
|
||||
public static Quaternion Negate(Quaternion quaternion)
|
||||
{
|
||||
Quaternion quaternion2;
|
||||
quaternion2.mX = -quaternion.mX;
|
||||
quaternion2.mY = -quaternion.mY;
|
||||
quaternion2.mZ = -quaternion.mZ;
|
||||
quaternion2.mW = -quaternion.mW;
|
||||
return quaternion2;
|
||||
}
|
||||
|
||||
public static void Negate(ref Quaternion quaternion, out Quaternion result)
|
||||
{
|
||||
result.mX = -quaternion.mX;
|
||||
result.mY = -quaternion.mY;
|
||||
result.mZ = -quaternion.mZ;
|
||||
result.mW = -quaternion.mW;
|
||||
}
|
||||
|
||||
public void Normalize() mut
|
||||
{
|
||||
float num2 = (((mX * mX) + (mY * mY)) + (mZ * mZ)) + (mW * mW);
|
||||
float num = 1f / ((float)Math.Sqrt((double)num2));
|
||||
mX *= num;
|
||||
mY *= num;
|
||||
mZ *= num;
|
||||
mW *= num;
|
||||
}
|
||||
|
||||
public static Quaternion Normalize(Quaternion quaternion)
|
||||
{
|
||||
Quaternion quaternion2;
|
||||
float num2 = (((quaternion.mX * quaternion.mX) + (quaternion.mY * quaternion.mY)) + (quaternion.mZ * quaternion.mZ)) + (quaternion.mW * quaternion.mW);
|
||||
float num = 1f / ((float)Math.Sqrt((double)num2));
|
||||
quaternion2.mX = quaternion.mX * num;
|
||||
quaternion2.mY = quaternion.mY * num;
|
||||
quaternion2.mZ = quaternion.mZ * num;
|
||||
quaternion2.mW = quaternion.mW * num;
|
||||
return quaternion2;
|
||||
}
|
||||
|
||||
public static void Normalize(ref Quaternion quaternion, out Quaternion result)
|
||||
{
|
||||
float num2 = (((quaternion.mX * quaternion.mX) + (quaternion.mY * quaternion.mY)) + (quaternion.mZ * quaternion.mZ)) + (quaternion.mW * quaternion.mW);
|
||||
float num = 1f / ((float)Math.Sqrt((double)num2));
|
||||
result.mX = quaternion.mX * num;
|
||||
result.mY = quaternion.mY * num;
|
||||
result.mZ = quaternion.mZ * num;
|
||||
result.mW = quaternion.mW * num;
|
||||
}
|
||||
|
||||
public static Quaternion operator +(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = quaternion1.mX + quaternion2.mX;
|
||||
quaternion.mY = quaternion1.mY + quaternion2.mY;
|
||||
quaternion.mZ = quaternion1.mZ + quaternion2.mZ;
|
||||
quaternion.mW = quaternion1.mW + quaternion2.mW;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static Quaternion operator /(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float x = quaternion1.mX;
|
||||
float y = quaternion1.mY;
|
||||
float z = quaternion1.mZ;
|
||||
float w = quaternion1.mW;
|
||||
float num14 = (((quaternion2.mX * quaternion2.mX) + (quaternion2.mY * quaternion2.mY)) + (quaternion2.mZ * quaternion2.mZ)) + (quaternion2.mW * quaternion2.mW);
|
||||
float num5 = 1f / num14;
|
||||
float num4 = -quaternion2.mX * num5;
|
||||
float num3 = -quaternion2.mY * num5;
|
||||
float num2 = -quaternion2.mZ * num5;
|
||||
float num = quaternion2.mW * num5;
|
||||
float num13 = (y * num2) - (z * num3);
|
||||
float num12 = (z * num4) - (x * num2);
|
||||
float num11 = (x * num3) - (y * num4);
|
||||
float num10 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
quaternion.mX = ((x * num) + (num4 * w)) + num13;
|
||||
quaternion.mY = ((y * num) + (num3 * w)) + num12;
|
||||
quaternion.mZ = ((z * num) + (num2 * w)) + num11;
|
||||
quaternion.mW = (w * num) - num10;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static bool operator ==(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
return ((((quaternion1.mX == quaternion2.mX) && (quaternion1.mY == quaternion2.mY)) && (quaternion1.mZ == quaternion2.mZ)) && (quaternion1.mW == quaternion2.mW));
|
||||
}
|
||||
|
||||
public static bool operator !=(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
if (((quaternion1.mX == quaternion2.mX) && (quaternion1.mY == quaternion2.mY)) && (quaternion1.mZ == quaternion2.mZ))
|
||||
return (quaternion1.mW != quaternion2.mW);
|
||||
return true;
|
||||
}
|
||||
|
||||
public static Quaternion operator *(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
float x = quaternion1.mX;
|
||||
float y = quaternion1.mY;
|
||||
float z = quaternion1.mZ;
|
||||
float w = quaternion1.mW;
|
||||
float num4 = quaternion2.mX;
|
||||
float num3 = quaternion2.mY;
|
||||
float num2 = quaternion2.mZ;
|
||||
float num = quaternion2.mW;
|
||||
float num12 = (y * num2) - (z * num3);
|
||||
float num11 = (z * num4) - (x * num2);
|
||||
float num10 = (x * num3) - (y * num4);
|
||||
float num9 = ((x * num4) + (y * num3)) + (z * num2);
|
||||
quaternion.mX = ((x * num) + (num4 * w)) + num12;
|
||||
quaternion.mY = ((y * num) + (num3 * w)) + num11;
|
||||
quaternion.mZ = ((z * num) + (num2 * w)) + num10;
|
||||
quaternion.mW = (w * num) - num9;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static Quaternion operator *(Quaternion quaternion1, float scaleFactor)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = quaternion1.mX * scaleFactor;
|
||||
quaternion.mY = quaternion1.mY * scaleFactor;
|
||||
quaternion.mZ = quaternion1.mZ * scaleFactor;
|
||||
quaternion.mW = quaternion1.mW * scaleFactor;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static Quaternion operator -(Quaternion quaternion1, Quaternion quaternion2)
|
||||
{
|
||||
Quaternion quaternion;
|
||||
quaternion.mX = quaternion1.mX - quaternion2.mX;
|
||||
quaternion.mY = quaternion1.mY - quaternion2.mY;
|
||||
quaternion.mZ = quaternion1.mZ - quaternion2.mZ;
|
||||
quaternion.mW = quaternion1.mW - quaternion2.mW;
|
||||
return quaternion;
|
||||
}
|
||||
|
||||
public static Quaternion operator -(Quaternion quaternion)
|
||||
{
|
||||
Quaternion quaternion2;
|
||||
quaternion2.mX = -quaternion.mX;
|
||||
quaternion2.mY = -quaternion.mY;
|
||||
quaternion2.mZ = -quaternion.mZ;
|
||||
quaternion2.mW = -quaternion.mW;
|
||||
return quaternion2;
|
||||
}
|
||||
|
||||
public override void ToString(String outStr)
|
||||
{
|
||||
ThrowUnimplemented();
|
||||
}
|
||||
|
||||
internal Matrix4 ToMatrix()
|
||||
{
|
||||
Matrix4 matrix = Matrix4.Identity;
|
||||
ToMatrix(out matrix);
|
||||
return matrix;
|
||||
}
|
||||
|
||||
/*internal void ToMatrix(out Matrix4 matrix)
|
||||
{
|
||||
Quaternion.ToMatrix(this, out matrix);
|
||||
}*/
|
||||
|
||||
public void ToMatrix(out Matrix4 matrix)
|
||||
{
|
||||
float fTx = mX + mX;
|
||||
float fTy = mY + mY;
|
||||
float fTz = mZ + mZ;
|
||||
float fTwx = fTx * mW;
|
||||
float fTwy = fTy * mW;
|
||||
float fTwz = fTz * mW;
|
||||
float fTxx = fTx * mX;
|
||||
float fTxy = fTy * mX;
|
||||
float fTxz = fTz * mX;
|
||||
float fTyy = fTy * mY;
|
||||
float fTyz = fTz * mY;
|
||||
float fTzz = fTz * mZ;
|
||||
|
||||
matrix.m00 = 1.0f - (fTyy + fTzz);
|
||||
matrix.m01 = fTxy - fTwz;
|
||||
matrix.m02 = fTxz + fTwy;
|
||||
matrix.m03 = 0;
|
||||
|
||||
matrix.m10 = fTxy + fTwz;
|
||||
matrix.m11 = 1.0f - (fTxx + fTzz);
|
||||
matrix.m12 = fTyz - fTwx;
|
||||
matrix.m13 = 0;
|
||||
|
||||
matrix.m20 = fTxz - fTwy;
|
||||
matrix.m21 = fTyz + fTwx;
|
||||
matrix.m22 = 1.0f - (fTxx + fTyy);
|
||||
matrix.m23 = 0;
|
||||
|
||||
matrix.m30 = 0;
|
||||
matrix.m31 = 0;
|
||||
matrix.m32 = 0;
|
||||
matrix.m33 = 1.0f;
|
||||
}
|
||||
|
||||
internal Vector3 XYZ
|
||||
{
|
||||
get
|
||||
{
|
||||
return Vector3(mX, mY, mZ);
|
||||
}
|
||||
|
||||
set mut
|
||||
{
|
||||
mX = value.mX;
|
||||
mY = value.mY;
|
||||
mZ = value.mZ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
197
BeefLibs/Beefy2D/src/geom/Rect.bf
Normal file
197
BeefLibs/Beefy2D/src/geom/Rect.bf
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using Beefy.gfx;
|
||||
|
||||
namespace Beefy.geom
|
||||
{
|
||||
public struct Rect
|
||||
{
|
||||
public float mX;
|
||||
public float mY;
|
||||
public float mWidth;
|
||||
public float mHeight;
|
||||
|
||||
public float Left
|
||||
{
|
||||
get
|
||||
{
|
||||
return mX;
|
||||
}
|
||||
}
|
||||
|
||||
public float Top
|
||||
{
|
||||
get
|
||||
{
|
||||
return mY;
|
||||
}
|
||||
}
|
||||
|
||||
public float Right
|
||||
{
|
||||
get
|
||||
{
|
||||
return mX + mWidth;
|
||||
}
|
||||
}
|
||||
|
||||
public float Bottom
|
||||
{
|
||||
get
|
||||
{
|
||||
return mY + mHeight;
|
||||
}
|
||||
}
|
||||
|
||||
public float Width
|
||||
{
|
||||
get
|
||||
{
|
||||
return mWidth;
|
||||
}
|
||||
}
|
||||
|
||||
public float Height
|
||||
{
|
||||
get
|
||||
{
|
||||
return mHeight;
|
||||
}
|
||||
}
|
||||
|
||||
public this(float x = 0, float y = 0, float width = 0, float height = 0)
|
||||
{
|
||||
mX = x;
|
||||
mY = y;
|
||||
mWidth = width;
|
||||
mHeight = height;
|
||||
}
|
||||
|
||||
public void Set(float x = 0, float y = 0, float width = 0, float height = 0) mut
|
||||
{
|
||||
mX = x;
|
||||
mY = y;
|
||||
mWidth = width;
|
||||
mHeight = height;
|
||||
}
|
||||
|
||||
public bool Intersects(Rect rect)
|
||||
{
|
||||
return !((rect.mX + rect.mWidth <= mX) ||
|
||||
(rect.mY + rect.mHeight <= mY) ||
|
||||
(rect.mX >= mX + mWidth) ||
|
||||
(rect.mY >= mY + mHeight));
|
||||
}
|
||||
|
||||
public void SetIntersectionOf(Rect rect1, Rect rect2) mut
|
||||
{
|
||||
float x1 = Math.Max(rect1.mX, rect2.mX);
|
||||
float x2 = Math.Min(rect1.mX + rect1.mWidth, rect2.mX + rect2.mWidth);
|
||||
float y1 = Math.Max(rect1.mY, rect2.mY);
|
||||
float y2 = Math.Min(rect1.mY + rect1.mHeight, rect2.mY + rect2.mHeight);
|
||||
if (((x2 - x1) < 0) || ((y2 - y1) < 0))
|
||||
{
|
||||
mX = 0;
|
||||
mY = 0;
|
||||
mWidth = 0;
|
||||
mHeight = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
mX = x1;
|
||||
mY = y1;
|
||||
mWidth = x2 - x1;
|
||||
mHeight = y2 - y1;
|
||||
}
|
||||
}
|
||||
|
||||
public void SetIntersectionOf(Rect rect1, float x, float y, float width, float height) mut
|
||||
{
|
||||
float x1 = Math.Max(rect1.mX, x);
|
||||
float x2 = Math.Min(rect1.mX + rect1.mWidth, x + width);
|
||||
float y1 = Math.Max(rect1.mY, y);
|
||||
float y2 = Math.Min(rect1.mY + rect1.mHeight, y + height);
|
||||
if (((x2 - x1) < 0) || ((y2 - y1) < 0))
|
||||
{
|
||||
mX = 0;
|
||||
mY = 0;
|
||||
mWidth = 0;
|
||||
mHeight = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
mX = x1;
|
||||
mY = y1;
|
||||
mWidth = x2 - x1;
|
||||
mHeight = y2 - y1;
|
||||
}
|
||||
}
|
||||
|
||||
public Rect Intersection(Rect rect)
|
||||
{
|
||||
float x1 = Math.Max(mX, rect.mX);
|
||||
float x2 = Math.Min(mX + mWidth, rect.mX + rect.mWidth);
|
||||
float y1 = Math.Max(mY, rect.mY);
|
||||
float y2 = Math.Min(mY + mHeight, rect.mY + rect.mHeight);
|
||||
if (((x2 - x1) < 0) || ((y2 - y1) < 0))
|
||||
return Rect(0, 0, 0, 0);
|
||||
else
|
||||
return Rect(x1, y1, x2 - x1, y2 - y1);
|
||||
}
|
||||
|
||||
public Rect Union(Rect rect)
|
||||
{
|
||||
float x1 = Math.Min(mX, rect.mX);
|
||||
float x2 = Math.Max(mX + mWidth, rect.mX + rect.mWidth);
|
||||
float y1 = Math.Min(mY, rect.mY);
|
||||
float y2 = Math.Max(mY + mHeight, rect.mY + rect.mHeight);
|
||||
return Rect(x1, y1, x2 - x1, y2 - y1);
|
||||
}
|
||||
|
||||
public bool Contains(float x, float y)
|
||||
{
|
||||
return ((x >= mX) && (x < mX + mWidth) &&
|
||||
(y >= mY) && (y < mY + mHeight));
|
||||
}
|
||||
|
||||
public bool Contains(Point pt)
|
||||
{
|
||||
return Contains(pt.x, pt.y);
|
||||
}
|
||||
|
||||
public bool Contains(Rect rect)
|
||||
{
|
||||
return Contains(rect.mX, rect.mY) && Contains(rect.mX + rect.mWidth, rect.mY + rect.mHeight);
|
||||
}
|
||||
|
||||
public void Offset(float x, float y) mut
|
||||
{
|
||||
mX += x;
|
||||
mY += y;
|
||||
}
|
||||
|
||||
public void Inflate(float x, float y) mut
|
||||
{
|
||||
mX -= x;
|
||||
mWidth += x * 2;
|
||||
mY -= y;
|
||||
mHeight += y * 2;
|
||||
}
|
||||
|
||||
public void Scale(float scaleX, float scaleY) mut
|
||||
{
|
||||
mX *= scaleX;
|
||||
mY *= scaleY;
|
||||
mWidth *= scaleX;
|
||||
mHeight *= scaleY;
|
||||
}
|
||||
|
||||
public void ScaleFrom(float scaleX, float scaleY, float centerX, float centerY) mut
|
||||
{
|
||||
Offset(-centerX, -centerY);
|
||||
Scale(scaleX, scaleY);
|
||||
Offset(centerX, centerY);
|
||||
}
|
||||
}
|
||||
}
|
||||
87
BeefLibs/Beefy2D/src/geom/Vector2.bf
Normal file
87
BeefLibs/Beefy2D/src/geom/Vector2.bf
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace Beefy.geom
|
||||
{
|
||||
public struct Vector2
|
||||
{
|
||||
public float mX;
|
||||
public float mY;
|
||||
|
||||
public float Length
|
||||
{
|
||||
get
|
||||
{
|
||||
return (float)Math.Sqrt(mX * mX + mY * mY);
|
||||
}
|
||||
}
|
||||
|
||||
public float LengthSquared
|
||||
{
|
||||
get
|
||||
{
|
||||
return mX * mX + mY * mY;
|
||||
}
|
||||
}
|
||||
|
||||
public this(float x, float y)
|
||||
{
|
||||
mX = x;
|
||||
mY = y;
|
||||
}
|
||||
|
||||
public static void DistanceSquared(Vector2 value1, Vector2 value2, out float result)
|
||||
{
|
||||
result = (value1.mX - value2.mX) * (value1.mX - value2.mX) +
|
||||
(value1.mY - value2.mY) * (value1.mY - value2.mY);
|
||||
}
|
||||
|
||||
public static float Distance(Vector2 vector1, Vector2 vector2)
|
||||
{
|
||||
float result;
|
||||
DistanceSquared(vector1, vector2, out result);
|
||||
return (float)Math.Sqrt(result);
|
||||
}
|
||||
|
||||
public static Vector2 Add(Vector2 vec1, Vector2 vec2)
|
||||
{
|
||||
return Vector2(vec1.mX + vec2.mX, vec1.mY + vec2.mY);
|
||||
}
|
||||
|
||||
public static Vector2 Subtract(Vector2 vec1, Vector2 vec2)
|
||||
{
|
||||
return Vector2(vec1.mX - vec2.mX, vec1.mY - vec2.mY);
|
||||
}
|
||||
|
||||
public static float Dot(Vector2 vec1, Vector2 vec2)
|
||||
{
|
||||
return vec1.mX * vec2.mX + vec1.mY * vec2.mY;
|
||||
}
|
||||
|
||||
public static Vector2 FromAngle(float angle, float length = 1.0f)
|
||||
{
|
||||
return Vector2((float)Math.Cos(angle) * length, (float)Math.Sin(angle) * length);
|
||||
}
|
||||
|
||||
public static Vector2 operator +(Vector2 vec1, Vector2 vec2)
|
||||
{
|
||||
return Vector2(vec1.mX + vec2.mX, vec1.mY + vec2.mY);
|
||||
}
|
||||
|
||||
public static Vector2 operator -(Vector2 vec1, Vector2 vec2)
|
||||
{
|
||||
return Vector2(vec1.mX - vec2.mX, vec1.mY - vec2.mY);
|
||||
}
|
||||
|
||||
public static Vector2 operator *(Vector2 vec1, float factor)
|
||||
{
|
||||
return Vector2(vec1.mX * factor, vec1.mY * factor);
|
||||
}
|
||||
|
||||
public static Vector2 operator /(Vector2 vec1, float factor)
|
||||
{
|
||||
return Vector2(vec1.mX / factor, vec1.mY / factor);
|
||||
}
|
||||
}
|
||||
}
|
||||
247
BeefLibs/Beefy2D/src/geom/Vector3.bf
Normal file
247
BeefLibs/Beefy2D/src/geom/Vector3.bf
Normal file
|
|
@ -0,0 +1,247 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Beefy.gfx;
|
||||
|
||||
namespace Beefy.geom
|
||||
{
|
||||
public struct Vector3 : IHashable, IEquatable<Vector3>
|
||||
{
|
||||
[Reflect]
|
||||
public float mX;
|
||||
[Reflect]
|
||||
public float mY;
|
||||
[Reflect]
|
||||
public float mZ;
|
||||
|
||||
private static Vector3 sZero = Vector3(0f, 0f, 0f);
|
||||
private static Vector3 sOne = Vector3(1f, 1f, 1f);
|
||||
private static Vector3 sUnitX = Vector3(1f, 0f, 0f);
|
||||
private static Vector3 sUnitY = Vector3(0f, 1f, 0f);
|
||||
private static Vector3 sUnitZ = Vector3(0f, 0f, 1f);
|
||||
private static Vector3 sUp = Vector3(0f, 1f, 0f);
|
||||
private static Vector3 sDown = Vector3(0f, -1f, 0f);
|
||||
private static Vector3 sRight = Vector3(1f, 0f, 0f);
|
||||
private static Vector3 sLeft = Vector3(-1f, 0f, 0f);
|
||||
private static Vector3 sForward = Vector3(0f, 0f, -1f);
|
||||
private static Vector3 sBackward = Vector3(0f, 0f, 1f);
|
||||
|
||||
public static Vector3 Zero
|
||||
{
|
||||
get { return sZero; }
|
||||
}
|
||||
|
||||
public static Vector3 One
|
||||
{
|
||||
get { return sOne; }
|
||||
}
|
||||
|
||||
public static Vector3 UnitX
|
||||
{
|
||||
get { return sUnitX; }
|
||||
}
|
||||
|
||||
public static Vector3 UnitY
|
||||
{
|
||||
get { return sUnitY; }
|
||||
}
|
||||
|
||||
public static Vector3 UnitZ
|
||||
{
|
||||
get { return sUnitZ; }
|
||||
}
|
||||
|
||||
public static Vector3 Up
|
||||
{
|
||||
get { return sUp; }
|
||||
}
|
||||
|
||||
public static Vector3 Down
|
||||
{
|
||||
get { return sDown; }
|
||||
}
|
||||
|
||||
public static Vector3 Right
|
||||
{
|
||||
get { return sRight; }
|
||||
}
|
||||
|
||||
public static Vector3 Left
|
||||
{
|
||||
get { return sLeft; }
|
||||
}
|
||||
|
||||
public static Vector3 Forward
|
||||
{
|
||||
get { return sForward; }
|
||||
}
|
||||
|
||||
public static Vector3 Backward
|
||||
{
|
||||
get { return sBackward; }
|
||||
}
|
||||
|
||||
public float Length
|
||||
{
|
||||
get
|
||||
{
|
||||
return (float)Math.Sqrt(mX * mX + mY * mY + mZ * mZ);
|
||||
}
|
||||
}
|
||||
|
||||
public float LengthSquared
|
||||
{
|
||||
get
|
||||
{
|
||||
return mX * mX + mY * mY + mZ * mZ;
|
||||
}
|
||||
}
|
||||
|
||||
public this(float x, float y, float z)
|
||||
{
|
||||
mX = x;
|
||||
mY = y;
|
||||
mZ = z;
|
||||
}
|
||||
|
||||
public bool Equals(Vector3 other)
|
||||
{
|
||||
return this == other;
|
||||
}
|
||||
|
||||
public int GetHashCode()
|
||||
{
|
||||
return (int)(this.mX + this.mY + this.mZ);
|
||||
}
|
||||
|
||||
|
||||
/*public static Vector2D Add(Vector2D vec1, Vector2D vec2)
|
||||
{
|
||||
return new Vector2D(vec1.mX + vec2.mX, vec1.mY + vec2.mY);
|
||||
}
|
||||
|
||||
public static Vector2D Subtract(Vector2D vec1, Vector2D vec2)
|
||||
{
|
||||
return new Vector2D(vec1.mX - vec2.mX, vec1.mY - vec2.mY);
|
||||
}*/
|
||||
|
||||
|
||||
public static Vector3 Normalize(Vector3 vector)
|
||||
{
|
||||
Vector3 newVec;
|
||||
Normalize(vector, out newVec);
|
||||
return vector;
|
||||
}
|
||||
|
||||
public static void Normalize(Vector3 value, out Vector3 result)
|
||||
{
|
||||
float factor= Distance(value, sZero);
|
||||
factor = 1f / factor;
|
||||
result.mX = value.mX * factor;
|
||||
result.mY = value.mY * factor;
|
||||
result.mZ = value.mZ * factor;
|
||||
}
|
||||
|
||||
public static float Dot(Vector3 vec1, Vector3 vec2)
|
||||
{
|
||||
return vec1.mX * vec2.mX + vec1.mY * vec2.mY + vec1.mZ * vec2.mZ;
|
||||
}
|
||||
|
||||
public static Vector3 Cross(Vector3 vector1, Vector3 vector2)
|
||||
{
|
||||
return Vector3(vector1.mY * vector2.mZ - vector2.mY * vector1.mZ,
|
||||
-(vector1.mX * vector2.mZ - vector2.mX * vector1.mZ),
|
||||
vector1.mX * vector2.mY - vector2.mX * vector1.mY);
|
||||
}
|
||||
|
||||
public static float DistanceSquared(Vector3 value1, Vector3 value2)
|
||||
{
|
||||
return (value1.mX - value2.mX) * (value1.mX - value2.mX) +
|
||||
(value1.mY - value2.mY) * (value1.mY - value2.mY) +
|
||||
(value1.mZ - value2.mZ) * (value1.mZ - value2.mZ);
|
||||
}
|
||||
|
||||
public static float Distance(Vector3 vector1, Vector3 vector2)
|
||||
{
|
||||
float result = DistanceSquared(vector1, vector2);
|
||||
return (float)Math.Sqrt(result);
|
||||
}
|
||||
|
||||
/*public static Vector2D FromAngle(float angle, float length = 1.0f)
|
||||
{
|
||||
return new Vector2D((float)Math.Cos(angle) * length, (float)Math.Sin(angle) * length);
|
||||
}*/
|
||||
|
||||
public static Vector3 Transform(Vector3 vec, Matrix4 matrix)
|
||||
{
|
||||
Vector3 result;
|
||||
float fInvW = 1.0f / (matrix.m30 * vec.mX + matrix.m31 * vec.mY + matrix.m32 * vec.mZ + matrix.m33);
|
||||
|
||||
result.mX = (matrix.m00 * vec.mX + matrix.m01 * vec.mY + matrix.m02 * vec.mZ + matrix.m03) * fInvW;
|
||||
result.mY = (matrix.m10 * vec.mX + matrix.m11 * vec.mY + matrix.m12 * vec.mZ + matrix.m13) * fInvW;
|
||||
result.mZ = (matrix.m20 * vec.mX + matrix.m21 * vec.mY + matrix.m22 * vec.mZ + matrix.m23) * fInvW;
|
||||
return result;
|
||||
}
|
||||
|
||||
/*public static void Transform(Vector3[] sourceArray, ref Matrix4 matrix, Vector3[] destinationArray)
|
||||
{
|
||||
//Debug.Assert(destinationArray.Length >= sourceArray.Length, "The destination array is smaller than the source array.");
|
||||
|
||||
for (var i = 0; i < sourceArray.Length; i++)
|
||||
{
|
||||
var position = sourceArray[i];
|
||||
destinationArray[i] =
|
||||
new Vector3(
|
||||
(position.mX * matrix.m11) + (position.mY * matrix.m21) + (position.mZ * matrix.m31) + matrix.m41,
|
||||
(position.mX * matrix.m12) + (position.mY * matrix.m22) + (position.mZ * matrix.m32) + matrix.m42,
|
||||
(position.mX * matrix.m13) + (position.mY * matrix.m23) + (position.mZ * matrix.m33) + matrix.m43);
|
||||
}
|
||||
}*/
|
||||
|
||||
public static Vector3 Transform(Vector3 vec, Quaternion quat)
|
||||
{
|
||||
Matrix4 matrix = quat.ToMatrix();
|
||||
return Transform(vec, matrix);
|
||||
}
|
||||
|
||||
public static Vector3 TransformNormal(Vector3 normal, Matrix4 matrix)
|
||||
{
|
||||
return Vector3((normal.mX * matrix.m11) + (normal.mY * matrix.m21) + (normal.mZ * matrix.m31),
|
||||
(normal.mX * matrix.m12) + (normal.mY * matrix.m22) + (normal.mZ * matrix.m32),
|
||||
(normal.mX * matrix.m13) + (normal.mY * matrix.m23) + (normal.mZ * matrix.m33));
|
||||
}
|
||||
|
||||
public static bool operator ==(Vector3 value1, Vector3 value2)
|
||||
{
|
||||
return (value1.mX == value2.mX) &&
|
||||
(value1.mY == value2.mY) &&
|
||||
(value1.mZ == value2.mZ);
|
||||
}
|
||||
|
||||
public static bool operator !=(Vector3 value1, Vector3 value2)
|
||||
{
|
||||
return !(value1 == value2);
|
||||
}
|
||||
|
||||
public static Vector3 operator +(Vector3 vec1, Vector3 vec2)
|
||||
{
|
||||
return Vector3(vec1.mX + vec2.mX, vec1.mY + vec2.mY, vec1.mZ + vec2.mZ);
|
||||
}
|
||||
|
||||
public static Vector3 operator -(Vector3 vec1, Vector3 vec2)
|
||||
{
|
||||
return Vector3(vec1.mX - vec2.mX, vec1.mY - vec2.mY, vec1.mZ - vec2.mZ);
|
||||
}
|
||||
|
||||
public static Vector3 operator *(Vector3 vec, float scale)
|
||||
{
|
||||
return Vector3(vec.mX * scale, vec.mY * scale, vec.mZ * scale);
|
||||
}
|
||||
|
||||
public override void ToString(String str)
|
||||
{
|
||||
str.AppendF("{0:0.0#}, {1:0.0#}, {2:0.0#}", mX, mY, mZ);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue