Microsoft/xbox-kernel
Microsoft/xbox-kernel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
9eec575c13
xbox-kernel/public/sdk/inc/xgmath.inl

2415 lines
42 KiB
Plaintext
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 1998 - 2001 Microsoft Corporation. All Rights Reserved.
//
// File: xgmath.inl
// Content: XG math inline functions
//
//////////////////////////////////////////////////////////////////////////////
#ifndef __XGMATH_INL__
#define __XGMATH_INL__
#pragma warning(disable:4035)
//===========================================================================
//
// Inline Class Methods
//
//===========================================================================
#ifdef __cplusplus
#include <malloc.h>
//--------------------------
// 2D Vector
//--------------------------
XGINLINE
XGVECTOR2::XGVECTOR2( CONST FLOAT *pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
x = pf[0];
y = pf[1];
}
XGINLINE
XGVECTOR2::XGVECTOR2( FLOAT fx, FLOAT fy )
{
x = fx;
y = fy;
}
// casting
XGINLINE
XGVECTOR2::operator FLOAT* ()
{
return (FLOAT *) &x;
}
XGINLINE
XGVECTOR2::operator CONST FLOAT* () const
{
return (CONST FLOAT *) &x;
}
// assignment operators
XGINLINE XGVECTOR2&
XGVECTOR2::operator += ( CONST XGVECTOR2& v )
{
x += v.x;
y += v.y;
return *this;
}
XGINLINE XGVECTOR2&
XGVECTOR2::operator -= ( CONST XGVECTOR2& v )
{
x -= v.x;
y -= v.y;
return *this;
}
XGINLINE XGVECTOR2&
XGVECTOR2::operator *= ( FLOAT f )
{
x *= f;
y *= f;
return *this;
}
XGINLINE XGVECTOR2&
XGVECTOR2::operator /= ( FLOAT f )
{
FLOAT fInv = 1.0f / f;
x *= fInv;
y *= fInv;
return *this;
}
// unary operators
XGINLINE XGVECTOR2
XGVECTOR2::operator + () const
{
return *this;
}
XGINLINE XGVECTOR2
XGVECTOR2::operator - () const
{
return XGVECTOR2(-x, -y);
}
// binary operators
XGINLINE XGVECTOR2
XGVECTOR2::operator + ( CONST XGVECTOR2& v ) const
{
return XGVECTOR2(x + v.x, y + v.y);
}
XGINLINE XGVECTOR2
XGVECTOR2::operator - ( CONST XGVECTOR2& v ) const
{
return XGVECTOR2(x - v.x, y - v.y);
}
XGINLINE XGVECTOR2
XGVECTOR2::operator * ( FLOAT f ) const
{
return XGVECTOR2(x * f, y * f);
}
XGINLINE XGVECTOR2
XGVECTOR2::operator / ( FLOAT f ) const
{
FLOAT fInv = 1.0f / f;
return XGVECTOR2(x * fInv, y * fInv);
}
XGINLINE XGVECTOR2
operator * ( FLOAT f, CONST XGVECTOR2& v )
{
return XGVECTOR2(f * v.x, f * v.y);
}
XGINLINE BOOL
XGVECTOR2::operator == ( CONST XGVECTOR2& v ) const
{
return x == v.x && y == v.y;
}
XGINLINE BOOL
XGVECTOR2::operator != ( CONST XGVECTOR2& v ) const
{
return x != v.x || y != v.y;
}
//--------------------------
// 3D Vector
//--------------------------
XGINLINE
XGVECTOR3::XGVECTOR3( CONST FLOAT *pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
x = pf[0];
y = pf[1];
z = pf[2];
}
XGINLINE
XGVECTOR3::XGVECTOR3( CONST D3DVECTOR& v )
{
x = v.x;
y = v.y;
z = v.z;
}
XGINLINE
XGVECTOR3::XGVECTOR3( FLOAT fx, FLOAT fy, FLOAT fz )
{
x = fx;
y = fy;
z = fz;
}
// casting
XGINLINE
XGVECTOR3::operator FLOAT* ()
{
return (FLOAT *) &x;
}
XGINLINE
XGVECTOR3::operator CONST FLOAT* () const
{
return (CONST FLOAT *) &x;
}
// assignment operators
XGINLINE XGVECTOR3&
XGVECTOR3::operator += ( CONST XGVECTOR3& v )
{
x += v.x;
y += v.y;
z += v.z;
return *this;
}
XGINLINE XGVECTOR3&
XGVECTOR3::operator -= ( CONST XGVECTOR3& v )
{
x -= v.x;
y -= v.y;
z -= v.z;
return *this;
}
XGINLINE XGVECTOR3&
XGVECTOR3::operator *= ( FLOAT f )
{
x *= f;
y *= f;
z *= f;
return *this;
}
XGINLINE XGVECTOR3&
XGVECTOR3::operator /= ( FLOAT f )
{
FLOAT fInv = 1.0f / f;
x *= fInv;
y *= fInv;
z *= fInv;
return *this;
}
// unary operators
XGINLINE XGVECTOR3
XGVECTOR3::operator + () const
{
return *this;
}
XGINLINE XGVECTOR3
XGVECTOR3::operator - () const
{
return XGVECTOR3(-x, -y, -z);
}
// binary operators
XGINLINE XGVECTOR3
XGVECTOR3::operator + ( CONST XGVECTOR3& v ) const
{
return XGVECTOR3(x + v.x, y + v.y, z + v.z);
}
XGINLINE XGVECTOR3
XGVECTOR3::operator - ( CONST XGVECTOR3& v ) const
{
return XGVECTOR3(x - v.x, y - v.y, z - v.z);
}
XGINLINE XGVECTOR3
XGVECTOR3::operator * ( FLOAT f ) const
{
return XGVECTOR3(x * f, y * f, z * f);
}
XGINLINE XGVECTOR3
XGVECTOR3::operator / ( FLOAT f ) const
{
FLOAT fInv = 1.0f / f;
return XGVECTOR3(x * fInv, y * fInv, z * fInv);
}
XGINLINE XGVECTOR3
operator * ( FLOAT f, CONST struct XGVECTOR3& v )
{
return XGVECTOR3(f * v.x, f * v.y, f * v.z);
}
XGINLINE BOOL
XGVECTOR3::operator == ( CONST XGVECTOR3& v ) const
{
return x == v.x && y == v.y && z == v.z;
}
XGINLINE BOOL
XGVECTOR3::operator != ( CONST XGVECTOR3& v ) const
{
return x != v.x || y != v.y || z != v.z;
}
//--------------------------
// 4D Vector
//--------------------------
XGINLINE
XGVECTOR4::XGVECTOR4( CONST FLOAT *pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
x = pf[0];
y = pf[1];
z = pf[2];
w = pf[3];
}
XGINLINE
XGVECTOR4::XGVECTOR4( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
{
x = fx;
y = fy;
z = fz;
w = fw;
}
// casting
XGINLINE
XGVECTOR4::operator FLOAT* ()
{
return (FLOAT *) &x;
}
XGINLINE
XGVECTOR4::operator CONST FLOAT* () const
{
return (CONST FLOAT *) &x;
}
// assignment operators
XGINLINE XGVECTOR4&
XGVECTOR4::operator += ( CONST XGVECTOR4& v )
{
x += v.x;
y += v.y;
z += v.z;
w += v.w;
return *this;
}
XGINLINE XGVECTOR4&
XGVECTOR4::operator -= ( CONST XGVECTOR4& v )
{
x -= v.x;
y -= v.y;
z -= v.z;
w -= v.w;
return *this;
}
XGINLINE XGVECTOR4&
XGVECTOR4::operator *= ( FLOAT f )
{
x *= f;
y *= f;
z *= f;
w *= f;
return *this;
}
XGINLINE XGVECTOR4&
XGVECTOR4::operator /= ( FLOAT f )
{
FLOAT fInv = 1.0f / f;
x *= fInv;
y *= fInv;
z *= fInv;
w *= fInv;
return *this;
}
// unary operators
XGINLINE XGVECTOR4
XGVECTOR4::operator + () const
{
return *this;
}
XGINLINE XGVECTOR4
XGVECTOR4::operator - () const
{
return XGVECTOR4(-x, -y, -z, -w);
}
// binary operators
XGINLINE XGVECTOR4
XGVECTOR4::operator + ( CONST XGVECTOR4& v ) const
{
return XGVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
}
XGINLINE XGVECTOR4
XGVECTOR4::operator - ( CONST XGVECTOR4& v ) const
{
return XGVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
}
XGINLINE XGVECTOR4
XGVECTOR4::operator * ( FLOAT f ) const
{
return XGVECTOR4(x * f, y * f, z * f, w * f);
}
XGINLINE XGVECTOR4
XGVECTOR4::operator / ( FLOAT f ) const
{
FLOAT fInv = 1.0f / f;
return XGVECTOR4(x * fInv, y * fInv, z * fInv, w * fInv);
}
XGINLINE XGVECTOR4
operator * ( FLOAT f, CONST XGVECTOR4& v )
{
return XGVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
}
XGINLINE BOOL
XGVECTOR4::operator == ( CONST XGVECTOR4& v ) const
{
return x == v.x && y == v.y && z == v.z && w == v.w;
}
XGINLINE BOOL
XGVECTOR4::operator != ( CONST XGVECTOR4& v ) const
{
return x != v.x || y != v.y || z != v.z || w != v.w;
}
//--------------------------
// Matrix
//--------------------------
XGINLINE
XGMATRIX::XGMATRIX( CONST FLOAT* pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
memcpy(&_11, pf, sizeof(XGMATRIX));
}
XGINLINE
XGMATRIX::XGMATRIX( CONST D3DMATRIX& mat )
{
memcpy(&_11, &mat, sizeof(XGMATRIX));
}
XGINLINE
XGMATRIX::XGMATRIX( FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44 )
{
_11 = f11; _12 = f12; _13 = f13; _14 = f14;
_21 = f21; _22 = f22; _23 = f23; _24 = f24;
_31 = f31; _32 = f32; _33 = f33; _34 = f34;
_41 = f41; _42 = f42; _43 = f43; _44 = f44;
}
// access grants
XGINLINE FLOAT&
XGMATRIX::operator () ( UINT iRow, UINT iCol )
{
return m[iRow][iCol];
}
XGINLINE FLOAT
XGMATRIX::operator () ( UINT iRow, UINT iCol ) const
{
return m[iRow][iCol];
}
// casting operators
XGINLINE
XGMATRIX::operator FLOAT* ()
{
return (FLOAT *) &_11;
}
XGINLINE
XGMATRIX::operator CONST FLOAT* () const
{
return (CONST FLOAT *) &_11;
}
// assignment operators
XGINLINE XGMATRIX&
XGMATRIX::operator *= ( CONST XGMATRIX& mat )
{
XGMatrixMultiply(this, this, &mat);
return *this;
}
XGINLINE XGMATRIX&
XGMATRIX::operator += ( CONST XGMATRIX& mat )
{
_11 += mat._11; _12 += mat._12; _13 += mat._13; _14 += mat._14;
_21 += mat._21; _22 += mat._22; _23 += mat._23; _24 += mat._24;
_31 += mat._31; _32 += mat._32; _33 += mat._33; _34 += mat._34;
_41 += mat._41; _42 += mat._42; _43 += mat._43; _44 += mat._44;
return *this;
}
XGINLINE XGMATRIX&
XGMATRIX::operator -= ( CONST XGMATRIX& mat )
{
_11 -= mat._11; _12 -= mat._12; _13 -= mat._13; _14 -= mat._14;
_21 -= mat._21; _22 -= mat._22; _23 -= mat._23; _24 -= mat._24;
_31 -= mat._31; _32 -= mat._32; _33 -= mat._33; _34 -= mat._34;
_41 -= mat._41; _42 -= mat._42; _43 -= mat._43; _44 -= mat._44;
return *this;
}
XGINLINE XGMATRIX&
XGMATRIX::operator *= ( FLOAT f )
{
_11 *= f; _12 *= f; _13 *= f; _14 *= f;
_21 *= f; _22 *= f; _23 *= f; _24 *= f;
_31 *= f; _32 *= f; _33 *= f; _34 *= f;
_41 *= f; _42 *= f; _43 *= f; _44 *= f;
return *this;
}
XGINLINE XGMATRIX&
XGMATRIX::operator /= ( FLOAT f )
{
FLOAT fInv = 1.0f / f;
_11 *= fInv; _12 *= fInv; _13 *= fInv; _14 *= fInv;
_21 *= fInv; _22 *= fInv; _23 *= fInv; _24 *= fInv;
_31 *= fInv; _32 *= fInv; _33 *= fInv; _34 *= fInv;
_41 *= fInv; _42 *= fInv; _43 *= fInv; _44 *= fInv;
return *this;
}
// unary operators
XGINLINE XGMATRIX
XGMATRIX::operator + () const
{
return *this;
}
XGINLINE XGMATRIX
XGMATRIX::operator - () const
{
return XGMATRIX(-_11, -_12, -_13, -_14,
-_21, -_22, -_23, -_24,
-_31, -_32, -_33, -_34,
-_41, -_42, -_43, -_44);
}
// binary operators
XGINLINE XGMATRIX
XGMATRIX::operator * ( CONST XGMATRIX& mat ) const
{
XGMATRIX matT;
XGMatrixMultiply(&matT, this, &mat);
return matT;
}
XGINLINE XGMATRIX
XGMATRIX::operator + ( CONST XGMATRIX& mat ) const
{
return XGMATRIX(_11 + mat._11, _12 + mat._12, _13 + mat._13, _14 + mat._14,
_21 + mat._21, _22 + mat._22, _23 + mat._23, _24 + mat._24,
_31 + mat._31, _32 + mat._32, _33 + mat._33, _34 + mat._34,
_41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
}
XGINLINE XGMATRIX
XGMATRIX::operator - ( CONST XGMATRIX& mat ) const
{
return XGMATRIX(_11 - mat._11, _12 - mat._12, _13 - mat._13, _14 - mat._14,
_21 - mat._21, _22 - mat._22, _23 - mat._23, _24 - mat._24,
_31 - mat._31, _32 - mat._32, _33 - mat._33, _34 - mat._34,
_41 - mat._41, _42 - mat._42, _43 - mat._43, _44 - mat._44);
}
XGINLINE XGMATRIX
XGMATRIX::operator * ( FLOAT f ) const
{
return XGMATRIX(_11 * f, _12 * f, _13 * f, _14 * f,
_21 * f, _22 * f, _23 * f, _24 * f,
_31 * f, _32 * f, _33 * f, _34 * f,
_41 * f, _42 * f, _43 * f, _44 * f);
}
XGINLINE XGMATRIX
XGMATRIX::operator / ( FLOAT f ) const
{
FLOAT fInv = 1.0f / f;
return XGMATRIX(_11 * fInv, _12 * fInv, _13 * fInv, _14 * fInv,
_21 * fInv, _22 * fInv, _23 * fInv, _24 * fInv,
_31 * fInv, _32 * fInv, _33 * fInv, _34 * fInv,
_41 * fInv, _42 * fInv, _43 * fInv, _44 * fInv);
}
XGINLINE XGMATRIX
operator * ( FLOAT f, CONST XGMATRIX& mat )
{
return XGMATRIX(f * mat._11, f * mat._12, f * mat._13, f * mat._14,
f * mat._21, f * mat._22, f * mat._23, f * mat._24,
f * mat._31, f * mat._32, f * mat._33, f * mat._34,
f * mat._41, f * mat._42, f * mat._43, f * mat._44);
}
XGINLINE BOOL
XGMATRIX::operator == ( CONST XGMATRIX& mat ) const
{
return 0 == memcmp(this, &mat, sizeof(XGMATRIX));
}
XGINLINE BOOL
XGMATRIX::operator != ( CONST XGMATRIX& mat ) const
{
return 0 != memcmp(this, &mat, sizeof(XGMATRIX));
}
//--------------------------
// Quaternion
//--------------------------
XGINLINE
XGQUATERNION::XGQUATERNION( CONST FLOAT* pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
x = pf[0];
y = pf[1];
z = pf[2];
w = pf[3];
}
XGINLINE
XGQUATERNION::XGQUATERNION( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
{
x = fx;
y = fy;
z = fz;
w = fw;
}
// casting
XGINLINE
XGQUATERNION::operator FLOAT* ()
{
return (FLOAT *) &x;
}
XGINLINE
XGQUATERNION::operator CONST FLOAT* () const
{
return (CONST FLOAT *) &x;
}
// assignment operators
XGINLINE XGQUATERNION&
XGQUATERNION::operator += ( CONST XGQUATERNION& q )
{
x += q.x;
y += q.y;
z += q.z;
w += q.w;
return *this;
}
XGINLINE XGQUATERNION&
XGQUATERNION::operator -= ( CONST XGQUATERNION& q )
{
x -= q.x;
y -= q.y;
z -= q.z;
w -= q.w;
return *this;
}
XGINLINE XGQUATERNION&
XGQUATERNION::operator *= ( CONST XGQUATERNION& q )
{
XGQuaternionMultiply(this, this, &q);
return *this;
}
XGINLINE XGQUATERNION&
XGQUATERNION::operator *= ( FLOAT f )
{
x *= f;
y *= f;
z *= f;
w *= f;
return *this;
}
XGINLINE XGQUATERNION&
XGQUATERNION::operator /= ( FLOAT f )
{
FLOAT fInv = 1.0f / f;
x *= fInv;
y *= fInv;
z *= fInv;
w *= fInv;
return *this;
}
// unary operators
XGINLINE XGQUATERNION
XGQUATERNION::operator + () const
{
return *this;
}
XGINLINE XGQUATERNION
XGQUATERNION::operator - () const
{
return XGQUATERNION(-x, -y, -z, -w);
}
// binary operators
XGINLINE XGQUATERNION
XGQUATERNION::operator + ( CONST XGQUATERNION& q ) const
{
return XGQUATERNION(x + q.x, y + q.y, z + q.z, w + q.w);
}
XGINLINE XGQUATERNION
XGQUATERNION::operator - ( CONST XGQUATERNION& q ) const
{
return XGQUATERNION(x - q.x, y - q.y, z - q.z, w - q.w);
}
XGINLINE XGQUATERNION
XGQUATERNION::operator * ( CONST XGQUATERNION& q ) const
{
XGQUATERNION qT;
XGQuaternionMultiply(&qT, this, &q);
return qT;
}
XGINLINE XGQUATERNION
XGQUATERNION::operator * ( FLOAT f ) const
{
return XGQUATERNION(x * f, y * f, z * f, w * f);
}
XGINLINE XGQUATERNION
XGQUATERNION::operator / ( FLOAT f ) const
{
FLOAT fInv = 1.0f / f;
return XGQUATERNION(x * fInv, y * fInv, z * fInv, w * fInv);
}
XGINLINE XGQUATERNION
operator * (FLOAT f, CONST XGQUATERNION& q )
{
return XGQUATERNION(f * q.x, f * q.y, f * q.z, f * q.w);
}
XGINLINE BOOL
XGQUATERNION::operator == ( CONST XGQUATERNION& q ) const
{
return x == q.x && y == q.y && z == q.z && w == q.w;
}
XGINLINE BOOL
XGQUATERNION::operator != ( CONST XGQUATERNION& q ) const
{
return x != q.x || y != q.y || z != q.z || w != q.w;
}
//--------------------------
// Plane
//--------------------------
XGINLINE
XGPLANE::XGPLANE( CONST FLOAT* pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
a = pf[0];
b = pf[1];
c = pf[2];
d = pf[3];
}
XGINLINE
XGPLANE::XGPLANE( FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd )
{
a = fa;
b = fb;
c = fc;
d = fd;
}
// casting
XGINLINE
XGPLANE::operator FLOAT* ()
{
return (FLOAT *) &a;
}
XGINLINE
XGPLANE::operator CONST FLOAT* () const
{
return (CONST FLOAT *) &a;
}
// unary operators
XGINLINE XGPLANE
XGPLANE::operator + () const
{
return *this;
}
XGINLINE XGPLANE
XGPLANE::operator - () const
{
return XGPLANE(-a, -b, -c, -d);
}
// binary operators
XGINLINE BOOL
XGPLANE::operator == ( CONST XGPLANE& p ) const
{
return a == p.a && b == p.b && c == p.c && d == p.d;
}
XGINLINE BOOL
XGPLANE::operator != ( CONST XGPLANE& p ) const
{
return a != p.a || b != p.b || c != p.c || d != p.d;
}
//--------------------------
// Color
//--------------------------
XGINLINE
XGCOLOR::XGCOLOR( DWORD dw )
{
CONST FLOAT f = 1.0f / 255.0f;
r = f * (FLOAT) (unsigned char) (dw >> 16);
g = f * (FLOAT) (unsigned char) (dw >> 8);
b = f * (FLOAT) (unsigned char) (dw >> 0);
a = f * (FLOAT) (unsigned char) (dw >> 24);
}
XGINLINE
XGCOLOR::XGCOLOR( CONST FLOAT* pf )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pf != NULL);
#endif
#endif
r = pf[0];
g = pf[1];
b = pf[2];
a = pf[3];
}
XGINLINE
XGCOLOR::XGCOLOR( CONST D3DCOLORVALUE& c )
{
r = c.r;
g = c.g;
b = c.b;
a = c.a;
}
XGINLINE
XGCOLOR::XGCOLOR( FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa )
{
r = fr;
g = fg;
b = fb;
a = fa;
}
// casting
XGINLINE
XGCOLOR::operator DWORD () const
{
FLOAT R = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (r * 255.0f + 0.5f);
FLOAT G = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (g * 255.0f + 0.5f);
FLOAT B = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (b * 255.0f + 0.5f);
FLOAT A = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (a * 255.0f + 0.5f);
__asm {
cvtss2si eax, B
cvtss2si edx, A
shl edx, 24
or eax, edx
cvtss2si edx, R
shl edx, 16
or eax, edx
cvtss2si edx, G
shl edx, 8
or eax, edx
}
}
XGINLINE
XGCOLOR::operator FLOAT * ()
{
return (FLOAT *) &r;
}
XGINLINE
XGCOLOR::operator CONST FLOAT * () const
{
return (CONST FLOAT *) &r;
}
XGINLINE
XGCOLOR::operator D3DCOLORVALUE * ()
{
return (D3DCOLORVALUE *) &r;
}
XGINLINE
XGCOLOR::operator CONST D3DCOLORVALUE * () const
{
return (CONST D3DCOLORVALUE *) &r;
}
XGINLINE
XGCOLOR::operator D3DCOLORVALUE& ()
{
return *((D3DCOLORVALUE *) &r);
}
XGINLINE
XGCOLOR::operator CONST D3DCOLORVALUE& () const
{
return *((CONST D3DCOLORVALUE *) &r);
}
// assignment operators
XGINLINE XGCOLOR&
XGCOLOR::operator += ( CONST XGCOLOR& c )
{
r += c.r;
g += c.g;
b += c.b;
a += c.a;
return *this;
}
XGINLINE XGCOLOR&
XGCOLOR::operator -= ( CONST XGCOLOR& c )
{
r -= c.r;
g -= c.g;
b -= c.b;
a -= c.a;
return *this;
}
XGINLINE XGCOLOR&
XGCOLOR::operator *= ( FLOAT f )
{
r *= f;
g *= f;
b *= f;
a *= f;
return *this;
}
XGINLINE XGCOLOR&
XGCOLOR::operator /= ( FLOAT f )
{
FLOAT fInv = 1.0f / f;
r *= fInv;
g *= fInv;
b *= fInv;
a *= fInv;
return *this;
}
// unary operators
XGINLINE XGCOLOR
XGCOLOR::operator + () const
{
return *this;
}
XGINLINE XGCOLOR
XGCOLOR::operator - () const
{
return XGCOLOR(-r, -g, -b, -a);
}
// binary operators
XGINLINE XGCOLOR
XGCOLOR::operator + ( CONST XGCOLOR& c ) const
{
return XGCOLOR(r + c.r, g + c.g, b + c.b, a + c.a);
}
XGINLINE XGCOLOR
XGCOLOR::operator - ( CONST XGCOLOR& c ) const
{
return XGCOLOR(r - c.r, g - c.g, b - c.b, a - c.a);
}
XGINLINE XGCOLOR
XGCOLOR::operator * ( FLOAT f ) const
{
return XGCOLOR(r * f, g * f, b * f, a * f);
}
XGINLINE XGCOLOR
XGCOLOR::operator / ( FLOAT f ) const
{
FLOAT fInv = 1.0f / f;
return XGCOLOR(r * fInv, g * fInv, b * fInv, a * fInv);
}
XGINLINE XGCOLOR
operator * (FLOAT f, CONST XGCOLOR& c )
{
return XGCOLOR(f * c.r, f * c.g, f * c.b, f * c.a);
}
XGINLINE BOOL
XGCOLOR::operator == ( CONST XGCOLOR& c ) const
{
return r == c.r && g == c.g && b == c.b && a == c.a;
}
XGINLINE BOOL
XGCOLOR::operator != ( CONST XGCOLOR& c ) const
{
return r != c.r || g != c.g || b != c.b || a != c.a;
}
#endif //__cplusplus
//===========================================================================
//
// Inline functions
//
//===========================================================================
//--------------------------
// 2D Vector
//--------------------------
XGINLINE FLOAT XGVec2Length
( CONST XGVECTOR2 *pV )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV != NULL);
#endif
#endif
__asm {
mov edx, pV
movups xmm1, [edx]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 1h
addps xmm1, xmm0
sqrtss xmm1, xmm1
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec2LengthSq
( CONST XGVECTOR2 *pV )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV != NULL);
#endif
#endif
__asm {
mov edx, pV
movups xmm1, [edx]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 1h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec2Dot
( CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2 )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movlps xmm1, [edx]
mov ecx, pV2
movlps xmm2, [ecx]
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 1h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec2CCW
( CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV1 != NULL && pV2 != NULL);
#endif
#endif
return pV1->x * pV2->y - pV1->y * pV2->x;
}
XGINLINE XGVECTOR2* XGVec2Add
( XGVECTOR2 *pOut, CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movlps xmm1, [edx]
mov ecx, pV2
movlps xmm2, [ecx]
addps xmm1, xmm2
mov eax, pOut
movlps [eax], xmm1
}
}
XGINLINE XGVECTOR2* XGVec2Subtract
( XGVECTOR2 *pOut, CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movlps xmm1, [edx]
mov ecx, pV2
movlps xmm2, [ecx]
subps xmm1, xmm2
mov eax, pOut
movlps [eax], xmm1
}
}
XGINLINE XGVECTOR2* XGVec2Minimize
( XGVECTOR2 *pOut, CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
mov edx, pV2
movlps xmm0, [ecx]
movlps xmm1, [edx]
minps xmm0, xmm1
mov eax, pOut
movlps [eax], xmm0
}
}
XGINLINE XGVECTOR2* XGVec2Maximize
( XGVECTOR2 *pOut, CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
mov edx, pV2
movlps xmm0, [ecx]
movlps xmm1, [edx]
maxps xmm0, xmm1
mov eax, pOut
movlps [eax], xmm0
}
}
XGINLINE XGVECTOR2* XGVec2Scale
( XGVECTOR2 *pOut, CONST XGVECTOR2 *pV, FLOAT s )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV != NULL);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov ecx, pV
movlps xmm1, [ecx]
mulps xmm0, xmm1
mov eax, pOut
movlps [eax], xmm0
}
}
XGINLINE XGVECTOR2* XGVec2Lerp
( XGVECTOR2 *pOut, CONST XGVECTOR2 *pV1, CONST XGVECTOR2 *pV2,
FLOAT s )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov ecx, pV1
movlps xmm1, [ecx]
mov edx, pV2
movlps xmm2, [edx]
subps xmm2, xmm1
mulps xmm0, xmm2
addps xmm0, xmm1
mov eax, pOut
movlps [eax], xmm0
}
}
//--------------------------
// 3D Vector
//--------------------------
XGINLINE FLOAT XGVec3Length
( CONST XGVECTOR3 *pV )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV != NULL);
#endif
#endif
__asm {
mov edx, pV
movss xmm1, [edx]
movhps xmm1, [edx+4]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 32h
addps xmm1, xmm0
shufps xmm0, xmm0, 32h
addps xmm1, xmm0
sqrtss xmm1, xmm1
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec3LengthSq
( CONST XGVECTOR3 *pV )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV != NULL);
#endif
#endif
__asm {
mov edx, pV
movss xmm1, [edx]
movhps xmm1, [edx+4]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 32h
addps xmm1, xmm0
shufps xmm0, xmm0, 32h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec3Dot
( CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2 )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movss xmm1, [edx]
movhps xmm1, [edx+4]
mov edx, pV2
movss xmm2, [edx]
movhps xmm2, [edx+4]
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 32h
addps xmm1, xmm0
shufps xmm0, xmm0, 32h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE XGVECTOR3* XGVec3Cross
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2 )
{
XGVECTOR3 v;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
v.x = pV1->y * pV2->z - pV1->z * pV2->y;
v.y = pV1->z * pV2->x - pV1->x * pV2->z;
v.z = pV1->x * pV2->y - pV1->y * pV2->x;
*pOut = v;
return pOut;
}
XGINLINE XGVECTOR3* XGVec3Add
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
movss xmm0, [ecx]
movhps xmm0, [ecx+4]
mov edx, pV2
movss xmm1, [edx]
movhps xmm1, [edx+4]
addps xmm0, xmm1
mov eax, pOut
movss [eax], xmm0
movhps [eax+4], xmm0
}
}
XGINLINE XGVECTOR3* XGVec3Subtract
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
movss xmm0, [ecx]
movhps xmm0, [ecx+4]
mov edx, pV2
movss xmm1, [edx]
movhps xmm1, [edx+4]
subps xmm0, xmm1
mov eax, pOut
movss [eax], xmm0
movhps [eax+4], xmm0
}
}
XGINLINE XGVECTOR3* XGVec3Minimize
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
movss xmm0, [ecx]
movhps xmm0, [ecx+4]
mov edx, pV2
movss xmm1, [edx]
movhps xmm1, [edx+4]
minps xmm0, xmm1
mov eax, pOut
movss [eax], xmm0
movhps [eax+4], xmm0
}
}
XGINLINE XGVECTOR3* XGVec3Maximize
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2 )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
movss xmm0, [ecx]
movhps xmm0, [ecx+4]
mov edx, pV2
movss xmm1, [edx]
movhps xmm1, [edx+4]
maxps xmm0, xmm1
mov eax, pOut
movss [eax], xmm0
movhps [eax+4], xmm0
}
}
XGINLINE XGVECTOR3* XGVec3Scale
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV, FLOAT s)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV != NULL);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov edx, pV
movss xmm1, [edx]
movhps xmm1, [edx+4]
mulps xmm0, xmm1
mov eax, pOut
movss [eax], xmm0
movhps [eax+4], xmm0
}
}
XGINLINE XGVECTOR3* XGVec3Lerp
( XGVECTOR3 *pOut, CONST XGVECTOR3 *pV1, CONST XGVECTOR3 *pV2,
FLOAT s )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
movss xmm1, [ecx]
movhps xmm1, [ecx+4]
mov edx, pV2
movss xmm2, [edx]
movhps xmm2, [edx+4]
subps xmm2, xmm1
movss xmm0, s
shufps xmm0, xmm0, 0h
mulps xmm0, xmm2
addps xmm0, xmm1
mov eax, pOut
movss [eax], xmm0
movhps [eax+4], xmm0
}
}
//--------------------------
// 4D Vector
//--------------------------
XGINLINE FLOAT XGVec4Length
( CONST XGVECTOR4 *pV )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV != NULL);
#endif
#endif
__asm {
mov edx, pV
movups xmm1, [edx]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
sqrtss xmm1, xmm1
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec4LengthSq
( CONST XGVECTOR4 *pV )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV != NULL);
#endif
#endif
__asm {
mov edx, pV
movups xmm1, [edx]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGVec4Dot
( CONST XGVECTOR4 *pV1, CONST XGVECTOR4 *pV2 )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movups xmm1, [edx]
mov ecx, pV2
movups xmm2, [ecx]
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE XGVECTOR4* XGVec4Add
( XGVECTOR4 *pOut, CONST XGVECTOR4 *pV1, CONST XGVECTOR4 *pV2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movups xmm1, [edx]
mov ecx, pV2
movups xmm2, [ecx]
addps xmm1, xmm2
mov eax, pOut
movups [eax], xmm1
}
}
XGINLINE XGVECTOR4* XGVec4Subtract
( XGVECTOR4 *pOut, CONST XGVECTOR4 *pV1, CONST XGVECTOR4 *pV2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov edx, pV1
movups xmm1, [edx]
mov ecx, pV2
movups xmm2, [ecx]
subps xmm1, xmm2
mov eax, pOut
movups [eax], xmm1
}
}
XGINLINE XGVECTOR4* XGVec4Minimize
( XGVECTOR4 *pOut, CONST XGVECTOR4 *pV1, CONST XGVECTOR4 *pV2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
mov edx, pV2
movups xmm0, [ecx]
movups xmm1, [edx]
minps xmm0, xmm1
mov eax, pOut
movups [eax], xmm0
}
}
XGINLINE XGVECTOR4* XGVec4Maximize
( XGVECTOR4 *pOut, CONST XGVECTOR4 *pV1, CONST XGVECTOR4 *pV2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
mov ecx, pV1
mov edx, pV2
movups xmm0, [ecx]
movups xmm1, [edx]
maxps xmm0, xmm1
mov eax, pOut
movups [eax], xmm0
}
}
XGINLINE XGVECTOR4* XGVec4Scale
( XGVECTOR4 *pOut, CONST XGVECTOR4 *pV, FLOAT s)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov ecx, pV
movups xmm1, [ecx]
mulps xmm0, xmm1
mov eax, pOut
movups [eax], xmm0
}
}
XGINLINE XGVECTOR4* XGVec4Lerp
( XGVECTOR4 *pOut, CONST XGVECTOR4 *pV1, CONST XGVECTOR4 *pV2,
FLOAT s )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pV1 != NULL && pV2 != NULL);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov ecx, pV1
movups xmm1, [ecx]
mov edx, pV2
movups xmm2, [edx]
subps xmm2, xmm1
mulps xmm0, xmm2
addps xmm0, xmm1
mov eax, pOut
movups [eax], xmm0
}
}
//--------------------------
// 4D Matrix
//--------------------------
XGINLINE XGMATRIX* XGMatrixIdentity
( XGMATRIX *pOut )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL);
#endif
#endif
pOut->m[0][1] = pOut->m[0][2] = pOut->m[0][3] =
pOut->m[1][0] = pOut->m[1][2] = pOut->m[1][3] =
pOut->m[2][0] = pOut->m[2][1] = pOut->m[2][3] =
pOut->m[3][0] = pOut->m[3][1] = pOut->m[3][2] = 0.0f;
pOut->m[0][0] = pOut->m[1][1] = pOut->m[2][2] = pOut->m[3][3] = 1.0f;
return pOut;
}
XGINLINE BOOL XGMatrixIsIdentity
( CONST XGMATRIX *pM )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pM != NULL);
#endif
#endif
return pM->m[0][0] == 1.0f && pM->m[0][1] == 0.0f && pM->m[0][2] == 0.0f && pM->m[0][3] == 0.0f &&
pM->m[1][0] == 0.0f && pM->m[1][1] == 1.0f && pM->m[1][2] == 0.0f && pM->m[1][3] == 0.0f &&
pM->m[2][0] == 0.0f && pM->m[2][1] == 0.0f && pM->m[2][2] == 1.0f && pM->m[2][3] == 0.0f &&
pM->m[3][0] == 0.0f && pM->m[3][1] == 0.0f && pM->m[3][2] == 0.0f && pM->m[3][3] == 1.0f;
}
//--------------------------
// Quaternion
//--------------------------
XGINLINE FLOAT XGQuaternionLength
( CONST XGQUATERNION *pQ )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pQ != NULL);
#endif
#endif
__asm {
mov edx, pQ
movups xmm1, [edx]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
sqrtss xmm1, xmm1
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGQuaternionLengthSq
( CONST XGQUATERNION *pQ )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pQ != NULL);
#endif
#endif
__asm {
mov edx, pQ
movups xmm1, [edx]
movaps xmm2, xmm1
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGQuaternionDot
( CONST XGQUATERNION *pQ1, CONST XGQUATERNION *pQ2 )
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pQ1 != NULL && pQ2 != NULL);
#endif
#endif
__asm {
mov edx, pQ1
movups xmm1, [edx]
mov ecx, pQ2
movups xmm2, [ecx]
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE XGQUATERNION* XGQuaternionIdentity
( XGQUATERNION *pOut )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL);
#endif
#endif
pOut->x = pOut->y = pOut->z = 0.0f;
pOut->w = 1.0f;
return pOut;
}
XGINLINE BOOL XGQuaternionIsIdentity
( CONST XGQUATERNION *pQ )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pQ != NULL);
#endif
#endif
return pQ->x == 0.0f && pQ->y == 0.0f && pQ->z == 0.0f && pQ->w == 1.0f;
}
XGINLINE XGQUATERNION* XGQuaternionConjugate
( XGQUATERNION *pOut, CONST XGQUATERNION *pQ )
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pQ != NULL);
#endif
#endif
pOut->x = -pQ->x;
pOut->y = -pQ->y;
pOut->z = -pQ->z;
pOut->w = pQ->w;
return pOut;
}
//--------------------------
// Plane
//--------------------------
XGINLINE FLOAT XGPlaneDot
( CONST XGPLANE *pP, CONST XGVECTOR4 *pV)
{
FLOAT res;
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pP != NULL && pV != NULL);
#endif
#endif
__asm {
mov edx, pP
movups xmm1, [edx]
mov ecx, pV
movups xmm2, [ecx]
mulps xmm1, xmm2
movaps xmm0, xmm1
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
shufps xmm0, xmm0, 93h
addps xmm1, xmm0
movss [res], xmm1
}
return res;
}
XGINLINE FLOAT XGPlaneDotCoord
( CONST XGPLANE *pP, CONST XGVECTOR3 *pV)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pP != NULL && pV != NULL);
#endif
#endif
return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d;
}
XGINLINE FLOAT XGPlaneDotNormal
( CONST XGPLANE *pP, CONST XGVECTOR3 *pV)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pP != NULL && pV != NULL);
#endif
#endif
return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z;
}
//--------------------------
// Color
//--------------------------
XGINLINE XGCOLOR* XGColorNegative
(XGCOLOR *pOut, CONST XGCOLOR *pC)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pC != NULL);
#endif
#endif
pOut->r = 1.0f - pC->r;
pOut->g = 1.0f - pC->g;
pOut->b = 1.0f - pC->b;
pOut->a = pC->a;
return pOut;
}
XGINLINE XGCOLOR* XGColorAdd
(XGCOLOR *pOut, CONST XGCOLOR *pC1, CONST XGCOLOR *pC2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pC1 != NULL && pC2 != NULL);
#endif
#endif
__asm {
mov edx, pC1
movups xmm1, [edx]
mov ecx, pC2
movups xmm2, [ecx]
addps xmm1, xmm2
mov eax, pOut
movups [eax], xmm1
}
}
XGINLINE XGCOLOR* XGColorSubtract
(XGCOLOR *pOut, CONST XGCOLOR *pC1, CONST XGCOLOR *pC2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pC1 != NULL && pC2 != NULL);
#endif
#endif
__asm {
mov edx, pC1
movups xmm1, [edx]
mov ecx, pC2
movups xmm2, [ecx]
subps xmm1, xmm2
mov eax, pOut
movups [eax], xmm1
}
}
XGINLINE XGCOLOR* XGColorScale
(XGCOLOR *pOut, CONST XGCOLOR *pC, FLOAT s)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pC != NULL);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov ecx, pC
movups xmm1, [ecx]
mulps xmm0, xmm1
mov eax, pOut
movups [eax], xmm0
}
}
XGINLINE XGCOLOR* XGColorModulate
(XGCOLOR *pOut, CONST XGCOLOR *pC1, CONST XGCOLOR *pC2)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pC1 != NULL && pC2 != NULL);
#endif
#endif
__asm {
mov edx, pC1
movups xmm1, [edx]
mov ecx, pC2
movups xmm2, [ecx]
mulps xmm1, xmm2
mov eax, pOut
movups [eax], xmm1
}
}
XGINLINE XGCOLOR* XGColorLerp
(XGCOLOR *pOut, CONST XGCOLOR *pC1, CONST XGCOLOR *pC2, FLOAT s)
{
#ifdef _DEBUG
#ifdef ASSERT
ASSERT(pOut != NULL && pC1 != NULL && pC2 != NULL);
#endif
#endif
__asm {
movss xmm0, s
shufps xmm0, xmm0, 0h
mov ecx, pC1
movups xmm1, [ecx]
mov edx, pC2
movups xmm2, [edx]
subps xmm2, xmm1
mulps xmm0, xmm2
addps xmm0, xmm1
mov eax, pOut
movups [eax], xmm0
}
}
#pragma warning(default:4035)
#endif // __XG8MATH_INL__
Reference in New Issue Copy Permalink