/*
* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Vector and matrix math functions and data types
*
*/
#ifndef __M3G_MATH_H__
#define __M3G_MATH_H__
/*!
* \file
* \brief Vector and matrix math functions and data types
*/
/*----------------------------------------------------------------------
* Internal data types
*--------------------------------------------------------------------*/
/*!
* \internal
* \brief Axis-aligned bounding box
*/
typedef struct
{
M3Gfloat min[3], max[3];
/*
M3Gbyte min[3], minExp;
M3Gbyte max[3], maxExp;
*/
} AABB;
/*----------------------------------------------------------------------
* Global constants
*--------------------------------------------------------------------*/
/*!
* \internal
* \brief Maximum positive float value
*/
#define M3G_MAX_POSITIVE_FLOAT (3.402e+38f)
/*!
* \internal
* \brief Minimum negative float value
*/
#define M3G_MIN_NEGATIVE_FLOAT (-3.402e+38f)
/*!
* \internal
* \brief Degrees to radians multiplier
*/
#define M3G_DEG2RAD (0.017453292519943295769236907684886f)
#define EPSILON (1.0e-5f)
#define EPSILON_EXP (-17)
#define RAD2DEG (57.295779513082320876798154814105f)
#define PI (3.14159265359f)
#define HALF_PI (PI / 2.0f)
#define ONE_AND_HALF_PI (PI + HALF_PI)
#define TWO_PI (2.f * PI)
/*! \internal \brief Extracts the bit pattern of a floating point number */
#define FLOAT_AS_UINT(x) (*(M3Guint*)&(x))
/*! \internal \brief Returns an integer bit pattern as float */
#define INT_AS_FLOAT(x) (*(M3Gfloat*)&(x))
/* IEEE floating point format */
#define MANTISSA_MASK 0x007FFFFFu
#define EXP_MASK 0x7F800000u
#define SIGN_MASK 0x80000000u
#define M3G_FLOAT_ONE 0x3F800000
/*! \internal \brief Extracts the exponent of a floating point number */
#define EXPONENT(x) (((M3Gint)(FLOAT_AS_UINT(x) & EXP_MASK) >> 23) - 127)
/*! \internal \brief Extracts the mantissa of a floating point number */
#define MANTISSA(x) (FLOAT_AS_UINT(x) & MANTISSA_MASK)
/*! \internal \brief Extracts the sign of a floating point number */
#define SIGN(x) (1 - ((FLOAT_AS_UINT(x) & SIGN_MASK) >> 30))
/*! \internal \brief Extracts just the sign bit of a floating point number */
#define SIGN_BIT(x) (FLOAT_AS_UINT(x) >> 31)
/* Useful constants */
#define LEADING_ONE (1 << 23)
/*! \internal \brief Checks the sign of a floating point number */
#define IS_NEGATIVE(x) ((FLOAT_AS_UINT(x) & SIGN_MASK) != 0)
/* Floating-point constant identification macros */
# define IS_ZERO(x) ((FLOAT_AS_UINT(x) & ~SIGN_MASK) <= 0x01000000)
# define IS_ONE(x) (((x) > 1.0f - EPSILON) && ((x) < 1.0f + EPSILON))
# define IS_MINUS_ONE(x) (((x) > -1.0f - EPSILON) && ((x) < -1.0f + EPSILON))
/* Elementary vectors */
static const Vec4 Vec4_X_AXIS = {1, 0, 0, 0};
static const Vec4 Vec4_Y_AXIS = {0, 1, 0, 0};
static const Vec4 Vec4_Z_AXIS = {0, 0, 1, 0};
static const Vec4 Vec4_ORIGIN = {0, 0, 0, 1};
/*----------------------------------------------------------------------
* Elementary floating-point math
*--------------------------------------------------------------------*/
#if defined(M3G_SOFT_FLOAT)
static M3Gfloat m3gAdd(const M3Gfloat a, const M3Gfloat b);
static M3Gfloat m3gMul(const M3Gfloat a, const M3Gfloat b);
static M3Gfloat m3gRcpSqrt(const M3Gfloat x);
static M3Gfloat m3gSqrt(const M3Gfloat x);
static M3G_INLINE M3Gfloat m3gAbs(const M3Gfloat a)
{
M3Guint temp = FLOAT_AS_UINT(a) & ~SIGN_MASK;
return INT_AS_FLOAT(temp);
}
static M3G_INLINE M3Gfloat m3gDiv(const M3Gfloat a, const M3Gfloat b)
{
return (a / b);
}
static M3G_INLINE M3Gfloat m3gDivif(const M3Gint a, const M3Gint b)
{
return m3gDiv((M3Gfloat) a, (M3Gfloat) b);
}
static M3G_INLINE M3Gfloat m3gMadd(const M3Gfloat a, const M3Gfloat b, const M3Gfloat c)
{
return m3gAdd(m3gMul(a, b), c);
}
static M3G_INLINE M3Gfloat m3gRcp(const M3Gfloat x)
{
return (1.0f / x);
}
static M3G_INLINE M3Gfloat m3gSub(const M3Gfloat a, const M3Gfloat b)
{
M3Guint bNeg = FLOAT_AS_UINT(b) ^ SIGN_MASK;
return m3gAdd(a, INT_AS_FLOAT(bNeg));
}
#else
# include <math.h>
# define m3gAbs(a) ((float)fabs(a))
# define m3gAdd(a, b) ((float)(a) + (float)(b))
# define m3gMadd(a, b, c) ((float)(a) * (float)(b) + (float)(c))
# define m3gMul(a, b) ((float)(a) * (float)(b))
# define m3gDiv(a, b) ((float)(a) / (float)(b))
# define m3gDivif(a, b) ((float)(a) / (float)(b))
# define m3gRcp(x) (1.0f / (float)(x))
# define m3gRcpSqrt(x) (1.0f / (float)sqrt(x))
# define m3gSqrt(x) ((float)sqrt(x))
# define m3gSub(a, b) ((float)(a) - (float)(b))
#endif /* M3G_SOFT_FLOAT */
/*----------------------------------------------------------------------
* Trigonometric and exp functions
*--------------------------------------------------------------------*/
#if defined(M3G_SOFT_FLOAT)
static M3Gfloat m3gArcCos(const M3Gfloat x);
static M3Gfloat m3gArcTan(const M3Gfloat y, const M3Gfloat x);
static M3Gfloat m3gCos(const M3Gfloat x);
static M3Gfloat m3gSin(const M3Gfloat x);
static M3Gfloat m3gTan(const M3Gfloat x);
static M3Gfloat m3gExp(const M3Gfloat a);
#else
# define m3gArcCos(x) ((float)acos(x))
# define m3gArcTan(y, x) ((float)atan2((y), (x)))
# define m3gCos(x) ((float)cos(x))
# define m3gSin(x) ((float)sin(x))
# define m3gTan(x) ((float)tan(x))
# define m3gExp(x) ((float)exp(x))
#endif
/*----------------------------------------------------------------------
* Matrix and quaternion stuff
*--------------------------------------------------------------------*/
static M3Gbool m3gIsWUnity (const Matrix *mtx);
static void m3gExpQuat (Quat *quat, const Vec3 *qExp);
static void m3gLogQuat (Vec3 *qLog, const Quat *quat);
static void m3gLogDiffQuat (Vec3 *logDiff,
const Quat *from, const Quat *to);
static M3Gint m3gGetFixedPoint3x3Basis(const Matrix *mtx, M3Gshort *elem);
static M3Gint m3gGetFixedPointTranslation(const Matrix *mtx, M3Gshort *elem);
/*----------------------------------------------------------------------
* Bounding boxes
*--------------------------------------------------------------------*/
static void m3gFitAABB(AABB *box, const AABB *a, const AABB *b);
static void m3gTransformAABB(AABB *box, const Matrix *mtx);
#if defined(M3G_DEBUG)
static void m3gValidateAABB(const AABB *aabb);
#else
# define m3gValidateAABB(a)
#endif
/*----------------------------------------------------------------------
* Rounding and conversion
*--------------------------------------------------------------------*/
static M3Gint m3gRoundToInt(const M3Gfloat a);
static M3Guint m3gAlpha1f(M3Gfloat a);
/*static M3Guint m3gColor1f(M3Gfloat i);*/
static M3Guint m3gColor3f(M3Gfloat r, M3Gfloat g, M3Gfloat b);
static M3Guint m3gColor4f(M3Gfloat r, M3Gfloat g, M3Gfloat b, M3Gfloat a);
static void m3gFloatColor(M3Gint argb, M3Gfloat intensity, M3Gfloat *rgba);
static M3Gbool m3gIntersectTriangle(const Vec3 *orig, const Vec3 *dir,
const Vec3 *vert0, const Vec3 *vert1, const Vec3 *vert2,
Vec3 *tuv, M3Gint cullMode);
static M3Gbool m3gIntersectBox(const Vec3 *orig, const Vec3 *dir, const AABB *box);
static M3Gbool m3gIntersectRectangle(M3GRectangle *dst, M3GRectangle *r1, M3GRectangle *r2);
/*----------------------------------------------------------------------
* Inline functions
*--------------------------------------------------------------------*/
/*!
* \internal
* \brief Multiplies a floating point number by 0.5.
*
* \param x the number to multiply
* \return 0.5 * \c x
*/
static M3G_INLINE M3Gfloat m3gHalf(M3Gfloat x)
{
M3Guint bits = FLOAT_AS_UINT(x);
M3Guint mask = 0xff;
M3Gint exponent = bits & (mask << 23);
bits ^= exponent;
exponent = exponent - (1 << 23);
if (exponent > 0) bits |= exponent;
return INT_AS_FLOAT(bits);
}
/*!
* \internal
* \brief Multiplies a floating point number by two
*
* This does NOT handle overflows.
*
* \param x the number to multiply
* \return 2 * \c x
*/
static M3G_INLINE M3Gfloat m3gDouble(M3Gfloat x)
{
M3Guint bits = FLOAT_AS_UINT(x) + (1 << 23);
return INT_AS_FLOAT(bits);
}
/*!
* \internal
* \brief Computes the square of a floating point number
*
* \param x the input number
* \return x * x
*/
static M3G_INLINE M3Gfloat m3gSquare(M3Gfloat x)
{
return m3gMul(x, x);
}
/*!
* \internal
* \brief Negates a floating-point value
*/
static M3G_INLINE M3Gfloat m3gNegate(M3Gfloat x)
{
M3Guint ix = FLOAT_AS_UINT(x) ^ SIGN_MASK;
return INT_AS_FLOAT(ix);
}
#endif /*__M3G_MATH_H__*/