#ifndef RAYMATH_H

#define RAYMATH_H

#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE)

#error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory"

#if defined(RAYMATH_IMPLEMENTATION)

#if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)

#define RMAPI __declspec(dllexport) extern inline // Building raylib as a Win32 shared library (.dll)

#elif defined(BUILD_LIBTYPE_SHARED)

#define RMAPI __attribute__((visibility("default"))) // Building raylib as a Unix shared library (.so/.dylib)

#elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)

#define RMAPI __declspec(dllimport) // Using raylib as a Win32 shared library (.dll)

#else

#define RMAPI extern inline // Provide external definition

#endif

#elif defined(RAYMATH_STATIC_INLINE)

#define RMAPI static inline // Functions may be inlined, no external out-of-line definition

#if defined(__TINYC__)

#define RMAPI static inline // plain inline not supported by tinycc (See issue #435)

#else

#define RMAPI inline // Functions may be inlined or external definition used

#endif

#ifndef PI

#define PI 3.14159265358979323846f

#ifndef EPSILON

#define EPSILON 0.000001f

#ifndef DEG2RAD

#define DEG2RAD (PI/180.0f)

#ifndef RAD2DEG

#define RAD2DEG (180.0f/PI)

#ifndef MatrixToFloat

#define MatrixToFloat(mat) (MatrixToFloatV(mat).v)

#ifndef Vector3ToFloat

#define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v)

#if !defined(RL_VECTOR2_TYPE)

typedef struct Vector2 {

float x;

float y;

} Vector2;

#define RL_VECTOR2_TYPE

#if !defined(RL_VECTOR3_TYPE)

typedef struct Vector3 {

} Vector3;

#define RL_VECTOR3_TYPE

#if !defined(RL_VECTOR4_TYPE)

typedef struct Vector4 {

} Vector4;

#define RL_VECTOR4_TYPE

#if !defined(RL_QUATERNION_TYPE)

typedef Vector4 Quaternion;

#define RL_QUATERNION_TYPE

#if !defined(RL_MATRIX_TYPE)

typedef struct Matrix {

} Matrix;

#define RL_MATRIX_TYPE

#if !defined(RL_FLOAT3_TYPE)

typedef struct float3 {

float v[3];

} float3;

#define RL_FLOAT3_TYPE

#if !defined(RL_FLOAT16_TYPE)

typedef struct float16 {

float v[16];

} float16;

#define RL_FLOAT16_TYPE

#include <math.h> // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabsf()

#if RAYMATH_USE_SIMD_INTRINSICS

// SIMD is used on the most costly raymath function MatrixMultiply()

// NOTE: Only SSE intrinsics support implemented

// TODO: Consider support for other SIMD instrinsics:

// - SSEx, AVX, AVX2, FMA, NEON, RVV

