update raylib and deps
This commit is contained in:
Juan Medina
parent
fd64d4172a
commit
3fcffd9168
31 changed files with 43817 additions and 12586 deletions
413
raylib/raymath.h
413
raylib/raymath.h
|
|
@ -154,6 +154,18 @@ RMDEF float Lerp(float start, float end, float amount)
|
|||
return start + amount*(end - start);
|
||||
}
|
||||
|
||||
// Normalize input value within input range
|
||||
RMDEF float Normalize(float value, float start, float end)
|
||||
{
|
||||
return (value - start) / (end - start);
|
||||
}
|
||||
|
||||
// Remap input value within input range to output range
|
||||
RMDEF float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd)
|
||||
{
|
||||
return (value - inputStart) / (inputEnd - inputStart) * (outputEnd - outputStart) + outputStart;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Module Functions Definition - Vector2 math
|
||||
//----------------------------------------------------------------------------------
|
||||
|
|
@ -179,6 +191,13 @@ RMDEF Vector2 Vector2Add(Vector2 v1, Vector2 v2)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Add vector and float value
|
||||
RMDEF Vector2 Vector2AddValue(Vector2 v, float add)
|
||||
{
|
||||
Vector2 result = { v.x + add, v.y + add };
|
||||
return result;
|
||||
}
|
||||
|
||||
// Subtract two vectors (v1 - v2)
|
||||
RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
|
||||
{
|
||||
|
|
@ -186,6 +205,13 @@ RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Subtract vector by float value
|
||||
RMDEF Vector2 Vector2SubtractValue(Vector2 v, float sub)
|
||||
{
|
||||
Vector2 result = { v.x - sub, v.y - sub };
|
||||
return result;
|
||||
}
|
||||
|
||||
// Calculate vector length
|
||||
RMDEF float Vector2Length(Vector2 v)
|
||||
{
|
||||
|
|
@ -193,6 +219,13 @@ RMDEF float Vector2Length(Vector2 v)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Calculate vector square length
|
||||
RMDEF float Vector2LengthSqr(Vector2 v)
|
||||
{
|
||||
float result = (v.x*v.x) + (v.y*v.y);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Calculate two vectors dot product
|
||||
RMDEF float Vector2DotProduct(Vector2 v1, Vector2 v2)
|
||||
{
|
||||
|
|
@ -223,7 +256,7 @@ RMDEF Vector2 Vector2Scale(Vector2 v, float scale)
|
|||
}
|
||||
|
||||
// Multiply vector by vector
|
||||
RMDEF Vector2 Vector2MultiplyV(Vector2 v1, Vector2 v2)
|
||||
RMDEF Vector2 Vector2Multiply(Vector2 v1, Vector2 v2)
|
||||
{
|
||||
Vector2 result = { v1.x*v2.x, v1.y*v2.y };
|
||||
return result;
|
||||
|
|
@ -236,15 +269,8 @@ RMDEF Vector2 Vector2Negate(Vector2 v)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Divide vector by a float value
|
||||
RMDEF Vector2 Vector2Divide(Vector2 v, float div)
|
||||
{
|
||||
Vector2 result = { v.x/div, v.y/div };
|
||||
return result;
|
||||
}
|
||||
|
||||
// Divide vector by vector
|
||||
RMDEF Vector2 Vector2DivideV(Vector2 v1, Vector2 v2)
|
||||
RMDEF Vector2 Vector2Divide(Vector2 v1, Vector2 v2)
|
||||
{
|
||||
Vector2 result = { v1.x/v2.x, v1.y/v2.y };
|
||||
return result;
|
||||
|
|
@ -253,7 +279,7 @@ RMDEF Vector2 Vector2DivideV(Vector2 v1, Vector2 v2)
|
|||
// Normalize provided vector
|
||||
RMDEF Vector2 Vector2Normalize(Vector2 v)
|
||||
{
|
||||
Vector2 result = Vector2Divide(v, Vector2Length(v));
|
||||
Vector2 result = Vector2Scale(v, 1/Vector2Length(v));
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -276,6 +302,24 @@ RMDEF Vector2 Vector2Rotate(Vector2 v, float degs)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Move Vector towards target
|
||||
RMDEF Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance)
|
||||
{
|
||||
Vector2 result = { 0 };
|
||||
float dx = target.x - v.x;
|
||||
float dy = target.y - v.y;
|
||||
float value = (dx*dx) + (dy*dy);
|
||||
|
||||
if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) result = target;
|
||||
|
||||
float dist = sqrtf(value);
|
||||
|
||||
result.x = v.x + dx/dist*maxDistance;
|
||||
result.y = v.y + dy/dist*maxDistance;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Module Functions Definition - Vector3 math
|
||||
//----------------------------------------------------------------------------------
|
||||
|
|
@ -301,6 +345,13 @@ RMDEF Vector3 Vector3Add(Vector3 v1, Vector3 v2)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Add vector and float value
|
||||
RMDEF Vector3 Vector3AddValue(Vector3 v, float add)
|
||||
{
|
||||
Vector3 result = { v.x + add, v.y + add, v.z + add };
|
||||
return result;
|
||||
}
|
||||
|
||||
// Subtract two vectors
|
||||
RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)
|
||||
{
|
||||
|
|
@ -308,6 +359,13 @@ RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Subtract vector by float value
|
||||
RMDEF Vector3 Vector3SubtractValue(Vector3 v, float sub)
|
||||
{
|
||||
Vector3 result = { v.x - sub, v.y - sub, v.z - sub };
|
||||
return result;
|
||||
}
|
||||
|
||||
// Multiply vector by scalar
|
||||
RMDEF Vector3 Vector3Scale(Vector3 v, float scalar)
|
||||
{
|
||||
|
|
@ -362,6 +420,13 @@ RMDEF float Vector3Length(const Vector3 v)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Calculate vector square length
|
||||
RMDEF float Vector3LengthSqr(const Vector3 v)
|
||||
{
|
||||
float result = v.x*v.x + v.y*v.y + v.z*v.z;
|
||||
return result;
|
||||
}
|
||||
|
||||
// Calculate two vectors dot product
|
||||
RMDEF float Vector3DotProduct(Vector3 v1, Vector3 v2)
|
||||
{
|
||||
|
|
@ -386,15 +451,8 @@ RMDEF Vector3 Vector3Negate(Vector3 v)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Divide vector by a float value
|
||||
RMDEF Vector3 Vector3Divide(Vector3 v, float div)
|
||||
{
|
||||
Vector3 result = { v.x / div, v.y / div, v.z / div };
|
||||
return result;
|
||||
}
|
||||
|
||||
// Divide vector by vector
|
||||
RMDEF Vector3 Vector3DivideV(Vector3 v1, Vector3 v2)
|
||||
RMDEF Vector3 Vector3Divide(Vector3 v1, Vector3 v2)
|
||||
{
|
||||
Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z };
|
||||
return result;
|
||||
|
|
@ -737,6 +795,32 @@ RMDEF Matrix MatrixSubtract(Matrix left, Matrix right)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Returns two matrix multiplication
|
||||
// NOTE: When multiplying matrices... the order matters!
|
||||
RMDEF Matrix MatrixMultiply(Matrix left, Matrix right)
|
||||
{
|
||||
Matrix result = { 0 };
|
||||
|
||||
result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
|
||||
result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
|
||||
result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14;
|
||||
result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15;
|
||||
result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12;
|
||||
result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13;
|
||||
result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14;
|
||||
result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15;
|
||||
result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12;
|
||||
result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13;
|
||||
result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14;
|
||||
result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15;
|
||||
result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12;
|
||||
result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13;
|
||||
result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14;
|
||||
result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns translation matrix
|
||||
RMDEF Matrix MatrixTranslate(float x, float y, float z)
|
||||
{
|
||||
|
|
@ -793,33 +877,6 @@ RMDEF Matrix MatrixRotate(Vector3 axis, float angle)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Returns xyz-rotation matrix (angles in radians)
|
||||
RMDEF Matrix MatrixRotateXYZ(Vector3 ang)
|
||||
{
|
||||
Matrix result = MatrixIdentity();
|
||||
|
||||
float cosz = cosf(-ang.z);
|
||||
float sinz = sinf(-ang.z);
|
||||
float cosy = cosf(-ang.y);
|
||||
float siny = sinf(-ang.y);
|
||||
float cosx = cosf(-ang.x);
|
||||
float sinx = sinf(-ang.x);
|
||||
|
||||
result.m0 = cosz * cosy;
|
||||
result.m4 = (cosz * siny * sinx) - (sinz * cosx);
|
||||
result.m8 = (cosz * siny * cosx) + (sinz * sinx);
|
||||
|
||||
result.m1 = sinz * cosy;
|
||||
result.m5 = (sinz * siny * sinx) + (cosz * cosx);
|
||||
result.m9 = (sinz * siny * cosx) - (cosz * sinx);
|
||||
|
||||
result.m2 = -siny;
|
||||
result.m6 = cosy * sinx;
|
||||
result.m10= cosy * cosx;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns x-rotation matrix (angle in radians)
|
||||
RMDEF Matrix MatrixRotateX(float angle)
|
||||
{
|
||||
|
|
@ -868,6 +925,46 @@ RMDEF Matrix MatrixRotateZ(float angle)
|
|||
return result;
|
||||
}
|
||||
|
||||
|
||||
// Returns xyz-rotation matrix (angles in radians)
|
||||
RMDEF Matrix MatrixRotateXYZ(Vector3 ang)
|
||||
{
|
||||
Matrix result = MatrixIdentity();
|
||||
|
||||
float cosz = cosf(-ang.z);
|
||||
float sinz = sinf(-ang.z);
|
||||
float cosy = cosf(-ang.y);
|
||||
float siny = sinf(-ang.y);
|
||||
float cosx = cosf(-ang.x);
|
||||
float sinx = sinf(-ang.x);
|
||||
|
||||
result.m0 = cosz * cosy;
|
||||
result.m4 = (cosz * siny * sinx) - (sinz * cosx);
|
||||
result.m8 = (cosz * siny * cosx) + (sinz * sinx);
|
||||
|
||||
result.m1 = sinz * cosy;
|
||||
result.m5 = (sinz * siny * sinx) + (cosz * cosx);
|
||||
result.m9 = (sinz * siny * cosx) - (cosz * sinx);
|
||||
|
||||
result.m2 = -siny;
|
||||
result.m6 = cosy * sinx;
|
||||
result.m10= cosy * cosx;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns zyx-rotation matrix (angles in radians)
|
||||
// TODO: This solution is suboptimal, it should be possible to create this matrix in one go
|
||||
// instead of using a 3 matrix multiplication
|
||||
RMDEF Matrix MatrixRotateZYX(Vector3 ang)
|
||||
{
|
||||
Matrix result = MatrixRotateZ(ang.z);
|
||||
result = MatrixMultiply(result, MatrixRotateY(ang.y));
|
||||
result = MatrixMultiply(result, MatrixRotateX(ang.x));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns scaling matrix
|
||||
RMDEF Matrix MatrixScale(float x, float y, float z)
|
||||
{
|
||||
|
|
@ -879,32 +976,6 @@ RMDEF Matrix MatrixScale(float x, float y, float z)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Returns two matrix multiplication
|
||||
// NOTE: When multiplying matrices... the order matters!
|
||||
RMDEF Matrix MatrixMultiply(Matrix left, Matrix right)
|
||||
{
|
||||
Matrix result = { 0 };
|
||||
|
||||
result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
|
||||
result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
|
||||
result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14;
|
||||
result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15;
|
||||
result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12;
|
||||
result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13;
|
||||
result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14;
|
||||
result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15;
|
||||
result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12;
|
||||
result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13;
|
||||
result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14;
|
||||
result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15;
|
||||
result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12;
|
||||
result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13;
|
||||
result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14;
|
||||
result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns perspective projection matrix
|
||||
RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far)
|
||||
{
|
||||
|
|
@ -1040,6 +1111,34 @@ RMDEF float16 MatrixToFloatV(Matrix mat)
|
|||
// Module Functions Definition - Quaternion math
|
||||
//----------------------------------------------------------------------------------
|
||||
|
||||
// Add two quaternions
|
||||
RMDEF Quaternion QuaternionAdd(Quaternion q1, Quaternion q2)
|
||||
{
|
||||
Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w};
|
||||
return result;
|
||||
}
|
||||
|
||||
// Add quaternion and float value
|
||||
RMDEF Quaternion QuaternionAddValue(Quaternion q, float add)
|
||||
{
|
||||
Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add};
|
||||
return result;
|
||||
}
|
||||
|
||||
// Subtract two quaternions
|
||||
RMDEF Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2)
|
||||
{
|
||||
Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w};
|
||||
return result;
|
||||
}
|
||||
|
||||
// Subtract quaternion and float value
|
||||
RMDEF Quaternion QuaternionSubtractValue(Quaternion q, float sub)
|
||||
{
|
||||
Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub};
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns identity quaternion
|
||||
RMDEF Quaternion QuaternionIdentity(void)
|
||||
{
|
||||
|
|
@ -1108,6 +1207,28 @@ RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Scale quaternion by float value
|
||||
RMDEF Quaternion QuaternionScale(Quaternion q, float mul)
|
||||
{
|
||||
Quaternion result = { 0 };
|
||||
|
||||
float qax = q.x, qay = q.y, qaz = q.z, qaw = q.w;
|
||||
|
||||
result.x = qax * mul + qaw * mul + qay * mul - qaz * mul;
|
||||
result.y = qay * mul + qaw * mul + qaz * mul - qax * mul;
|
||||
result.z = qaz * mul + qaw * mul + qax * mul - qay * mul;
|
||||
result.w = qaw * mul - qax * mul - qay * mul - qaz * mul;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Divide two quaternions
|
||||
RMDEF Quaternion QuaternionDivide(Quaternion q1, Quaternion q2)
|
||||
{
|
||||
Quaternion result = {q1.x / q2.x, q1.y / q2.y, q1.z / q2.z, q1.w / q2.w};
|
||||
return result;
|
||||
}
|
||||
|
||||
// Calculate linear interpolation between two quaternions
|
||||
RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)
|
||||
{
|
||||
|
|
@ -1176,7 +1297,7 @@ RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
|
|||
|
||||
result.x = cross.x;
|
||||
result.y = cross.y;
|
||||
result.z = cross.y;
|
||||
result.z = cross.z;
|
||||
result.w = 1.0f + cos2Theta; // NOTE: Added QuaternioIdentity()
|
||||
|
||||
// Normalize to essentially nlerp the original and identity to 0.5
|
||||
|
|
@ -1191,101 +1312,58 @@ RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
|
|||
// Returns a quaternion for a given rotation matrix
|
||||
RMDEF Quaternion QuaternionFromMatrix(Matrix mat)
|
||||
{
|
||||
Quaternion result = { 0 };
|
||||
|
||||
float trace = MatrixTrace(mat);
|
||||
|
||||
if (trace > 0.0f)
|
||||
Quaternion result = { 0.0f };
|
||||
|
||||
if ((mat.m0 > mat.m5) && (mat.m0 > mat.m10))
|
||||
{
|
||||
float s = sqrtf(trace + 1)*2.0f;
|
||||
float invS = 1.0f/s;
|
||||
|
||||
result.w = s*0.25f;
|
||||
result.x = (mat.m6 - mat.m9)*invS;
|
||||
result.y = (mat.m8 - mat.m2)*invS;
|
||||
result.z = (mat.m1 - mat.m4)*invS;
|
||||
}
|
||||
float s = sqrtf(1.0f + mat.m0 - mat.m5 - mat.m10)*2;
|
||||
|
||||
result.x = 0.25f*s;
|
||||
result.y = (mat.m4 + mat.m1)/s;
|
||||
result.z = (mat.m2 + mat.m8)/s;
|
||||
result.w = (mat.m9 - mat.m6)/s;
|
||||
}
|
||||
else if (mat.m5 > mat.m10)
|
||||
{
|
||||
float s = sqrtf(1.0f + mat.m5 - mat.m0 - mat.m10)*2;
|
||||
result.x = (mat.m4 + mat.m1)/s;
|
||||
result.y = 0.25f*s;
|
||||
result.z = (mat.m9 + mat.m6)/s;
|
||||
result.w = (mat.m2 - mat.m8)/s;
|
||||
}
|
||||
else
|
||||
{
|
||||
float m00 = mat.m0, m11 = mat.m5, m22 = mat.m10;
|
||||
|
||||
if (m00 > m11 && m00 > m22)
|
||||
{
|
||||
float s = (float)sqrt(1.0f + m00 - m11 - m22)*2.0f;
|
||||
float invS = 1.0f/s;
|
||||
|
||||
result.w = (mat.m6 - mat.m9)*invS;
|
||||
result.x = s*0.25f;
|
||||
result.y = (mat.m4 + mat.m1)*invS;
|
||||
result.z = (mat.m8 + mat.m2)*invS;
|
||||
}
|
||||
else if (m11 > m22)
|
||||
{
|
||||
float s = sqrtf(1.0f + m11 - m00 - m22)*2.0f;
|
||||
float invS = 1.0f/s;
|
||||
|
||||
result.w = (mat.m8 - mat.m2)*invS;
|
||||
result.x = (mat.m4 + mat.m1)*invS;
|
||||
result.y = s*0.25f;
|
||||
result.z = (mat.m9 + mat.m6)*invS;
|
||||
}
|
||||
else
|
||||
{
|
||||
float s = sqrtf(1.0f + m22 - m00 - m11)*2.0f;
|
||||
float invS = 1.0f/s;
|
||||
|
||||
result.w = (mat.m1 - mat.m4)*invS;
|
||||
result.x = (mat.m8 + mat.m2)*invS;
|
||||
result.y = (mat.m9 + mat.m6)*invS;
|
||||
result.z = s*0.25f;
|
||||
}
|
||||
float s = sqrtf(1.0f + mat.m10 - mat.m0 - mat.m5)*2;
|
||||
result.x = (mat.m2 + mat.m8)/s;
|
||||
result.y = (mat.m9 + mat.m6)/s;
|
||||
result.z = 0.25f*s;
|
||||
result.w = (mat.m4 - mat.m1)/s;
|
||||
}
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns a matrix for a given quaternion
|
||||
RMDEF Matrix QuaternionToMatrix(Quaternion q)
|
||||
{
|
||||
Matrix result = { 0 };
|
||||
Matrix result = MatrixIdentity();
|
||||
|
||||
float a2 = 2*(q.x*q.x), b2=2*(q.y*q.y), c2=2*(q.z*q.z); //, d2=2*(q.w*q.w);
|
||||
|
||||
float ab = 2*(q.x*q.y), ac=2*(q.x*q.z), bc=2*(q.y*q.z);
|
||||
float ad = 2*(q.x*q.w), bd=2*(q.y*q.w), cd=2*(q.z*q.w);
|
||||
|
||||
float x = q.x, y = q.y, z = q.z, w = q.w;
|
||||
|
||||
float x2 = x + x;
|
||||
float y2 = y + y;
|
||||
float z2 = z + z;
|
||||
|
||||
float length = QuaternionLength(q);
|
||||
float lengthSquared = length*length;
|
||||
|
||||
float xx = x*x2/lengthSquared;
|
||||
float xy = x*y2/lengthSquared;
|
||||
float xz = x*z2/lengthSquared;
|
||||
|
||||
float yy = y*y2/lengthSquared;
|
||||
float yz = y*z2/lengthSquared;
|
||||
float zz = z*z2/lengthSquared;
|
||||
|
||||
float wx = w*x2/lengthSquared;
|
||||
float wy = w*y2/lengthSquared;
|
||||
float wz = w*z2/lengthSquared;
|
||||
|
||||
result.m0 = 1.0f - (yy + zz);
|
||||
result.m1 = xy - wz;
|
||||
result.m2 = xz + wy;
|
||||
result.m3 = 0.0f;
|
||||
result.m4 = xy + wz;
|
||||
result.m5 = 1.0f - (xx + zz);
|
||||
result.m6 = yz - wx;
|
||||
result.m7 = 0.0f;
|
||||
result.m8 = xz - wy;
|
||||
result.m9 = yz + wx;
|
||||
result.m10 = 1.0f - (xx + yy);
|
||||
result.m11 = 0.0f;
|
||||
result.m12 = 0.0f;
|
||||
result.m13 = 0.0f;
|
||||
result.m14 = 0.0f;
|
||||
result.m15 = 1.0f;
|
||||
result.m0 = 1 - b2 - c2;
|
||||
result.m1 = ab - cd;
|
||||
result.m2 = ac + bd;
|
||||
|
||||
result.m4 = ab + cd;
|
||||
result.m5 = 1 - a2 - c2;
|
||||
result.m6 = bc - ad;
|
||||
|
||||
result.m8 = ac - bd;
|
||||
result.m9 = bc + ad;
|
||||
result.m10 = 1 - a2 - b2;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -1399,4 +1477,27 @@ RMDEF Quaternion QuaternionTransform(Quaternion q, Matrix mat)
|
|||
return result;
|
||||
}
|
||||
|
||||
// Projects a Vector3 from screen space into object space
|
||||
RMDEF Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view)
|
||||
{
|
||||
Vector3 result = { 0.0f, 0.0f, 0.0f };
|
||||
|
||||
// Calculate unproject matrix (multiply view patrix by projection matrix) and invert it
|
||||
Matrix matViewProj = MatrixMultiply(view, projection);
|
||||
matViewProj = MatrixInvert(matViewProj);
|
||||
|
||||
// Create quaternion from source point
|
||||
Quaternion quat = { source.x, source.y, source.z, 1.0f };
|
||||
|
||||
// Multiply quat point by unproject matrix
|
||||
quat = QuaternionTransform(quat, matViewProj);
|
||||
|
||||
// Normalized world points in vectors
|
||||
result.x = quat.x/quat.w;
|
||||
result.y = quat.y/quat.w;
|
||||
result.z = quat.z/quat.w;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif // RAYMATH_H
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue