/*

HandmadeMath.h v1.9.0

This is a single header file with a bunch of useful functions for game and

graphics math operations.

=============================================================================

You MUST

#define HANDMADE_MATH_IMPLEMENTATION

in EXACTLY one C or C++ file that includes this header, BEFORE the

include, like this:

#define HANDMADE_MATH_IMPLEMENTATION

#include "HandmadeMath.h"

All other files should just #include "HandmadeMath.h" without the #define.

=============================================================================

To disable SSE intrinsics, you MUST

#define HANDMADE_MATH_NO_SSE

in EXACTLY one C or C++ file that includes this header, BEFORE the

include, like this:

#define HANDMADE_MATH_IMPLEMENTATION

#define HANDMADE_MATH_NO_SSE

#include "HandmadeMath.h"

=============================================================================

To use HandmadeMath without the CRT, you MUST

#define HMM_SINF MySinF

#define HMM_COSF MyCosF

#define HMM_TANF MyTanF

#define HMM_SQRTF MySqrtF

#define HMM_EXPF MyExpF

#define HMM_LOGF MyLogF

#define HMM_ACOSF MyACosF

#define HMM_ATANF MyATanF

#define HMM_ATAN2F MYATan2F

Provide your own implementations of SinF, CosF, TanF, ACosF, ATanF, ATan2F,

ExpF, and LogF in EXACTLY one C or C++ file that includes this header,

BEFORE the include, like this:

#define HMM_SINF MySinF

#define HMM_COSF MyCosF

#define HMM_TANF MyTanF

#define HMM_SQRTF MySqrtF

#define HMM_EXPF MyExpF

#define HMM_LOGF MyLogF

#define HMM_ACOSF MyACosF

#define HMM_ATANF MyATanF

#define HMM_ATAN2F MyATan2F

#define HANDMADE_MATH_IMPLEMENTATION

#include "HandmadeMath.h"

If you do not define all of these, HandmadeMath.h will use the

versions of these functions that are provided by the CRT.

=============================================================================

LICENSE

This software is in the public domain. Where that dedication is not

recognized, you are granted a perpetual, irrevocable license to copy,

distribute, and modify this file as you see fit.

CREDITS

Written by Zakary Strange (zak@strangedev.net && @strangezak)

Functionality:

Matt Mascarenhas (@miblo_)

Aleph

FieryDrake (@fierydrake)

Gingerbill (@TheGingerBill)

Ben Visness (@bvisness)

Trinton Bullard (@Peliex_Dev)

@AntonDan

Fixes:

Jeroen van Rijn (@J_vanRijn)

Kiljacken (@Kiljacken)

Insofaras (@insofaras)

Daniel Gibson (@DanielGibson)

*/

/* let's figure out if SSE is really available (unless disabled anyway)

(it isn't on non-x86/x86_64 platforms or even x86 without explicit SSE support)

=> only use "#ifdef HANDMADE_MATH__USE_SSE" to check for SSE support below this block! */

#ifndef HANDMADE_MATH_NO_SSE

# ifdef _MSC_VER

/* MSVC supports SSE in amd64 mode or _M_IX86_FP >= 1 (2 means SSE2) */

# if defined(_M_AMD64) || ( defined(_M_IX86_FP) && _M_IX86_FP >= 1 )

# define HANDMADE_MATH__USE_SSE 1

# endif

# else /* not MSVC, probably GCC, clang, icc or something that doesn't support SSE anyway */

# ifdef __SSE__ /* they #define __SSE__ if it's supported */

# define HANDMADE_MATH__USE_SSE 1

# endif /* __SSE__ */

# endif /* not _MSC_VER */

#endif /* #ifndef HANDMADE_MATH_NO_SSE */

#include <stdint.h> // This is for types

#ifdef HANDMADE_MATH__USE_SSE

#include <xmmintrin.h>

#endif

#ifndef HANDMADE_MATH_H

#define HANDMADE_MATH_H

#ifdef _MSC_VER