/*

#if defined(__SSE__) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP >= 1))

#include <xmmintrin.h>

#define RAYMATH_SSE_ENABLED

#endif

RMAPI float Clamp(float value, float min, float max)

{

float result = (value < min)? min : value;

if (result > max) result = max;

return result;

}

RMAPI float Lerp(float start, float end, float amount)

{

float result = start + amount*(end - start);

return result;

}

RMAPI float Normalize(float value, float start, float end)

{

float result = (value - start)/(end - start);

return result;

}

RMAPI float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd)

{

float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart;

return result;

}

RMAPI float Wrap(float value, float min, float max)

{

float result = value - (max - min)*floorf((value - min)/(max - min));

return result;

}

RMAPI int FloatEquals(float x, float y)

{

#if !defined(EPSILON)

#define EPSILON 0.000001f

int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y))));

return result;

}

RMAPI Vector2 Vector2Zero(void)

{

Vector2 result = { 0.0f, 0.0f };

return result;

}

RMAPI Vector2 Vector2One(void)

{

Vector2 result = { 1.0f, 1.0f };

return result;

}

RMAPI Vector2 Vector2Add(Vector2 v1, Vector2 v2)

{

Vector2 result = { v1.x + v2.x, v1.y + v2.y };

return result;

}

RMAPI Vector2 Vector2AddValue(Vector2 v, float add)

{

Vector2 result = { v.x + add, v.y + add };

return result;

}

RMAPI Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)

{

Vector2 result = { v1.x - v2.x, v1.y - v2.y };

return result;

}

RMAPI Vector2 Vector2SubtractValue(Vector2 v, float sub)

{

Vector2 result = { v.x - sub, v.y - sub };

return result;

}

RMAPI float Vector2Length(Vector2 v)

{

float result = sqrtf((v.x*v.x) + (v.y*v.y));

return result;

}

RMAPI float Vector2LengthSqr(Vector2 v)

{

float result = (v.x*v.x) + (v.y*v.y);

return result;

}

RMAPI float Vector2DotProduct(Vector2 v1, Vector2 v2)

{

float result = (v1.x*v2.x + v1.y*v2.y);

return result;

}

RMAPI float Vector2CrossProduct(Vector2 v1, Vector2 v2)

{

float result = (v1.x*v2.y - v1.y*v2.x);

return result;

}

RMAPI float Vector2Distance(Vector2 v1, Vector2 v2)

{

float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));

return result;

}

RMAPI float Vector2DistanceSqr(Vector2 v1, Vector2 v2)

{

float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));

return result;

}

RMAPI float Vector2Angle(Vector2 v1, Vector2 v2)

{

float result = 0.0f;

float dot = v1.x*v2.x + v1.y*v2.y;

float det = v1.x*v2.y - v1.y*v2.x;

result = atan2f(det, dot);

return result;

}

RMAPI float Vector2LineAngle(Vector2 start, Vector2 end)

{

float result = 0.0f;

// TODO(10/9/2023): Currently angles move clockwise, determine if this is wanted behavior

result = -atan2f(end.y - start.y, end.x - start.x);

return result;

}

RMAPI Vector2 Vector2Scale(Vector2 v, float scale)

{

Vector2 result = { v.x*scale, v.y*scale };

return result;

}

RMAPI Vector2 Vector2Multiply(Vector2 v1, Vector2 v2)

{

Vector2 result = { v1.x*v2.x, v1.y*v2.y };

return result;

}

RMAPI Vector2 Vector2Negate(Vector2 v)

{

Vector2 result = { -v.x, -v.y };

return result;

}

RMAPI Vector2 Vector2Divide(Vector2 v1, Vector2 v2)

{

Vector2 result = { v1.x/v2.x, v1.y/v2.y };

return result;

}

RMAPI Vector2 Vector2Normalize(Vector2 v)

{

Vector2 result = { 0 };

float length = sqrtf((v.x*v.x) + (v.y*v.y));

if (length > 0)

{

float ilength = 1.0f/length;

result.x = v.x*ilength;

result.y = v.y*ilength;

}

return result;

}

RMAPI Vector2 Vector2Transform(Vector2 v, Matrix mat)

{

Vector2 result = { 0 };

float x = v.x;

float y = v.y;

float z = 0;

result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;

result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;

return result;

}

RMAPI Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount)

{

Vector2 result = { 0 };

result.x = v1.x + amount*(v2.x - v1.x);

result.y = v1.y + amount*(v2.y - v1.y);

return result;

}

RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal)

{

Vector2 result = { 0 };

float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product

result.x = v.x - (2.0f*normal.x)*dotProduct;

result.y = v.y - (2.0f*normal.y)*dotProduct;

return result;

}

RMAPI Vector2 Vector2Min(Vector2 v1, Vector2 v2)

{

Vector2 result = { 0 };

result.x = fminf(v1.x, v2.x);

result.y = fminf(v1.y, v2.y);

return result;

}

RMAPI Vector2 Vector2Max(Vector2 v1, Vector2 v2)

{

Vector2 result = { 0 };

result.x = fmaxf(v1.x, v2.x);

result.y = fmaxf(v1.y, v2.y);

return result;

}

RMAPI Vector2 Vector2Rotate(Vector2 v, float angle)

{

Vector2 result = { 0 };

float cosres = cosf(angle);

float sinres = sinf(angle);

result.x = v.x*cosres - v.y*sinres;

result.y = v.x*sinres + v.y*cosres;

return result;

}

RMAPI 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))) return target;

float dist = sqrtf(value);

result.x = v.x + dx/dist*maxDistance;

result.y = v.y + dy/dist*maxDistance;

return result;

}

RMAPI Vector2 Vector2Invert(Vector2 v)

{

Vector2 result = { 1.0f/v.x, 1.0f/v.y };

return result;

}

RMAPI Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max)

{

Vector2 result = { 0 };

result.x = fminf(max.x, fmaxf(min.x, v.x));

result.y = fminf(max.y, fmaxf(min.y, v.y));

return result;

}

RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max)

{

Vector2 result = v;

float length = (v.x*v.x) + (v.y*v.y);

if (length > 0.0f)

{

length = sqrtf(length);

float scale = 1; // By default, 1 as the neutral element

if (length < min) scale = min/length;

else if (length > max) scale = max/length;

result.x = v.x*scale;

result.y = v.y*scale;

}

return result;

}

RMAPI int Vector2Equals(Vector2 p, Vector2 q)

{

#if !defined(EPSILON)

#define EPSILON 0.000001f

int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) &&

((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y)))));

return result;

}

RMAPI Vector2 Vector2Refract(Vector2 v, Vector2 n, float r)

{

Vector2 result = { 0 };

float dot = v.x*n.x + v.y*n.y;

float d = 1.0f - r*r*(1.0f - dot*dot);

if (d >= 0.0f)

{

d = sqrtf(d);

v.x = r*v.x - (r*dot + d)*n.x;

v.y = r*v.y - (r*dot + d)*n.y;

result = v;

}

return result;

}

RMAPI Vector3 Vector3Zero(void)

{

Vector3 result = { 0.0f, 0.0f, 0.0f };

return result;

}

RMAPI Vector3 Vector3One(void)

{

Vector3 result = { 1.0f, 1.0f, 1.0f };

return result;

}

RMAPI Vector3 Vector3Add(Vector3 v1, Vector3 v2)

{

Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };

return result;

}

RMAPI Vector3 Vector3AddValue(Vector3 v, float add)

{

Vector3 result = { v.x + add, v.y + add, v.z + add };

return result;

}

RMAPI Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)

{

Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };

return result;

}

RMAPI Vector3 Vector3SubtractValue(Vector3 v, float sub)

{

Vector3 result = { v.x - sub, v.y - sub, v.z - sub };

return result;

}

RMAPI Vector3 Vector3Scale(Vector3 v, float scalar)

{

Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar };

return result;

}

RMAPI Vector3 Vector3Multiply(Vector3 v1, Vector3 v2)

{

Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z };

return result;

}

RMAPI Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2)

{

Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x };

return result;

}

RMAPI Vector3 Vector3Perpendicular(Vector3 v)

{

Vector3 result = { 0 };

float min = fabsf(v.x);

Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};

if (fabsf(v.y) < min)

{

min = fabsf(v.y);

Vector3 tmp = {0.0f, 1.0f, 0.0f};

cardinalAxis = tmp;

}

if (fabsf(v.z) < min)

{

Vector3 tmp = {0.0f, 0.0f, 1.0f};

cardinalAxis = tmp;

}

// Cross product between vectors

result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y;

result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z;

result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x;

return result;

}

RMAPI float Vector3Length(const Vector3 v)

{

float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);

return result;

}

RMAPI float Vector3LengthSqr(const Vector3 v)

{

float result = v.x*v.x + v.y*v.y + v.z*v.z;

return result;

}

RMAPI float Vector3DotProduct(Vector3 v1, Vector3 v2)

{

float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);

return result;

}

RMAPI float Vector3Distance(Vector3 v1, Vector3 v2)

{

float result = 0.0f;

float dx = v2.x - v1.x;

float dy = v2.y - v1.y;

float dz = v2.z - v1.z;

result = sqrtf(dx*dx + dy*dy + dz*dz);

return result;

}

RMAPI float Vector3DistanceSqr(Vector3 v1, Vector3 v2)

{

float result = 0.0f;

float dx = v2.x - v1.x;

float dy = v2.y - v1.y;

float dz = v2.z - v1.z;

result = dx*dx + dy*dy + dz*dz;

return result;

}

RMAPI float Vector3Angle(Vector3 v1, Vector3 v2)

{

float result = 0.0f;

Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x };

float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z);

float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);

result = atan2f(len, dot);

return result;

}

RMAPI Vector3 Vector3Negate(Vector3 v)

{

Vector3 result = { -v.x, -v.y, -v.z };

return result;

}

RMAPI Vector3 Vector3Divide(Vector3 v1, Vector3 v2)

{

Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z };

return result;

}

RMAPI Vector3 Vector3Normalize(Vector3 v)

{

Vector3 result = v;

float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);

if (length != 0.0f)

{

float ilength = 1.0f/length;

result.x *= ilength;

result.y *= ilength;

result.z *= ilength;

}

return result;

}

RMAPI Vector3 Vector3Project(Vector3 v1, Vector3 v2)

{

Vector3 result = { 0 };

float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);

float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z);

float mag = v1dv2/v2dv2;

result.x = v2.x*mag;

result.y = v2.y*mag;

result.z = v2.z*mag;

return result;

}

RMAPI Vector3 Vector3Reject(Vector3 v1, Vector3 v2)

{

Vector3 result = { 0 };

float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);

float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z);

float mag = v1dv2/v2dv2;

result.x = v1.x - (v2.x*mag);

result.y = v1.y - (v2.y*mag);

result.z = v1.z - (v2.z*mag);

return result;

}

RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2)

{

float length = 0.0f;

float ilength = 0.0f;

// Vector3Normalize(*v1);

Vector3 v = *v1;

length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);

if (length == 0.0f) length = 1.0f;

ilength = 1.0f/length;

v1->x *= ilength;

v1->y *= ilength;

v1->z *= ilength;

// Vector3CrossProduct(*v1, *v2)

Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x };

// Vector3Normalize(vn1);

v = vn1;

length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);

if (length == 0.0f) length = 1.0f;

ilength = 1.0f/length;

vn1.x *= ilength;

vn1.y *= ilength;

vn1.z *= ilength;

// Vector3CrossProduct(vn1, *v1)

Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x };

*v2 = vn2;

}

RMAPI Vector3 Vector3Transform(Vector3 v, Matrix mat)

{

Vector3 result = { 0 };

float x = v.x;

float y = v.y;

float z = v.z;

result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;

result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;

result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;

return result;

}

RMAPI Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q)

{

Vector3 result = { 0 };

result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y);

result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z);

result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z);

return result;

}

RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle)

{

// Using Euler-Rodrigues Formula

// Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula

Vector3 result = v;

// Vector3Normalize(axis);

float length = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z);

if (length == 0.0f) length = 1.0f;

float ilength = 1.0f/length;

axis.x *= ilength;

axis.y *= ilength;

axis.z *= ilength;

angle /= 2.0f;

float a = sinf(angle);

float b = axis.x*a;

float c = axis.y*a;

float d = axis.z*a;

a = cosf(angle);

Vector3 w = { b, c, d };

// Vector3CrossProduct(w, v)

Vector3 wv = { w.y*v.z - w.z*v.y, w.z*v.x - w.x*v.z, w.x*v.y - w.y*v.x };

// Vector3CrossProduct(w, wv)

Vector3 wwv = { w.y*wv.z - w.z*wv.y, w.z*wv.x - w.x*wv.z, w.x*wv.y - w.y*wv.x };

// Vector3Scale(wv, 2*a)

a *= 2;

wv.x *= a;

wv.y *= a;

wv.z *= a;

// Vector3Scale(wwv, 2)

wwv.x *= 2;

wwv.y *= 2;

wwv.z *= 2;

result.x += wv.x;

result.y += wv.y;

result.z += wv.z;

result.x += wwv.x;

result.y += wwv.y;

result.z += wwv.z;

return result;

}

RMAPI Vector3 Vector3MoveTowards(Vector3 v, Vector3 target, float maxDistance)

{

Vector3 result = { 0 };

float dx = target.x - v.x;

float dy = target.y - v.y;

float dz = target.z - v.z;

float value = (dx*dx) + (dy*dy) + (dz*dz);

if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target;

float dist = sqrtf(value);

result.x = v.x + dx/dist*maxDistance;

result.y = v.y + dy/dist*maxDistance;

result.z = v.z + dz/dist*maxDistance;

return result;

}

RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)

{

Vector3 result = { 0 };

result.x = v1.x + amount*(v2.x - v1.x);

result.y = v1.y + amount*(v2.y - v1.y);

result.z = v1.z + amount*(v2.z - v1.z);

return result;