#pragma warning(disable:4201)

#endif

#ifdef __clang__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wgnu-anonymous-struct"

#endif

#ifdef __cplusplus

extern "C"

{

#endif

#define HMM_INLINE static inline

#define HMM_EXTERN extern

#if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \

!defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \

!defined(HMM_ACOSF) || !defined(HMM_ATANF)|| !defined(HMM_ATAN2F)

#include <math.h>

#endif

#ifndef HMM_SINF

#define HMM_SINF sinf

#endif

#ifndef HMM_COSF

#define HMM_COSF cosf

#endif

#ifndef HMM_TANF

#define HMM_TANF tanf

#endif

#ifndef HMM_SQRTF

#define HMM_SQRTF sqrtf

#endif

#ifndef HMM_EXPF

#define HMM_EXPF expf

#endif

#ifndef HMM_LOGF

#define HMM_LOGF logf

#endif

#ifndef HMM_ACOSF

#define HMM_ACOSF acosf

#endif

#ifndef HMM_ATANF

#define HMM_ATANF atanf

#endif

#ifndef HMM_ATAN2F

#define HMM_ATAN2F atan2f

#endif

#define HMM_PI32 3.14159265359f

#define HMM_PI 3.14159265358979323846

#define HMM_MIN(a, b) (a) > (b) ? (b) : (a)

#define HMM_MAX(a, b) (a) < (b) ? (b) : (a)

#define HMM_ABS(a) ((a) > 0 ? (a) : -(a))

#define HMM_MOD(a, m) ((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m))

#define HMM_SQUARE(x) ((x) * (x))

typedef union hmm_vec2

{

struct

{

float X, Y;

};

struct

{

float U, V;

};

struct

{

float Left, Right;

};

struct

{

float Width, Height;

};

float Elements[2];

#ifdef __cplusplus

inline float &operator[](const int &Index)

{

return Elements[Index];

}

#endif

} hmm_vec2;

typedef union hmm_vec3

{

struct

{

float X, Y, Z;

};

struct

{

float U, V, W;

};

struct

{

float R, G, B;

};

struct

{

hmm_vec2 XY;

float Ignored0_;

};

struct

{

float Ignored1_;

hmm_vec2 YZ;

};

struct

{

hmm_vec2 UV;

float Ignored2_;

};

struct

{

float Ignored3_;

hmm_vec2 VW;

};

float Elements[3];

#ifdef __cplusplus

inline float &operator[](const int &Index)

{

return Elements[Index];

}

#endif

} hmm_vec3;

typedef union hmm_vec4

{

struct

{

union

{

hmm_vec3 XYZ;

struct

{

float X, Y, Z;

};

};

float W;

};

struct

{

union

{

hmm_vec3 RGB;

struct

{

float R, G, B;

};

};

float A;

};

struct

{

hmm_vec2 XY;

float Ignored0_;

float Ignored1_;

};

struct

{

float Ignored2_;

hmm_vec2 YZ;

float Ignored3_;

};

struct

{

float Ignored4_;

float Ignored5_;

hmm_vec2 ZW;

};

float Elements[4];

#ifdef HANDMADE_MATH__USE_SSE

__m128 InternalElementsSSE;

#endif

#ifdef __cplusplus

inline float &operator[](const int &Index)

{

return Elements[Index];

}

#endif

} hmm_vec4;

typedef union hmm_mat4

{

float Elements[4][4];

#ifdef HANDMADE_MATH__USE_SSE

__m128 Columns[4];

// DEPRECATED. Our matrices are column-major, so this was named

// incorrectly. Use Columns instead.

__m128 Rows[4];

#endif

#ifdef __cplusplus

inline hmm_vec4 operator[](const int &Index)

{

float* col = Elements[Index];

hmm_vec4 result;

result.Elements[0] = col[0];

result.Elements[1] = col[1];

result.Elements[2] = col[2];

result.Elements[3] = col[3];

return result;

}

#endif

} hmm_mat4;

typedef union hmm_quaternion

{

struct

{

union

{

hmm_vec3 XYZ;

struct

{

float X, Y, Z;

};

};

float W;

};

float Elements[4];

#ifdef HANDMADE_MATH__USE_SSE

__m128 InternalElementsSSE;

#endif

} hmm_quaternion;

typedef int32_t hmm_bool;

typedef hmm_vec2 hmm_v2;

typedef hmm_vec3 hmm_v3;

typedef hmm_vec4 hmm_v4;

typedef hmm_mat4 hmm_m4;

/*

* Floating-point math functions

*/

HMM_INLINE float HMM_SinF(float Radians)

{

float Result = HMM_SINF(Radians);

return (Result);

}

HMM_INLINE float HMM_CosF(float Radians)

{

float Result = HMM_COSF(Radians);

return (Result);

}

HMM_INLINE float HMM_TanF(float Radians)

{

float Result = HMM_TANF(Radians);

return (Result);

}

HMM_INLINE float HMM_ACosF(float Radians)

{

float Result = HMM_ACOSF(Radians);

return (Result);

}

HMM_INLINE float HMM_ATanF(float Radians)

{

float Result = HMM_ATANF(Radians);

return (Result);

}

HMM_INLINE float HMM_ATan2F(float Left, float Right)

{

float Result = HMM_ATAN2F(Left, Right);

return (Result);

}

HMM_INLINE float HMM_ExpF(float Float)

{

float Result = HMM_EXPF(Float);

return (Result);

}

HMM_INLINE float HMM_LogF(float Float)

{

float Result = HMM_LOGF(Float);

return (Result);

}

HMM_INLINE float HMM_SquareRootF(float Float)

{

float Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 In = _mm_set_ss(Float);

__m128 Out = _mm_sqrt_ss(In);

Result = _mm_cvtss_f32(Out);

#else

Result = HMM_SQRTF(Float);

#endif

return(Result);

}

HMM_INLINE float HMM_RSquareRootF(float Float)

{

float Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 In = _mm_set_ss(Float);

__m128 Out = _mm_rsqrt_ss(In);

Result = _mm_cvtss_f32(Out);

#else

Result = 1.0f/HMM_SquareRootF(Float);

#endif

return(Result);

}

HMM_EXTERN float HMM_Power(float Base, int Exponent);

HMM_INLINE float HMM_PowerF(float Base, float Exponent)

{

float Result = HMM_EXPF(Exponent * HMM_LOGF(Base));

return (Result);

}

/*

* Utility functions

*/

HMM_INLINE float HMM_ToRadians(float Degrees)

{

float Result = Degrees * (HMM_PI32 / 180.0f);

return (Result);

}

HMM_INLINE float HMM_Lerp(float A, float Time, float B)

{

float Result = (1.0f - Time) * A + Time * B;

return (Result);

}

HMM_INLINE float HMM_Clamp(float Min, float Value, float Max)

{

float Result = Value;

if(Result < Min)

{

Result = Min;

}

else if(Result > Max)

{

Result = Max;

}

return (Result);

}

/*

* Vector initialization

*/

HMM_INLINE hmm_vec2 HMM_Vec2(float X, float Y)

{

hmm_vec2 Result;

Result.X = X;

Result.Y = Y;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_Vec2i(int X, int Y)

{

hmm_vec2 Result;

Result.X = (float)X;

Result.Y = (float)Y;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_Vec3(float X, float Y, float Z)

{

hmm_vec3 Result;

Result.X = X;

Result.Y = Y;

Result.Z = Z;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_Vec3i(int X, int Y, int Z)

{

hmm_vec3 Result;

Result.X = (float)X;

Result.Y = (float)Y;

Result.Z = (float)Z;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_Vec4(float X, float Y, float Z, float W)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_setr_ps(X, Y, Z, W);

#else

Result.X = X;

Result.Y = Y;

Result.Z = Z;

Result.W = W;

#endif

return (Result);

}

HMM_INLINE hmm_vec4 HMM_Vec4i(int X, int Y, int Z, int W)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_setr_ps((float)X, (float)Y, (float)Z, (float)W);

#else

Result.X = (float)X;

Result.Y = (float)Y;

Result.Z = (float)Z;

Result.W = (float)W;

#endif

return (Result);

}

HMM_INLINE hmm_vec4 HMM_Vec4v(hmm_vec3 Vector, float W)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_setr_ps(Vector.X, Vector.Y, Vector.Z, W);

#else

Result.XYZ = Vector;

Result.W = W;

#endif

return (Result);

}

/*

* Binary vector operations

*/

HMM_INLINE hmm_vec2 HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X + Right.X;

Result.Y = Left.Y + Right.Y;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X + Right.X;

Result.Y = Left.Y + Right.Y;

Result.Z = Left.Z + Right.Z;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_add_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

#else

Result.X = Left.X + Right.X;

Result.Y = Left.Y + Right.Y;

Result.Z = Left.Z + Right.Z;

Result.W = Left.W + Right.W;

#endif

return (Result);

}

HMM_INLINE hmm_vec2 HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X - Right.X;

Result.Y = Left.Y - Right.Y;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X - Right.X;

Result.Y = Left.Y - Right.Y;

Result.Z = Left.Z - Right.Z;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_sub_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

#else

Result.X = Left.X - Right.X;

Result.Y = Left.Y - Right.Y;

Result.Z = Left.Z - Right.Z;

Result.W = Left.W - Right.W;

#endif

return (Result);

}

HMM_INLINE hmm_vec2 HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X * Right.X;

Result.Y = Left.Y * Right.Y;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_MultiplyVec2f(hmm_vec2 Left, float Right)

{

hmm_vec2 Result;

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X * Right.X;

Result.Y = Left.Y * Right.Y;

Result.Z = Left.Z * Right.Z;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_MultiplyVec3f(hmm_vec3 Left, float Right)

{

hmm_vec3 Result;

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

Result.Z = Left.Z * Right;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

#else

Result.X = Left.X * Right.X;

Result.Y = Left.Y * Right.Y;

Result.Z = Left.Z * Right.Z;

Result.W = Left.W * Right.W;

#endif

return (Result);

}

HMM_INLINE hmm_vec4 HMM_MultiplyVec4f(hmm_vec4 Left, float Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 Scalar = _mm_set1_ps(Right);

Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Scalar);

#else

Result.X = Left.X * Right;

Result.Y = Left.Y * Right;

Result.Z = Left.Z * Right;

Result.W = Left.W * Right;

#endif

return (Result);

}

HMM_INLINE hmm_vec2 HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_vec2 Result;

Result.X = Left.X / Right.X;

Result.Y = Left.Y / Right.Y;

return (Result);

}

HMM_INLINE hmm_vec2 HMM_DivideVec2f(hmm_vec2 Left, float Right)

{

hmm_vec2 Result;

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_vec3 Result;

Result.X = Left.X / Right.X;

Result.Y = Left.Y / Right.Y;

Result.Z = Left.Z / Right.Z;

return (Result);

}

HMM_INLINE hmm_vec3 HMM_DivideVec3f(hmm_vec3 Left, float Right)

{

hmm_vec3 Result;

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

Result.Z = Left.Z / Right;

return (Result);

}

HMM_INLINE hmm_vec4 HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);

#else

Result.X = Left.X / Right.X;

Result.Y = Left.Y / Right.Y;

Result.Z = Left.Z / Right.Z;

Result.W = Left.W / Right.W;

#endif

return (Result);

}

HMM_INLINE hmm_vec4 HMM_DivideVec4f(hmm_vec4 Left, float Right)

{

hmm_vec4 Result;

#ifdef HANDMADE_MATH__USE_SSE

__m128 Scalar = _mm_set1_ps(Right);

Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Scalar);

#else

Result.X = Left.X / Right;

Result.Y = Left.Y / Right;

Result.Z = Left.Z / Right;

Result.W = Left.W / Right;

#endif

return (Result);

}

HMM_INLINE hmm_bool HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right)

{

hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y);

return (Result);

}

HMM_INLINE hmm_bool HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right)

{

hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z);

return (Result);

}

HMM_INLINE hmm_bool HMM_EqualsVec4(hmm_vec4 Left, hmm_vec4 Right)

{

hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W);

return (Result);

}

HMM_INLINE float HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo)

{

float Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y);

return (Result);

}

HMM_INLINE float HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo)

{

float Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z);

return (Result);

}

HMM_INLINE float HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo)

{

float Result;

// NOTE(zak): IN the future if we wanna check what version SSE is support

// we can use _mm_dp_ps (4.3) but for now we will use the old way.

// Or a r = _mm_mul_ps(v1, v2), r = _mm_hadd_ps(r, r), r = _mm_hadd_ps(r, r) for SSE3

#ifdef HANDMADE_MATH__USE_SSE

__m128 SSEResultOne = _mm_mul_ps(VecOne.InternalElementsSSE, VecTwo.InternalElementsSSE);

__m128 SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(2, 3, 0, 1));

SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo);

SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(0, 1, 2, 3));

SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo);

_mm_store_ss(&Result, SSEResultOne);

#else

Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z) + (VecOne.W * VecTwo.W);

#endif

return (Result);

}

HMM_INLINE hmm_vec3 HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo)

{

hmm_vec3 Result;

Result.X = (VecOne.Y * VecTwo.Z) - (VecOne.Z * VecTwo.Y);

Result.Y = (VecOne.Z * VecTwo.X) - (VecOne.X * VecTwo.Z);

Result.Z = (VecOne.X * VecTwo.Y) - (VecOne.Y * VecTwo.X);

return (Result);

}

/*

* Unary vector operations

*/

HMM_INLINE float HMM_LengthSquaredVec2(hmm_vec2 A)

{

float Result = HMM_DotVec2(A, A);

return(Result);

}

HMM_INLINE float HMM_LengthSquaredVec3(hmm_vec3 A)

{

float Result = HMM_DotVec3(A, A);

return (Result);

}

HMM_INLINE float HMM_LengthSquaredVec4(hmm_vec4 A)

{

float Result = HMM_DotVec4(A, A);

return (Result);

}

HMM_INLINE float HMM_LengthVec2(hmm_vec2 A)

{

float Result = HMM_SquareRootF(HMM_LengthSquaredVec2(A));

return (Result);

}

HMM_INLINE float HMM_LengthVec3(hmm_vec3 A)

{

float Result = HMM_SquareRootF(HMM_LengthSquaredVec3(A));

return (Result);

}

HMM_INLINE float HMM_LengthVec4(hmm_vec4 A)

{

float Result = HMM_SquareRootF(HMM_LengthSquaredVec4(A));

return(Result);

}

HMM_INLINE hmm_vec2 HMM_NormalizeVec2(hmm_vec2 A)

{

hmm_vec2 Result = {0};

float VectorLength = HMM_LengthVec2(A);

/* NOTE(kiljacken): We need a zero check to not divide-by-zero */

if (VectorLength != 0.0f)

{

Result.X = A.X * (1.0f / VectorLength);

Result.Y = A.Y * (1.0f / VectorLength);

}

return (Result);

}

HMM_INLINE hmm_vec3 HMM_NormalizeVec3(hmm_vec3 A)

{

hmm_vec3 Result = {0};

float VectorLength = HMM_LengthVec3(A);

/* NOTE(kiljacken): We need a zero check to not divide-by-zero */

if (VectorLength != 0.0f)

{

Result.X = A.X * (1.0f / VectorLength);

Result.Y = A.Y * (1.0f / VectorLength);

Result.Z = A.Z * (1.0f / VectorLength);

}

return (Result);

}

HMM_INLINE hmm_vec4 HMM_NormalizeVec4(hmm_vec4 A)

{